PHP哈希表碰撞攻击

时间：2022-04-30 13:29:09

哈希表是一种查找效率极高的数据结构，PHP中的哈希表是一种极为重要的数据结构，不但用于表示数组,关联数组,对象属性,函数表,符号表，还在Zend虚拟机内部用于存储上下文环境信息（执行上下文的变量及函数均使用哈希表结构存储）。

PHP是使用单链表存储碰撞的数据，因此实际上PHP哈希表的平均查找复杂度为O(L)，其中L为桶链表的平均长度；而最坏复杂度为O(N)，此时所有数据全部碰撞，哈希表退化成单链表

哈希表碰撞攻击就是通过精心构造数据，使得所有数据全部碰撞，人为将哈希表变成一个退化的单链表，此时哈希表各种操作的时间均提升了一个数量级，因此会消耗大量CPU资源，导致系统无法快速响应请求，从而达到拒绝服务攻击（DoS）的目的

下面是hash表的结构

typedef struct bucket {

        ulong h;                                                /* Used for numeric indexing */

        uint nKeyLength;

        void *pData;

        void *pDataPtr;

        struct bucket *pListNext;

        struct bucket *pListLast;

        struct bucket *pNext;

        struct bucket *pLast;

        const char *arKey;

} Bucket;

typedef struct _hashtable {

        uint nTableSize;

        uint nTableMask;

        uint nNumOfElements;

        ulong nNextFreeElement;

        Bucket *pInternalPointer;       /* Used for element traversal */

        Bucket *pListHead;

        Bucket *pListTail;

        Bucket **arBuckets;

        dtor_func_t pDestructor;

        zend_bool persistent;

        unsigned char nApplyCount;

        zend_bool bApplyProtection;

#if ZEND_DEBUG

        int inconsistent;

#endif

} HashTable;

Zend HashTable的哈希算法异常简单：

hash(key)=key & nTableMask

即简单将数据的原始key与HashTable的nTableMask进行按位与即可。

如果原始key为字符串，则首先使用Tims33算法将字符串转为整形再与nTableMask按位与。

hash(strkey)=time33(strkey) & nTableMask

下面是Times 33 算法 在/Zend/zend_hash.h这个文件当中

/*

 * DJBX33A (Daniel J. Bernstein, Times 33 with Addition)

 *

 * This is Daniel J. Bernstein's popular `times 33' hash function as

 * posted by him years ago on comp.lang.c. It basically uses a function

 * like ``hash(i) = hash(i-1) * 33 + str[i]''. This is one of the best

 * known hash functions for strings. Because it is both computed very

 * fast and distributes very well.

 *

 * The magic of number 33, i.e. why it works better than many other

 * constants, prime or not, has never been adequately explained by

 * anyone. So I try an explanation: if one experimentally tests all

 * multipliers between 1 and 256 (as RSE did now) one detects that even

 * numbers are not useable at all. The remaining 128 odd numbers

 * (except for the number 1) work more or less all equally well. They

 * all distribute in an acceptable way and this way fill a hash table

 * with an average percent of approx. 86%.

 *

 * If one compares the Chi^2 values of the variants, the number 33 not

 * even has the best value. But the number 33 and a few other equally

 * good numbers like 17, 31, 63, 127 and 129 have nevertheless a great

 * advantage to the remaining numbers in the large set of possible

* multipliers: their multiply operation can be replaced by a faster

 * operation based on just one shift plus either a single addition

 * or subtraction operation. And because a hash function has to both

 * distribute good _and_ has to be very fast to compute, those few

 * numbers should be preferred and seems to be the reason why Daniel J.

 * Bernstein also preferred it.

 *

 *

 *                  -- Ralf S. Engelschall <rse@engelschall.com>

 */

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的Hashtable的大小都是2的指数, 比如如果你存入10个元素的数组, 那么数组实际大小是16, 如果存入20个, 则实际大小为32, 而63个话, 实际大小为64. 当你的存入的元素个数大于了数组目前的最多元素个数的时候, PHP会对这个数组进行扩容, 并且从新Hash.

现在, 我们假设要存入65536个元素(中间可能会经过扩容, 但是我们只需要知道, 最后的数组大小是65536, 并且对应的tableMask为0 1111 1111 1111 1111), 那么如果第一次我们存入的元素的键值为0, 则hash后的值为0，第二次64 ，也使hash后的数据为0 第n次……  就可以使得底层的PHP数组把所有的元素都Hash到0号bucket上, 从而使得Hash表退化成链表了.

以下具体数据

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

0011 0000 0000 0000 0000 & 0 1111 1111 1111 1111 = 0

0100 0000 0000 0000 0000 & 0 1111 1111 1111 1111 = 0

……

概况来说只要保证后16位均为0，则与掩码位于后得到的哈希值全部碰撞在位置0。

下面是利用这个原理写的一段攻击代码：

<?php

$size = pow(2, 16);

$startTime = microtime(true);

$array = array();

for ($key = 0, $maxKey = ($size - 1) * $size; $key <= $maxKey; $key += $size) {

    $array[$key] = 0;

}

$endTime = microtime(true);

echo $endTime - $startTime, ' seconds', "\n";

/********************************************************************************************************/

$size = pow(2, 16);

$startTime = microtime(true);

$array = array();

for ($key = 0, $maxKey = ($size - 1) * $size; $key <= $size; $key += 1) {

$array[$key] = 0;

}

$endTime = microtime(true);

echo $endTime - $startTime, ' seconds', "\n";

正常的几秒就执行完了，而攻击的则需要几十秒

针对POST方式的哈希碰撞攻击，可以看  http://www.laruence.com/2011/12/30/2440.html。

参考：http://www.laruence.com/2011/12/30/2435.html

相关文章