Хеш-функція, яка виробляє короткі хеші?

Чи існує спосіб шифрування, який може зайняти рядок будь-якої довжини і створити хеш, менший за 10 символів? Я хочу створити досить унікальні ідентифікатори, але на основі вмісту повідомлення, а не випадково.

Однак я можу жити, обмежуючи повідомлення цілими значеннями, якщо рядки довільної довжини неможливі. Однак хеш у такому випадку не повинен бути подібним для двох послідовних цілих чисел.

Ви можете використовувати будь-який загальнодоступний хеш-алгоритм (наприклад, SHA-1), який дасть вам трохи довший результат, ніж той, який вам потрібен. Просто обріжте результат до потрібної довжини, що може бути досить хорошим.

Наприклад, у Python:

>>> import hashlib
>>> hash = hashlib.sha1("my message".encode("UTF-8")).hexdigest()
>>> hash
'104ab42f1193c336aa2cf08a2c946d5c6fd0fcdb'
>>> hash[:10]
'104ab42f11'

Якщо вам не потрібен алгоритм, сильний проти навмисних модифікацій, я знайшов алгоритм під назвою adler32, який дає досить короткі (~ 8 символів) результати. Виберіть його зі спадного меню тут, щоб спробувати:

http://www.sha1-online.com/

Вам потрібно хешувати вміст, щоб скласти дайджест. Доступно багато хешів, але 10 символів досить мало для результату. Повертаючись назад, люди використовували CRC-32, який створює 33-бітний хеш (в основному 4 символи плюс один біт). Існує також CRC-64, який виробляє 65-розрядний хеш. MD5, який створює 128-бітний хеш (16 байт / символів), вважається непрацездатним для криптографічних цілей, оскільки можна знайти два повідомлення, що мають однаковий хеш. Само собою зрозуміло, що кожного разу, коли ви створюєте 16-байтовий дайджест із довільної довжини повідомлення, ви отримаєте дублікати. Чим коротший дайджест, тим більший ризик зіткнень.

Однак ваша стурбованість тим, що хеш не буде подібним для двох послідовних повідомлень (незалежно від того, цілі чи ні), повинна бути правдивою для всіх хешів. Навіть одна бітова зміна оригінального повідомлення повинна дати зовсім інший дайджест.

Отже, використання чогось на кшталт CRC-64 (і base-64 'результат) повинно привести вас у сусідній район, який ви шукаєте.

Просто підсумовуючи корисну для мене відповідь (зазначивши коментар @ erasmospunk щодо використання кодування base-64). Моєю метою було короткий рядок, який був переважно унікальним ...

Я не фахівець, тому, будь ласка, виправте це, якщо у нього є кричущі помилки (у Python знову, як прийнята відповідь):

import base64
import hashlib
import uuid

unique_id = uuid.uuid4()
# unique_id = UUID('8da617a7-0bd6-4cce-ae49-5d31f2a5a35f')

hash = hashlib.sha1(str(unique_id).encode("UTF-8"))
# hash.hexdigest() = '882efb0f24a03938e5898aa6b69df2038a2c3f0e'

result = base64.b64encode(hash.digest())
# result = b'iC77DySgOTjliYqmtp3yA4osPw4='

resultТут використовується більше , ніж просто шістнадцятирічних символів (то , що ви отримаєте , якщо ви використовували hash.hexdigest()) , так що це менш імовірно зіткнення (тобто, повинні бути більш безпечними , ніж вкоротити гекс перетравлювати).

Примітка: Використання UUID4 (випадковий). Інші типи див. На веб-сайті http://en.wikipedia.org/wiki/Universally_unique_identifier .

Ви можете використовувати існуючий хеш-алгоритм, який створює щось коротке, наприклад MD5 (128 біт) або SHA1 (160). Тоді ви можете скоротити це додатково шляхом XORing розділів дайджесту з іншими розділами. Це збільшить ймовірність зіткнень, але не настільки поганим, як просто скорочення дайджесту.

Крім того, ви можете включити довжину вихідних даних як частину результату, щоб зробити їх більш унікальними. Наприклад, XORing першої половини дайджесту MD5 з другою половиною дасть 64 біти. Додайте 32 біти для довжини даних (або нижче, якщо ви знаєте, що довжина завжди буде містити менше бітів). Це призведе до 96-розрядного (12-байтового) результату, який ви зможете перетворити на 24-символьний шістнадцятковий рядок. Крім того, ви можете використовувати базове кодування 64, щоб зробити його ще коротшим.

Якщо вам потрібно, "sub-10-character hash" ви можете скористатися алгоритмом Fletcher-32 , який створює хеш із 8 символів (32 біти), CRC-32 або Adler-32 .

CRC-32 повільніший за Adler32 у 20 - 100%.

Флетчер-32 трохи надійніший за Адлер-32. Він має нижчі обчислювальні витрати, ніж контрольна сума Адлера: порівняння Флетчера і Адлера .

Зразок програми з кількома реалізаціями Fletcher наведено нижче:

    #include <stdio.h>
    #include <string.h>
    #include <stdint.h> // for uint32_t

    uint32_t fletcher32_1(const uint16_t *data, size_t len)
    {
            uint32_t c0, c1;
            unsigned int i;

            for (c0 = c1 = 0; len >= 360; len -= 360) {
                    for (i = 0; i < 360; ++i) {
                            c0 = c0 + *data++;
                            c1 = c1 + c0;
                    }
                    c0 = c0 % 65535;
                    c1 = c1 % 65535;
            }
            for (i = 0; i < len; ++i) {
                    c0 = c0 + *data++;
                    c1 = c1 + c0;
            }
            c0 = c0 % 65535;
            c1 = c1 % 65535;
            return (c1 << 16 | c0);
    }

    uint32_t fletcher32_2(const uint16_t *data, size_t l)
    {
        uint32_t sum1 = 0xffff, sum2 = 0xffff;

        while (l) {
            unsigned tlen = l > 359 ? 359 : l;
            l -= tlen;
            do {
                sum2 += sum1 += *data++;
            } while (--tlen);
            sum1 = (sum1 & 0xffff) + (sum1 >> 16);
            sum2 = (sum2 & 0xffff) + (sum2 >> 16);
        }
        /* Second reduction step to reduce sums to 16 bits */
        sum1 = (sum1 & 0xffff) + (sum1 >> 16);
        sum2 = (sum2 & 0xffff) + (sum2 >> 16);
        return (sum2 << 16) | sum1;
    }

    int main()
    {
        char *str1 = "abcde";  
        char *str2 = "abcdef";

        size_t len1 = (strlen(str1)+1) / 2; //  '\0' will be used for padding 
        size_t len2 = (strlen(str2)+1) / 2; // 

        uint32_t f1 = fletcher32_1(str1,  len1);
        uint32_t f2 = fletcher32_2(str1,  len1);

        printf("%u %X \n",    f1,f1);
        printf("%u %X \n\n",  f2,f2);

        f1 = fletcher32_1(str2,  len2);
        f2 = fletcher32_2(str2,  len2);

        printf("%u %X \n",f1,f1);
        printf("%u %X \n",f2,f2);

        return 0;
    }

Вихід:

4031760169 F04FC729                                                                                                                                                                                                                              
4031760169 F04FC729                                                                                                                                                                                                                              

1448095018 56502D2A                                                                                                                                                                                                                              
1448095018 56502D2A                                                                                                                                                                                                                              

Погоджується з тестовими векторами :

"abcde"  -> 4031760169 (0xF04FC729)
"abcdef" -> 1448095018 (0x56502D2A)

Adler-32 має слабкі сторони щодо коротких повідомлень з кількома сотнями байтів, оскільки контрольна сума для цих повідомлень погано охоплює 32 доступних біта. Перевір це:

Алгоритм Adler32 недостатньо складний, щоб конкурувати з порівнянними контрольними сумами .

Просто запустіть це в терміналі (на MacOS або Linux):

crc32 <(echo "some string")

Довжиною 8 символів.

Ви можете використовувати бібліотеку hashlib для Python. Алгоритми shake_128 та shake_256 забезпечують хеші змінної довжини. Ось деякий робочий код (Python3):

import hashlib
>>> my_string = 'hello shake'
>>> hashlib.shake_256(my_string.encode()).hexdigest(5)
'34177f6a0a'

Зауважте, що за допомогою параметра довжини x (наприклад 5) функція повертає хеш-значення довжини 2x .

Зараз 2019 рік, і є кращі варіанти. А саме, xxhash .

~ echo test | xxhsum                                                           
2d7f1808da1fa63c  stdin

Нещодавно мені знадобилося щось на зразок простої функції зменшення рядків. В основному, код виглядав приблизно так (код C / C ++ вперед):

size_t ReduceString(char *Dest, size_t DestSize, const char *Src, size_t SrcSize, bool Normalize)
{
    size_t x, x2 = 0, z = 0;

    memset(Dest, 0, DestSize);

    for (x = 0; x < SrcSize; x++)
    {
        Dest[x2] = (char)(((unsigned int)(unsigned char)Dest[x2]) * 37 + ((unsigned int)(unsigned char)Src[x]));
        x2++;

        if (x2 == DestSize - 1)
        {
            x2 = 0;
            z++;
        }
    }

    // Normalize the alphabet if it looped.
    if (z && Normalize)
    {
        unsigned char TempChr;
        y = (z > 1 ? DestSize - 1 : x2);
        for (x = 1; x < y; x++)
        {
            TempChr = ((unsigned char)Dest[x]) & 0x3F;

            if (TempChr < 10)  TempChr += '0';
            else if (TempChr < 36)  TempChr = TempChr - 10 + 'A';
            else if (TempChr < 62)  TempChr = TempChr - 36 + 'a';
            else if (TempChr == 62)  TempChr = '_';
            else  TempChr = '-';

            Dest[x] = (char)TempChr;
        }
    }

    return (SrcSize < DestSize ? SrcSize : DestSize);
}

Ймовірно, у нього більше зіткнень, ніж можна було б бажати, але він не призначений для використання в якості криптографічної хеш-функції. Ви можете спробувати різні множники (тобто змінити 37 на інше просте число), якщо ви отримаєте занадто багато зіткнень. Однією з цікавих особливостей цього фрагмента є те, що коли Src коротший за Dest, Dest закінчується вхідним рядком як є (0 * 37 + value = value). Якщо ви хочете щось «читабельне» в кінці процесу, Normalize відкоригує перетворені байти ціною збільшення зіткнень.

Джерело:

https://github.com/cubiclesoft/cross-platform-cpp/blob/master/sync/sync_util.cpp