在PHP的Zend Engine(下面简称ZE)中,有一个非常重要的数据结构——哈希表(HashTable)。哈希表在ZE中有非常广泛的应用,PHP的复杂数据结构中数组和类的存储和访问就是用哈希表来组织,PHP语言结构中的常量、变量、函数等符号表也是用它来组织。
1. 哈希表的基本概念
什么是哈希表呢?哈希表在数据结构中也叫散列表。是根据键名经过hash函数计算后,映射到表中的一个位置,来直接访问记录,加快了访问速度。在理想情况下,哈希表的操作时间复杂度为O(1)。数据项可以在一个与哈希表长度无关的时间内,计算出一个值hash(key),在固定时间内定位到一个桶(bucket,表示哈希表的一个位置),主要时间消耗在于哈希函数计算和桶的定位。
在分析PHP中HashTable实现原理之前,先介绍一下相关的基本概念:
如下图例子,希望通过人名检索一个数据,键名通过哈希函数,得到指向bucket的指针,最后访问真实的bucket。
键名(Key):在哈希函数转换前,数据的标识。
桶(Bucket):在哈希表中,真正保存数据的容器。
哈希函数(Hash Function):将Key通过哈希函数,得到一个指向bucket的指针。MD5,SHA-1是我们在业务中常用的哈希函数。
哈希冲突(Hash Collision):两个不同的Key,经过哈希函数,得到同一个bucket的指针。
2. PHP的哈希表实现原理
哈希表的结构:
Zend/zend_hash.h
typedef struct _hashtable {
uint nTableSize; //哈希表的长度,不是元素个数
uint nTableMask; //哈希表的掩码,设置为nTableSize-1
uint nNumOfElements; //哈希表实际元素个数
ulong nNextFreeElement; //指向下一个空元素位置
Bucket *pInternalPointer; //用于遍历哈希表的内部指针
Bucket *pListHead; //哈希表队列的头部
Bucket *pListTail; //哈希表队列的尾部
Bucket **arBuckets; //哈希表存储的元素数组
dtor_func_t pDestructor; //哈希表的元素析构函数指针
zend_bool persistent; //是否是持久保存,用于pmalloc的参数,可以持久存储在内存中
unsigned char nApplyCount; // zend_hash_apply的次数,用来限制嵌套遍历的层数,限制为3层
zend_bool bApplyProtection; //是否开启嵌套遍历保护
#if ZEND_DEBUG
int inconsistent;
#endif
} HashTable;
1) nTableSize 哈希表的大小。最小容量是2^3(8),最大容量是2^31(2147483648)。当如果进行一次操作后发现元素个数大于nTableSize,会申请当前nTableSize * 2的空间。假设当前nTableSize为8,当插入元素达到9个的时候,会申请nTableSize=16的空间。
2) nTableMask 为nTableSize-1,用于调整最大索引值。当哈希后值大于索引值时候,把这个值映射到索引值范围内。
3) nNumOfElements HashTable中的个数。数组操作中,sizeof和count函数获取的是这个值。
4) nNextFreeElement 下一个空元素的地址。
5) pInternalPointer 存储了HashTable当前指向的元素的指针,当我们使用一些内部循环函数的时候会用到这个指针比如reset(), current(), prev(), next(), foreach(), end()。相当于游标。
6) pListHead和pListTail则具体指向了该哈希表的第一个和最后一个元素,对应就是数组的起始和结束元素。哈希表的pListHead、pListTail与Bucket的pListNext、pListLast维护了一个哈希表中Bucket的双向链表,按照插入的先后顺序,用于哈希表的遍历。
7) arBuckets 实际存储Buckets的数组。
8) pDestructor 是一个析构函数,当某个值被从哈希表删除的时候会触发此函数。他还有一个主要作用是用于变量的GC回收。在PHP里面GC是通过引用计数实现的,当一个变量的引用计数变为0,就会被PHP的GC回收。
9) persistent 定义了hashtable是否能在多次request中获得持久存在。
10) nApplyCount 和 bApplyProtection 是用来防止嵌套遍历的。
11) inconsistent 是在调试模式下捕获对HT不正确的使用。
Bucket的结构:
typedef struct bucket {
ulong h; //数组索引的哈希值
uint nKeyLength; //索引数组为0,关联数组为key的长度
void *pData; //元素内容的指针
void *pDataPtr; // 如果是指针大小的数据,用pDataPtr直接存储,pData指向pDataPtr
struct bucket *pListNext; //哈希链表中下一个元素
struct bucket *pListLast; //哈希链表中上一个元素
struct bucket *pNext; //解决哈希冲突,变为双向链表,双向链表的下一个元素
struct bucket *pLast; //解决哈希冲突,变为双向链表,双向链表的上一个元素
const char *arKey; //最后一个元素key的名称
} Bucket;
通过下图来表示HashTable的原理:
我们先来看一下,ZE是如何创建一个hash表的。创建并初始化一个Hash比较容易,调用_zend_hash_init函数。PHP的哈希表最小容量8(2^3),最大容量是0x80000000(2^31,即2147483648)。nTableSize会按照2的整数次幂圆整来增加,直到超过预设值的nSize。
Zend/zend_hash.c
ZEND_API int _zend_hash_init(HashTable *ht, uint nSize, hash_func_t pHashFunction, dtor_func_t pDestructor, zend_bool persistent ZEND_FILE_LINE_DC)
{
uint i = 3;
SET_INCONSISTENT(HT_OK);
if (nSize >= 0x80000000) {
/* prevent overflow */
ht->nTableSize = 0x80000000;
} else {
while ((1U << i) < nSize) {
i++;
}
ht->nTableSize = 1 << i;
}
/* 省略哈希表初始化步骤 */
return SUCCESS;
}
1) *ht 是哈希表的指针,这里既可以传入一个已存在的HashTable, 也可以通过内核宏ALLOC_HASHTABLE(ht)来自动申请一块HashTable内存。ALLOC_HASHTABLE(ht)相当于ht=emalloc(sizeof(HashTable))
2) nSize 哈希表能拥有的最大数量。通过预先申请好内存的方式,减少哈希表rehash操作。
3) pHashFunction 自定义哈希函数的钩子
4) pDesctructor 哈希表析构的回调函数,当删除一个哈希表的时候,会调用。
5) persistent 对应HashTable.persistent,当设置为true的时候,不会在RSHUTDOWN阶段自动销毁。
我们通过更新哈希表的操作方式,来分析哈希表的操作机制:
h = zend_inline_hash_func(arKey, nKeyLength);
nIndex = h & ht->nTableMask;
p = ht->arBuckets[nIndex];
while (p != NULL) {
if (p->arKey == arKey ||
((p->h == h) && (p->nKeyLength == nKeyLength) && !memcmp(p->arKey, arKey, nKeyLength))) {
if (flag & HASH_ADD) {
return FAILURE;
}
/* 省略 */
UPDATE_DATA(ht, p, pData, nDataSize); // 找到h 和 Key都相等的Buckets,说明需要更新
/* 省略 */
}
p = p->pNext; // 这里说明有哈希冲突,按照Buckets[nIndex]的链表找下去
}
/* 省略 */
p->nKeyLength = nKeyLength;
INIT_DATA(ht, p, pData, nDataSize); // 把Bucket.pData数据更新
p->h = h;
CONNECT_TO_BUCKET_DLLIST(p, ht->arBuckets[nIndex]); // 挂到
if (pDest) {
*pDest = p->pData;
}
HANDLE_BLOCK_INTERRUPTIONS();
CONNECT_TO_GLOBAL_DLLIST(p, ht);
ht->arBuckets[nIndex] = p;
HANDLE_UNBLOCK_INTERRUPTIONS();
ht->nNumOfElements++;
ZEND_HASH_IF_FULL_DO_RESIZE(ht); /* 如果哈希表满了,重新散列,这里有一定开销 */
1) 通过哈希算法 times33(Key) & (nTableSize-1) ,生成Key对应的哈希值A,获取arBuckets[A]的值
2) 判断arBuckets[A]是否存在,如果存在而且没有哈希冲突,进行数据update(UPDATE_DATA)。如果存在但是Key不相同说明有哈希冲突,在arBuckets[A]链表中寻找Key是否存在,如果存在,执行update操作(UPDATE_DATA)
3) 如果arBuckets[A]不存在,创建新的arBucket[A](INIT_DATA)。或哈希冲突情况下,在arBuckets[A]的链表中找不到Key。创建新的bucket(INIT_DATA),并把新的buckets放在arBucket[A]链表头
4) 维护哈希表的逻辑链表(CONNECT_TO_GLOBAL_DLLIST)。
5) 如果发现新插入元素已经超过HashTable的nTableSize,自动扩容至2倍nTableSize,重新哈希后维护新的HashTable。
3. PHP使用的哈希函数
PHP的哈希表是用Times33哈希算法,又称为DJBX33A。这是一个使用比较广泛的对字符串的哈希算法,计算速度快,散列均匀,Perl和Apache都使用了这个算法。算法原理就是不断的乘以33,其算法原型如下:
hash(i) = hash(i-1) * 33 + str[i]
为什么是33呢?对于33这个数,DJB注释中是说,1到256之间的所有奇数,都能达到一个可接受的哈希分布,平均分布大概是86%。而其中33,17,31,63,127,129这几个数在面对大量的哈希运算时有一个更大的优势,就是这些数字能将乘法用位运算配合加减法替换,这样运算速度会更高。gcc编译器开启优化后会自动将乘法转换为位运算。PHP实际算法如下:
static inline ulong zend_inline_hash_func(const char *arKey, uint nKeyLength)
{
register ulong hash = 5381;
/* variant with the hash unrolled eight times */
for (; nKeyLength >= 8; nKeyLength -= 8) {
hash = ((hash << 5) + hash) + *arKey++;
hash = ((hash << 5) + hash) + *arKey++;
hash = ((hash << 5) + hash) + *arKey++;
hash = ((hash << 5) + hash) + *arKey++;
hash = ((hash << 5) + hash) + *arKey++;
hash = ((hash << 5) + hash) + *arKey++;
hash = ((hash << 5) + hash) + *arKey++;
hash = ((hash << 5) + hash) + *arKey++;
}
switch (nKeyLength) {
case 7: hash = ((hash << 5) + hash) + *arKey++; /* fallthrough... */
case 6: hash = ((hash << 5) + hash) + *arKey++; /* fallthrough... */
case 5: hash = ((hash << 5) + hash) + *arKey++; /* fallthrough... */
case 4: hash = ((hash << 5) + hash) + *arKey++; /* fallthrough... */
case 3: hash = ((hash << 5) + hash) + *arKey++; /* fallthrough... */
case 2: hash = ((hash << 5) + hash) + *arKey++; /* fallthrough... */
case 1: hash = ((hash << 5) + hash) + *arKey++; break;
case 0: break;
EMPTY_SWITCH_DEFAULT_CASE()
}
return hash;
}
PHP在哈希算法上有所优化,使用了(hash<<5)+hash,效率有所提高。至于hash的初始值为什么为一个大素数5381,要数学上来解释了,不是很理解。
4. 操作哈希表的内部函数
PHP的变量符号表是通过哈希表来维护,首先介绍一下再PHP扩展中如何创建一个新的变量。
ZEND_FUNCTION(variable_creation)
{
zval *new_var1, *new_var2, *new_var3; //创建两个新的变量容器
char *string_contents = "This is a new string variable";
MAKE_STD_ZVAL(new_var1); //为new_var1申请空间并初始化
MAKE_STD_ZVAL(new_var2);
ZVAL_LONG(new_var1, 10); //设置new_var1并赋值为long
ZVAL_LONG(new_var2, 5);
ZVAL_STRINGL(new_var3, string_contents, sizeof(string_contents), 0); //设置new_var3为字符串
ZEND_SET_SYMBOL(EG(active_symbol_table), "local_variable", new_var1); //设置long_variable为函数variable_creation的局部变量
ZEND_SET_SYMBOL(&EG(symbol_table), "global_variable", new_var2); //设置global_variable为全局变量
zend_hash_update(
&EG(symbol_table),
"new_var3",
strlen("new_var3") + 1,
&new_var3,
sizeof(zval *),
NULL
);
RETURN_NULL();
}
这里的zend_hash_update会更新变量符号表。PHP的数组也是用哈希表来维护,下面通过操作一个array来解释如何使用哈希表来才做数组。
增加一个关联数组:
zval *new_array, *new_element;
char *key = "element_key";
MAKE_STD_ZVAL(new_array);
MAKE_STD_ZVAL(new_element);
array_init(new_array);
ZVAL_LONG(new_element, 10);
if(zend_hash_update(new_array->value.ht, key, strlen(key) + 1, (void *)&new_element, sizeof(zval *), NULL) == FAILURE)
{
// do error handling here
}
增加一个索引数组:
zval *new_array, *new_element;
int key = 2;
MAKE_STD_ZVAL(new_array);
MAKE_STD_ZVAL(new_element);
array_init(new_array);
ZVAL_LONG(new_element, 10);
if(zend_hash_index_update(new_array->value.ht, key, (void *)&new_element, sizeof(zval *), NULL) == FAILURE)
{
// do error handling here
}
哈希表的增删改查
int zend_hash_add( HashTable *ht, char *arKey, uint nKeyLen,void *pData, uint nDataSize, void **pDest);
int zend_hash_update( HashTable *ht, char *arKey, uint nKeyLen, void *pData, uint nDataSize, void **pDest);
int zend_hash_index_update( HashTable *ht, ulong h, void *pData, uint nDataSize, void **pDest);//与zend_hash_update类似,不过哈希值计算是用h&TableMask
int zend_hash_next_index_insert(HashTable *ht, void *pData, uint nDataSize, void **pDest);
int zend_hash_find(HashTable *ht, char *arKey, uint nKeyLength,void **pData);
int zend_hash_index_find(HashTable *ht, ulong h, void **pData);
ZEND_API int zend_hash_exists(const HashTable *ht, const char *arKey, uint nKeyLength)
ZEND_API ulong zend_get_hash_value(const char *arKey, uint nKeyLength)
ZEND_API void zend_hash_merge_ex(HashTable *target, HashTable *source, copy_ctor_func_t pCopyConstructor, uint size, merge_checker_func_t pMergeSource, void *pParam)
通过source的逻辑双向链表,遍历source插入target
ZEND_API void zend_hash_copy(HashTable *target, HashTable *source, copy_ctor_func_t pCopyConstructor, void *tmp, uint size)
哈希表的遍历
ZEND_API int zend_hash_get_pointer(const HashTable *ht, HashPointer *ptr)
ZEND_API int zend_hash_set_pointer(HashTable *ht, const HashPointer *ptr)
ZEND_API void zend_hash_internal_pointer_reset_ex(HashTable *ht, HashPosition *pos)
ZEND_API void zend_hash_internal_pointer_end_ex(HashTable *ht, HashPosition *pos)
ZEND_API int zend_hash_move_forward_ex(HashTable *ht, HashPosition *pos)
ZEND_API int zend_hash_move_backwards_ex(HashTable *ht, HashPosition *pos)
数组操作函数reset(), each(), current(), next()会用这些函数来实现。
比较,排序
ZEND_API int zend_hash_sort ( HashTable * ht , sort_func_t sort_func , compare_func_t compar , int renumber TSRMLS_DC )
ZEND_API int zend_hash_minmax (const HashTable * ht , compare_func_t compar , int flag , void ** pData TSRMLS_DC )
ZEND_API int zend_hash_compare ( HashTable * ht1 , HashTable * ht2 , compare_func_t compar , zend_bool ordered TSRMLS_DC )
哈希表有一套排序算法。sort(), asort(), resort(), arsort(), ksort(), krsort()
详细请见: http://php.net/manual/en/array.sorting.php
5. 哈希冲突(Hashtable Collisions)
因为任何一个哈希表的长度都是有限制的,所以一定会发生键名不同,hash函数计算后得到相同的bucket位置。也就是key1 != key2,但是HASH(key1) = HASH(key2)。如下图2,在发生哈希冲突时(Hash Collision),最坏情况下,所有的键名全部冲突,哈希表会退化成双向链表,操作时间复杂度为O(n)。
当发生了哈希冲突,会把当前bucket插入到哈希值所在链表的第一位,并插入HashTable的逻辑链表。
6. 哈希碰撞攻击及解决
在去年发现了PHP的哈希碰撞攻击漏洞,PHP5.3.9以下的版本都会受影响。我们在业务压力很重的情况下,还是最短时间内把运营服务器全部更新到5.3.13以上,防止通过PHP的哈希碰撞进行拒绝服务攻击。
如何哈希碰撞攻击呢?运用哈希冲突。在我们对PHP哈希算法足够了解以后,通过精心构造,可以让PHP的哈希表全部冲突,退化成链表,每插入元素时候,PHP都要遍历一遍链表,消耗大量的CPU,造成拒绝服务攻击。最简单的方法是利用掩码规律制造碰撞,我们知道HashTable的长度nTableSize会被圆整为2的整数次幂,假设我们构造一个长度为2^16的哈希表,nTableSize的二进制表示为:1 0000 0000 0000 0000,而nTableMask = nTableSize – 1为:0 1111 1111 1111 1111。这样我们只要保证后16位均为0,则与掩码与运算后得到的哈希值全部碰撞在位置0。
0000 0000 0000 0000 0000 & 0 1111 1111 1111 1111 = 0
0001 0000 0000 0000 0000 & 0 1111 1111 1111 1111 = 0
0010 0000 0000 0000 0000 & 0 1111 1111 1111 1111 = 0
。。。
以下这个例子就是这个原理的实现,插入65535个数据需要消耗30秒,而正常情况下仅需要0.01秒。
<? php
echo '
';
$size = pow(2, 16); // 16 is just an example, could also be 15 or 17
$startTime = microtime(true);
$array = array();
for ($key = 0, $maxKey = ($size - 1) * $size; $key <= $maxKey; $key += $size) {
$array[$key] = 0;
}
$endTime = microtime(true);
echo 'Inserting ', $size, ' evil elements took ', $endTime - $startTime, ' seconds', "\n";
$startTime = microtime(true);
$array = array();
for ($key = 0, $maxKey = $size - 1; $key <= $maxKey; ++$key) {
$array[$key] = 0;
}
$endTime = microtime(true);
echo 'Inserting ', $size, ' good elements took ', $endTime - $startTime, ' seconds', "\n";
?>
结果是
Inserting 65536 evil elements took 32.726480007172 seconds
Inserting 65536 good elements took 0.014460802078247 seconds
文章来源:http://nikic.github.io/2011/12/28/Supercolliding-a-PHP-array.html
对于哈希碰撞攻击有2中常见形式:通过POST攻击或通过反序列化攻击。PHP会自动把HTTP包中POST的数据解析成数组$_POST,如果我们构造一个无限大的哈希冲突的值,可以造成拒绝服务攻击。
PHP5.3.9+是通过增加一个限制来尽量避免被此类攻击影响:
- max_input_vars - 指定 GET/POST/COOKIE 的最大输入变量数。默认是1000。
反序列化同样是利用数组的哈希冲突,如果POST的数据有字段为数组serialize后的值,或数组json_encode后的值,在unserialize或json_decode后,会有可能造成哈希碰撞攻击。解决方法,尽量避免在公网上以数组的序列化形式传递数据,如果不可避免,请使用私有协议(TLV)增加供给难度,或使用加密协议(HTTPS)防止中间人攻击。
7. 总结
PHP的哈希表采用times33的哈希算法,通过HashTable数据结构维护Buckets,当有哈希冲突的时候,会将元素插入到该Buckets前形成双向链表。同时为了方便遍历,HashTable也会维护逻辑双向链表(按照插入顺序),通过内部游标指针可以遍历Hashtable。PHP的变量符号表、常量符号表和函数都是用哈希表维护,PHP的数组类型变量也是通过哈希表维护。
哈希表容易遭到哈希碰撞攻击,请更新PHP版本到5.3.9以上,可以解决POST数据的攻击问题;反序列化(把序列化字符串还原为Array)的哈希碰撞攻击,到目前位置PHP官方还没有彻底解决这个问题,请尽量避免用户篡改数据和中间人攻击。