我可以使用什么算法为唯一的 mac 地址生成 48 位哈希？答案

【问题标题】：What algorithm can I use to generate a 48-bit hash for unique mac addresses?我可以使用什么算法为唯一的 mac 地址生成 48 位哈希？
【发布时间】：2020-01-25 01:16:44
【问题描述】：

有没有简单的使用散列算法生成48位散列？我需要从唯一的输入字符串生成唯一的 MAC 地址。这里没有安全问题，只是将其映射到 MAC 地址空间（即 48 位）的问题。

我想到了 CRC32，它只有 32 位，而且很简单（cksum 在每个 Linux 上都有），并将它们用于低 32 位，但如果主机多于几台，则冲突非常高。

如果我可以获得 48 位哈希，我可以屏蔽 8 个最高有效位中的第二个最低有效位，以确保它是本地管理地址。单个位的丢失很小。

相反，我可以使用更长的散列算法（MD5、SHA1 等），只取 48 个最高有效位或最低有效位。

有没有简单的方法来做到这一点？

我的偏好是命令行实用程序，但如果我必须编写简短的 python 或类似的，没什么大不了的。

【问题讨论】：

这似乎与 serverfault.com/questions/299556/… 重复
@Terry 很棒！请注意，他们只将其设为 40 位，并且只占用最重要的 40 位。我不确定这与以其他方式修剪它的影响。不过谢谢！

标签： linux hash mac-address

【解决方案1】：

2 年后，这是一个在实际应用中的想法（非常接近您的需要）。

对于没有非易失性存储器的定制板，我只需要一个 48 位的序列号。该板采用 STM32 处理器，具有 96 位的唯一 ID (STM32_UUID)。

这是完整的 C 代码：

#define STM32_UUID                      ((uint8_t*)0x1FFFF7E8)

// board SN 48 bit
static uint8_t BoardSerial[6]; 

void setBoardSerial(void)
{
  uint64_t hash = fastHash64(STM32_UUID, 12, 1234554321);
  memcpy(BoardSerial, &hash, 6);
}

static inline uint64_t mix(uint64_t h)
{
    h ^= h >> 23;
    h *= 0x2127599bf4325c37ULL;
    h ^= h >> 47;
    //
    return h;
}

uint64_t fastHash64(const void * buf, size_t len, uint64_t seed)
{
    const uint64_t m = 0x880355f21e6d1965ULL;
    const uint64_t * pos = (const uint64_t*)buf;
    const uint64_t * end = pos + (len / 8);
    const unsigned char * pos2;
    uint64_t h = seed ^ (len * m);
    uint64_t v;

    while(pos != end)
    {
        v  = *pos++;
        h ^= mix(v);
        h *= m;
    }

    pos2 = (const unsigned char*)pos;
    v = 0;

    switch(len & 7)
    {
        case 7: v ^= (uint64_t)pos2[6] << 48;
        case 6: v ^= (uint64_t)pos2[5] << 40;
        case 5: v ^= (uint64_t)pos2[4] << 32;
        case 4: v ^= (uint64_t)pos2[3] << 24;
        case 3: v ^= (uint64_t)pos2[2] << 16;
        case 2: v ^= (uint64_t)pos2[1] << 8;
        case 1: v ^= (uint64_t)pos2[0];
                h ^= mix(v);
                h *= m;
    }

    return mix(h);
}

我在一批大约 200 个单元（板）上测试了这个解决方案，绝对没有问题，没有冲突。我见过很多人遇到这个问题，他们需要一个较小的设备 ID，而该 ID 不知何故源自一个大的唯一单元序列号。

或者，您可以搜索 Bobcat 48 位哈希的实现。

【讨论】：