任何种子在同一字符串上的CRC32哈希冲突

问题描述

我试图找到种子来散列具有可能的最大长度的小写字母的短字符串而不会发生冲突。 我选择了SSE 4.2 CRC32来简化任务。对于长度为4、5、6的种子，只要达到合理的较小值（我不能无限等待），就不会发生碰撞。

#include <bitset>
#include <limits>
#include <iterator>
#include <iostream>

#include <x86intrin.h>

static std::bitset<size_t(std::numeric_limits<uint32_t>::max()) + 1> hashes;

static void findSeed()
{
    uint8_t c[7];
    const auto findCollision = [&] (uint32_t seed)
    {
        std::cout << "seed = " << seed << std::endl;
        hashes.reset();
        for (c[0] = 'a'; c[0] <= 'z'; ++c[0]) {
            uint32_t hash0 = _mm_crc32_u8(~seed,c[0]);
            for (c[1] = 'a'; c[1] <= 'z'; ++c[1]) {
                uint32_t hash1 = _mm_crc32_u8(hash0,c[1]);
                for (c[2] = 'a'; c[2] <= 'z'; ++c[2]) {
                    uint32_t hash2 = _mm_crc32_u8(hash1,c[2]);
                    for (c[3] = 'a'; c[3] <= 'z'; ++c[3]) {
                        uint32_t hash3 = _mm_crc32_u8(hash2,c[3]);
                        for (c[4] = 'a'; c[4] <= 'z'; ++c[4]) {
                            uint32_t hash4 = _mm_crc32_u8(hash3,c[4]);
                            for (c[5] = 'a'; c[5] <= 'z'; ++c[5]) {
                                uint32_t hash5 = _mm_crc32_u8(hash4,c[5]);
                                for (c[6] = 'a'; c[6] <= 'z'; ++c[6]) {
                                    uint32_t hash6 = _mm_crc32_u8(hash5,c[6]);
                                    if (hashes[hash6]) {
                                        std::cerr << "collision at ";
                                        std::copy(std::cbegin(c),std::cend(c),std::ostream_iterator<uint8_t>(std::cerr,""));
                                        std::cerr << " " << hash6 << '\n';
                                        return;
                                    }
                                    hashes.set(hash6);
                                }
                            }
                        }
                    }
                }
            }
            std::cout << "c[0] = " << c[0] << std::endl;
        }
    };
    for (uint32_t seed = 0; seed != std::numeric_limits<uint32_t>::max(); ++seed) {
        findCollision(seed);
    }
    findCollision(std::numeric_limits<uint32_t>::max());
}

int main()
{
    findSeed();
}

很明显，对于长度为7的字符串，不可能找到这样的种子，因为('z' - 'a' + 1)^7 = 26^7 = 8 031 810 176 > 4 294 967 296 = size_t(std::numeric_limits<uint32_t>::max()) + 1。但是值得注意的是，对于任何种子的字符串abfcmbk和baabaaa，首先发生冲突。发生冲突时，hash6对于不同的种子有所不同。我的想法很奇怪。

如何解释？

解决方法

如果CRC(seed,dat)是dat的CRC，使用指定的seed，则对于任何种子（seed1，seed2）和长度匹配的数据对（dat1，dat2） ，并给定CRC（seed1，dat1），就可以通过计算CRC(seed2,dat1)，CRC(seed1,dat1)和CRC(seed1,dat2)的异或来计算CRC(seed2,dat2)。

这反过来意味着，如果两个数据对任何特定种子将产生相同的CRC值，则它们对每个可能的种子将产生相同的值。如果对于任何seed1，CRC(seed1,dat1a)等于CRC(seed1,dat1b)，并且字符串长度相等，那么对于任何其他种子seed2和相同长度的数据dat2， CRC(seed2,dat1a) xor CRC(seed1,dat2) xor CRC(seed2,dat2)，而CRC(seed2,dat1b)等于CRC(seed1,dat1b) xor CRC(seed1,dat2)。由于xor的所有三个项都相等，这意味着结果也将相等。

,

如另一个答案中所述，CRC对此无能为力。相反，您应该简单地将六个或更少的小写字母编码为基26个32位整数，并根据字符串的长度进行一些补偿。 n = 0到6时26 ^ n之和小于2 ^ 32。实际上要少得多，因为可以将其编码为29位。或正如Peter Cordes所评论的那样，以30位包含六个5位字段。

没有碰撞。如果有用的话，您可以将32位CRC应用于该整数以对这些位进行加扰，并且不会再发生冲突。

如您所见，不可能以32位唯一编码七个或更多小写字符。