hashlib — Безопасные хэши и дайджесты сообщений

Исходный код: Lib/hashlib.py


Модуль реализует общий интерфейс для множества различных алгоритмов безопасного хеширования и дайджеста сообщений. Включены FIPS алгоритмы безопасного хеширования SHA1, SHA224, SHA256, SHA384 и SHA512 (определенные в FIPS 180-2), а также алгоритм RSA MD5 (определенный в Интернете RFC 1321). Термины «безопасный хэш» и «дайджест сообщения» взаимозаменяемы. Старые алгоритмы назывались дайджестами сообщений. Современный термин — безопасный хеш.

Примечание

Если вам нужны хэш-функции adler32 или crc32, они доступны в модуле zlib.

Предупреждение

Некоторые алгоритмы обладают известными недостатками, связанными с коллизиями (collision) хешей, см. раздел «См. также» в конце.

Алгоритмы хеширования

Для каждого типа хеша существует один метод конструктора. Все они возвращают хэш-объект с одним и тем же простым интерфейсом. Например: воспользуемся sha256() для создания хеш-объекта SHA-256. Теперь вы можете заполнить этот объект байтоподобными объектами (обычно bytes) с помощью метода update(). В любой момент вы можете запросить у него дайджест конкатенации данных, переданных ему до сих пор, с помощью методов digest() или hexdigest().

Примечание

Для повышения производительности многопоточности Python GIL отпускается для данных размером более 2047 байт при создании или обновлении объекта.

Примечание

Подача строковых объектов в update() не поддерживается, поскольку хеши работают с байтами, а не с символами.

Конструкторы для хэш-алгоритмов, которые всегда присутствуют в данном модуле: sha1(), sha224(), sha256(), sha384(), sha512(), blake2b() и blake2s(). md5() также обычно доступен, хотя он может отсутствовать, если вы используете редкую «FIPS- совместимую» сборку Python. Дополнительные алгоритмы также могут быть доступны в зависимости от библиотеки OpenSSL, которую Python использует на вашей платформе. На большинстве платформ также доступны sha3_224(), sha3_256(), sha3_384(), sha3_512(), shake_128(), shake_256().

Добавлено в версии 3.6: Конструкторы SHA3 (Keccak) и SHAKE sha3_224(), sha3_256(), sha3_384(), sha3_512(), shake_128(), shake_256().

Добавлено в версии 3.6: Добавлены blake2b() и blake2s().

Например, чтобы получить дайджест байтовой строки b'Nobody inspects the spammish repetition':

>>> import hashlib
>>> m = hashlib.sha256()
>>> m.update(b"Nobody inspects")
>>> m.update(b" the spammish repetition")
>>> m.digest()
b'\x03\x1e\xdd}Ae\x15\x93\xc5\xfe\\\x00o\xa5u+7\xfd\xdf\xf7\xbcN\x84:\xa6\xaf\x0c\x95\x0fK\x94\x06'
>>> m.digest_size
32
>>> m.block_size
64

Более сжато:

>>> hashlib.sha224(b"Nobody inspects the spammish repetition").hexdigest()
'a4337bc45a8fc544c03f52dc550cd6e1e87021bc896588bd79e901e2'
hashlib.new(name[, data])

Общий конструктор, который принимает строку name желаемого алгоритма в качестве первого параметра. Он также существует, чтобы разрешить доступ к перечисленным выше хешам, а также к любым другим алгоритмам, которые может предложить ваша библиотека OpenSSL. Именованные конструкторы намного быстрее, чем new(), и им следует отдавать предпочтение.

Использование new() с алгоритмом, предоставленным OpenSSL:

>>> h = hashlib.new('ripemd160')
>>> h.update(b"Nobody inspects the spammish repetition")
>>> h.hexdigest()
'cc4a5ce1b3df48aec5d22d1f16b894a0b894eccc'

Hashlib предоставляет следующие постоянные атрибуты:

hashlib.algorithms_guaranteed

Множество, содержащее имена хэш-алгоритмов, которые гарантированно поддерживаются этим модулем на всех платформах. Обратите внимание, что «md5» находится в этом списке, несмотря на то, что некоторые поставщики апстрима предлагают странную «FIPS-совместимую» сборку Python, которая исключает его.

Добавлено в версии 3.2.

hashlib.algorithms_available

Множество, содержащее имена хэш-алгоритмов, доступных в работающем интерпретаторе Python. Имена будут распознаны при передаче в new(). algorithms_guaranteed всегда будет подмножеством. Один и тот же алгоритм может появляться в этом множестве несколько раз под разными именами (благодаря OpenSSL).

Добавлено в версии 3.2.

Следующие значения предоставляются как постоянные атрибуты хэш-объектов, возвращаемых конструкторами:

hash.digest_size

Размер результирующего хэша в байтах.

hash.block_size

Размер внутреннего блока хеш-алгоритма в байтах.

У хэш-объекта есть следующие атрибуты:

hash.name

Каноническое имя этого хеша, всегда в нижнем регистре и всегда подходящее в качестве параметра для new() для создания другого хеша этого типа.

Изменено в версии 3.4: Атрибут name присутствует в CPython с момента его создания, но до тех пор, пока Python 3.4 не был официально указан, поэтому может не существовать на некоторых платформах.

У хэш-объекта есть следующие методы:

hash.update(data)

Обновить хэш-объект с помощью байтоподобного объекта. Повторные вызовы эквивалентны одному вызову с объединением всех аргументов: m.update(a); m.update(b) эквивалентен m.update(a+b).

Изменено в версии 3.1: Python GIL отпускается, чтобы позволить другим потокам работать, пока происходит обновление хэша для данных, размер которых превышает 2047 байт, при использовании алгоритмов хеширования, предоставляемых OpenSSL.

hash.digest()

Вернуть дайджест данных, переданных на данный момент методу update(). Является байтовым объектом размером digest_size, который может содержать байты во всем диапазоне от 0 до 255.

hash.hexdigest()

Подобно digest(), за исключением того, что дайджест возвращается как строковый объект двойной длины, содержащий только шестнадцатеричные цифры. Можно использовать для безопасного обмена значениями по электронной почте или в других небинарных средах.

hash.copy()

Вернуть копию («клон») хеш-объекта. Можно использовать для эффективного вычисления дайджестов данных, разделяющих общую начальную подстроку.

SHAKE дайджесты переменной длины

Алгоритмы shake_128() и shake_256() обеспечивают дайджесты переменной длины с length_in_bits//2 до 128 или 256 бит безопасности. Таким образом, их методы дайджеста требуют длины. Максимальная длина не ограничена SHAKE алгоритмом.

shake.digest(length)

Вернуть дайджест данных, переданных на данный момент методу update(). Байтовый объект размером length, который может содержать байты во всем диапазоне от 0 до 255.

shake.hexdigest(length)

Подобно digest(), за исключением того, что дайджест возвращается как строковый объект двойной длины, содержащий только шестнадцатеричные цифры. Можно использовать для безопасного обмена значениями по электронной почте или в других небинарных средах.

Ключевой вывод

Алгоритмы получения и расширения ключей предназначены для безопасного хеширования паролей. Наивные алгоритмы, такие как sha1(password), не устойчивы к атакам методом перебора. Хорошая функция хеширования паролей должна быть настраиваемой, медленной и включать соль.

hashlib.pbkdf2_hmac(hash_name, password, salt, iterations, dklen=None)

Функция предоставляет функцию получения ключа на основе пароля PKCS #5 2. Она использует HMAC в качестве псевдослучайной функции.

Строка hash_name — желаемое имя алгоритма хеш-дайджеста для HMAC, например sha1 или sha256. password и salt интерпретируются как байтовые буферы. Приложения и библиотеки должны ограничивать password разумной длиной (например, 1024). salt должен быть около 16 или более байтов из правильного источника, например os.urandom().

Номер iterations следует выбирать в зависимости от алгоритма хеширования и вычислительной мощности. По состоянию на 2013 год предлагается не менее 100 000 итераций SHA-256.

dklen — длина производного ключа. Если dklenNone, то используется размер дайджеста алгоритма хеширования hash_name, например 64 для SHA-512.

>>> import hashlib
>>> dk = hashlib.pbkdf2_hmac('sha256', b'password', b'salt', 100000)
>>> dk.hex()
'0394a2ede332c9a13eb82e9b24631604c31df978b4e2f0fbd2c549944f9d79a5'

Добавлено в версии 3.4.

Примечание

Быстрая реализация pbkdf2_hmac доступна с OpenSSL. Реализация Python использует встроенную версию hmac. Он примерно в три раза медленнее и не выпускает GIL.

hashlib.scrypt(password, *, salt, n, r, p, maxmem=0, dklen=64)

Функция генерации ключей на основе пароля scrypt, как определено в RFC 7914.

password и salt должны быть байтоподобными объектами. Приложения и библиотеки должны ограничивать password разумной длиной (например, 1024). salt должен быть около 16 или более байтов из правильного источника, например os.urandom().

n — коэффициент стоимости ЦПУ/памяти, r — размер блока, p коэффициент распараллеливания, а maxmem — ограничивает память (OpenSSL 1.1.0 по умолчанию равен 32 MiB). dklen — длина производного ключа.

Доступность: OpenSSL 1.1+.

Добавлено в версии 3.6.

BLAKE2

BLAKE2 — криптографическая хеш-функция, определенная в RFC 7693, которая бывает двух видов:

  • BLAKE2b, оптимизирован для 64-битных платформ и производит дайджесты любого размера от 1 до 64 байтов
  • BLAKE2s, оптимизирован для платформ от 8 до 32 бит и создает дайджесты любого размера от 1 до 32 байтов.

BLAKE2 поддерживает ключевой режим (более быстрая и простая замена HMAC), соленое хэширование, персонализация и древовидное хеширование.

Хеш-объекты из этого модуля следуют API объектов стандартной библиотеки hashlib.

Создание хеш-объектов

Новые хеш-объекты создаются путём вызова функций-конструкторов:

hashlib.blake2b(data=b'', *, digest_size=64, key=b'', salt=b'', person=b'', fanout=1, depth=1, leaf_size=0, node_offset=0, node_depth=0, inner_size=0, last_node=False)
hashlib.blake2s(data=b'', *, digest_size=32, key=b'', salt=b'', person=b'', fanout=1, depth=1, leaf_size=0, node_offset=0, node_depth=0, inner_size=0, last_node=False)

Функции возвращают соответствующие хэш-объекты для вычисления BLAKE2b или BLAKE2. При желании они принимают общие параметры:

  • data: начальный фрагмент данных для хеширования, который должен быть байтоподобным объектом. Его можно передать только как позиционный аргумент.
  • digest_size: размер выходного дайджеста в байтах.
  • key: ключ для хеширования с ключом (до 64 байтов для BLAKE2b, до 32 байтов для BLAKE2).
  • salt: соль для рандомизированного хеширования (до 16 байтов для BLAKE2b, до 8 байтов для BLAKE2).
  • person: строка персонализации (до 16 байтов для BLAKE2b, до 8 байтов для BLAKE2).

В следующей таблице показаны ограничения для общих параметров (в байтах):

Хэш digest_size len(key) len(salt) len(person)
BLAKE2b 64 64 16 16
BLAKE2s 32 32 8 8

Примечание

Спецификация BLAKE2 определяет постоянную длину для параметров соли и персонализации, однако для удобства эта реализация принимает байтовые строки любого размера до указанной длины. Если длина параметра меньше указанной, она дополняется нулями, например, b'salt' и b'salt\x00' — это одно и то же значение. (Не относится к key.)

Размеры доступны как модуль Константы, описанный ниже.

Функции-конструкторы также принимают следующие параметры древовидного хеширования:

  • fanout: разветвление (от 0 до 255, 0 — если неограниченно, 1 — в последовательном режиме).
  • depth: максимальная глубина дерева (от 1 до 255, 255, если не ограничено, 1 в последовательном режиме).
  • leaf_size: максимальная длина листа в байтах (от 0 до 2**32-1, 0, если неограничено или в последовательном режиме).
  • node_offset: смещение узла (от 0 до 2**64-1 для BLAKE2b, 0 до 2**48-1 для BLAKE2, 0 для первого, крайнего левого, конечного или в последовательном режиме).
  • node_depth: глубина узла (от 0 до 255, 0 для листьев или в последовательном режиме).
  • inner_size: размер внутреннего дайджеста (от 0 до 64 для BLAKE2b, от 0 до 32 для BLAKE2, 0 в последовательном режиме).
  • last_node: логическое значение, указывающее, является ли обработанный узел последним («False» для последовательного режима).
Пояснение к параметрам режима дерева.

См. раздел 2.10 в BLAKE2 спецификации для всестороннего обзора хеширования дерева.

Константы

blake2b.SALT_SIZE
blake2s.SALT_SIZE

Длина соли (максимальная длина, принимаемая конструкторами).

blake2b.PERSON_SIZE
blake2s.PERSON_SIZE

Длина строки персонализации (максимальная длина, принимаемая конструкторами).

blake2b.MAX_KEY_SIZE
blake2s.MAX_KEY_SIZE

Максимальный размер ключа.

blake2b.MAX_DIGEST_SIZE
blake2s.MAX_DIGEST_SIZE

Максимальный размер дайджеста, который может вывести хэш-функция.

Примеры

Простое хеширование

Чтобы вычислить хэш некоторых данных, вы должны сначала создать хеш-объект, вызвав соответствующую функцию-конструктор (blake2b() или blake2s()), затем обновить его данными, вызвав update() для объекта, и, наконец, получить дайджест из объекта вызвав digest() (или hexdigest() для строки в шестнадцатеричной кодировке).

>>> from hashlib import blake2b
>>> h = blake2b()
>>> h.update(b'Hello world')
>>> h.hexdigest()
'6ff843ba685842aa82031d3f53c48b66326df7639a63d128974c5c14f31a0f33343a8c65551134ed1ae0f2b0dd2bb495dc81039e3eeb0aa1bb0388bbeac29183'

В качестве ярлыка вы можете передать первый фрагмент данных для обновления непосредственно в конструктор в качестве позиционного аргумента:

>>> from hashlib import blake2b
>>> blake2b(b'Hello world').hexdigest()
'6ff843ba685842aa82031d3f53c48b66326df7639a63d128974c5c14f31a0f33343a8c65551134ed1ae0f2b0dd2bb495dc81039e3eeb0aa1bb0388bbeac29183'

Вы можете вызвать hash.update() столько раз, сколько вам нужно для итеративного обновления хэша:

>>> from hashlib import blake2b
>>> items = [b'Hello', b' ', b'world']
>>> h = blake2b()
>>> for item in items:
...     h.update(item)
>>> h.hexdigest()
'6ff843ba685842aa82031d3f53c48b66326df7639a63d128974c5c14f31a0f33343a8c65551134ed1ae0f2b0dd2bb495dc81039e3eeb0aa1bb0388bbeac29183'

Использование дайджеста разного размера

У BLAKE2 настраиваемый размер дайджестов до 64 байтов для BLAKE2b и до 32 байтов для BLAKE2. Например, чтобы заменить SHA-1 на BLAKE2b без изменения размера вывода, мы можем указать BLAKE2b создавать 20-байтовые дайджесты:

>>> from hashlib import blake2b
>>> h = blake2b(digest_size=20)
>>> h.update(b'Replacing SHA1 with the more secure function')
>>> h.hexdigest()
'd24f26cf8de66472d58d4e1b1774b4c9158b1f4c'
>>> h.digest_size
20
>>> len(h.digest())
20

У объектов хеширования с разными размерами дайджеста совершенно разные выходные данные (более короткие хеши не являются префиксом более длинных хешей); BLAKE2b и BLAKE2s производят разные выходные данные, даже если длина выходного файла одинакова:

>>> from hashlib import blake2b, blake2s
>>> blake2b(digest_size=10).hexdigest()
'6fa1d8fcfd719046d762'
>>> blake2b(digest_size=11).hexdigest()
'eb6ec15daf9546254f0809'
>>> blake2s(digest_size=10).hexdigest()
'1bf21a98c78a1c376ae9'
>>> blake2s(digest_size=11).hexdigest()
'567004bf96e4a25773ebf4'

Ключевое хеширование

Ключевое хеширование можно использовать для аутентификации как более быструю и простую замену Код аутентификации сообщения на основе хэша (HMAC). BLAKE2 можно безопасно использовать в режиме префикса MAC благодаря свойству неразличимости, унаследованному от BLAKE.

В этом примере показано, как получить (в шестнадцатеричном коде) 128-битный код аутентификации для сообщения b'message data' с ключом b'pseudorandom key':

>>> from hashlib import blake2b
>>> h = blake2b(key=b'pseudorandom key', digest_size=16)
>>> h.update(b'message data')
>>> h.hexdigest()
'3d363ff7401e02026f4a4687d4863ced'

В качестве практического примера веб-приложение может симметрично подписывать файлы cookie, отправленные пользователям, а затем проверять их, чтобы убедиться, что они не были подделаны:

>>> from hashlib import blake2b
>>> from hmac import compare_digest
>>>
>>> SECRET_KEY = b'pseudorandomly generated server secret key'
>>> AUTH_SIZE = 16
>>>
>>> def sign(cookie):
...     h = blake2b(digest_size=AUTH_SIZE, key=SECRET_KEY)
...     h.update(cookie)
...     return h.hexdigest().encode('utf-8')
>>>
>>> def verify(cookie, sig):
...     good_sig = sign(cookie)
...     return compare_digest(good_sig, sig)
>>>
>>> cookie = b'user-alice'
>>> sig = sign(cookie)
>>> print("{0},{1}".format(cookie.decode('utf-8'), sig))
user-alice,b'43b3c982cf697e0c5ab22172d1ca7421'
>>> verify(cookie, sig)
True
>>> verify(b'user-bob', sig)
False
>>> verify(cookie, b'0102030405060708090a0b0c0d0e0f00')
False

Несмотря на то, чт. е. собственный режим хеширования с ключом, BLAKE2, конечно, можно использовать в построении HMAC с модулем hmac:

>>> import hmac, hashlib
>>> m = hmac.new(b'secret key', digestmod=hashlib.blake2s)
>>> m.update(b'message')
>>> m.hexdigest()
'e3c8102868d28b5ff85fc35dda07329970d1a01e273c37481326fe0c861c8142'

Рандомизированное хеширование

Установив параметр salt, пользователи могут ввести рандомизацию в хэш- функцию. Рандомизированное хеширование полезно для защиты от коллизионных атак на хеш-функцию, используемую в цифровых подписях.

Рандомизированное хеширование предназначено для ситуаций, когда одна сторона, составитель сообщения, генерирует все или часть сообщения, которое должно быть подписано второй стороной, подписывающей сообщение. Если составитель сообщения может обнаружить конфликты криптографических хэш-функций (т. е. два сообщения, производящие одно и то же значение хеш-функции), он может подготовить значимые версии сообщения, которые будут давать одинаковое хеш-значение и цифровую подпись, но с разными результатами (например, переводя на счет 1 000 000 долларов США, а не 10 долларов США). Криптографические хеш-функции были разработаны с учётом устойчивости к коллизиям в качестве основной цели, но текущая концентрация на атаках криптографических хеш-функций может привести к тому, что данная криптографическая хеш-функция будет обеспечивать меньшую стойкость к коллизиям, чем ожидалось. Рандомизированное хеширование предлагает подписавшему дополнительную защиту за счёт снижения вероятности того, что составитель может сгенерировать два или более сообщений, которые в конечном итоге дадут одно и то же значение хеш-функции в процессе генерации цифровой подписи, — даже если это практично найти коллизии для хеш-функции. Однако использование рандомизированного хеширования может снизить уровень безопасности, обеспечиваемый цифровой подписью, когда все части сообщения подготовлены подписавшим.

(NIST SP-800-106 «Рандомизированное хеширование цифровых подписей»)

В BLAKE2 соль обрабатывается как однократный ввод в хеш-функцию во время инициализации, а не как ввод для каждой функции сжатия.

Предупреждение

Соленое хеширование (или просто хеширование) с BLAKE2 или любой другой криптографической хеш-функцией общего назначения, такой как SHA-256, не подходит для хеширования паролей. См. BLAKE2 FAQ для получения дополнительной информации.

>>> import os
>>> from hashlib import blake2b
>>> msg = b'some message'
>>> # Вычислить первый хеш со случайной солью.
>>> salt1 = os.urandom(blake2b.SALT_SIZE)
>>> h1 = blake2b(salt=salt1)
>>> h1.update(msg)
>>> # Вычислить второй хеш с другой случайной солью.
>>> salt2 = os.urandom(blake2b.SALT_SIZE)
>>> h2 = blake2b(salt=salt2)
>>> h2.update(msg)
>>> # Дайджесты разные.
>>> h1.digest() != h2.digest()
True

Персонализация

Иногда полезно заставить хеш-функцию создавать разные дайджесты для одного и того же ввода для разных целей. Цитата авторов хеш-функции Skein:

Мы рекомендуем всем разработчикам приложений серьезно подумать об этом; мы видели много протоколов, в которых хэш, вычисляемый в одной части протокола, может использоваться в совершенно другой части, потому что два вычисления хэша были выполнены для похожих или связанных данных, и злоумышленник может заставить приложение сделать входные данные хэша одно и тоже. Персонализация каждой хэш-функции, используемой в протоколе, в целом останавливает этот тип атаки.

(Семейство функций Skein Hash, p. 21)

BLAKE2 можно персонализировать, передав байты аргументу person:

>>> from hashlib import blake2b
>>> FILES_HASH_PERSON = b'MyApp Files Hash'
>>> BLOCK_HASH_PERSON = b'MyApp Block Hash'
>>> h = blake2b(digest_size=32, person=FILES_HASH_PERSON)
>>> h.update(b'the same content')
>>> h.hexdigest()
'20d9cd024d4fb086aae819a1432dd2466de12947831b75c5a30cf2676095d3b4'
>>> h = blake2b(digest_size=32, person=BLOCK_HASH_PERSON)
>>> h.update(b'the same content')
>>> h.hexdigest()
'cf68fb5761b9c44e7878bfb2c4c9aea52264a80b75005e65619778de59f383a3'

Персонализация вместе с ключевым режимом также может использоваться для получения разных ключей из одного.

>>> from hashlib import blake2s
>>> from base64 import b64decode, b64encode
>>> orig_key = b64decode(b'Rm5EPJai72qcK3RGBpW3vPNfZy5OZothY+kHY6h21KM=')
>>> enc_key = blake2s(key=orig_key, person=b'kEncrypt').digest()
>>> mac_key = blake2s(key=orig_key, person=b'kMAC').digest()
>>> print(b64encode(enc_key).decode('utf-8'))
rbPb15S/Z9t+agffno5wuhB77VbRi6F9Iv2qIxU7WHw=
>>> print(b64encode(mac_key).decode('utf-8'))
G9GtHFE1YluXY1zWPlYk1e/nWfu0WSEb0KRcjhDeP/o=

Древовидный режим

Вот пример хеширования минимального дерева с двумя листовыми узлами:

  10
 /  \
00  01

В данном примере используются 64-байтовые внутренние дайджесты и возвращается 32-байтовый окончательный дайджест:

>>> from hashlib import blake2b
>>>
>>> FANOUT = 2
>>> DEPTH = 2
>>> LEAF_SIZE = 4096
>>> INNER_SIZE = 64
>>>
>>> buf = bytearray(6000)
>>>
>>> # Левый лист
... h00 = blake2b(buf[0:LEAF_SIZE], fanout=FANOUT, depth=DEPTH,
...               leaf_size=LEAF_SIZE, inner_size=INNER_SIZE,
...               node_offset=0, node_depth=0, last_node=False)
>>> # Правый лист
... h01 = blake2b(buf[LEAF_SIZE:], fanout=FANOUT, depth=DEPTH,
...               leaf_size=LEAF_SIZE, inner_size=INNER_SIZE,
...               node_offset=1, node_depth=0, last_node=True)
>>> # Корневой узел
... h10 = blake2b(digest_size=32, fanout=FANOUT, depth=DEPTH,
...               leaf_size=LEAF_SIZE, inner_size=INNER_SIZE,
...               node_offset=0, node_depth=1, last_node=True)
>>> h10.update(h00.digest())
>>> h10.update(h01.digest())
>>> h10.hexdigest()
'3ad2a9b37c6070e374c7a8c508fe20ca86b6ed54e286e93a0318e95e881db5aa'

Благодарности

BLAKE2 был разработан Жан-Филиппом Аумассоном, Сэмюэлом Невесом, Зооко Уилкокс-О’Хирном и Кристианом Уиннерлейном на основе SHA-3 финалиста BLAKE, созданного Жан-Филиппом Аумассоном, Лукой Хенценом, Вилли Мейером и Рафаэльем К.-В. Фаном.

Он использует основной алгоритм из шифра ChaCha, разработанного Дэниелем Дж. Бернштейнм.

Реализация stdlib основана на модуле pyblake2. Он был написан Дмитрием Честных на основе реализации C, написанной Сэмюэлом Невесом. Документация была скопирована с pyblake2 и написана Дмитрием Честных.

Код C был частично переписан для Python Кристианом Хеймсом.

Следующее посвящение общественному достоянию относится как к реализации хэш- функции C, так и к коду расширения и к этой документации:

Насколько это возможно в соответствии с законом, автор(ы) передал(и) все авторские, а также смежные и смежные права на это программное обеспечение в общественное достояние всего мира. Данное программное обеспечение распространяется без каких-либо гарантий.

Вы должны были получить копию CC0 Public Domain Dedication вместе с этим программным обеспечением. Если нет, см. официальный сайт.

Следующие люди помогли с разработкой или внесли свои изменения в проект и общественное достояние в соответствии с Creative Commons Public Domain Dedication 1.0 Universal:

  • Александр Соколовский

См.также

Модуль hmac
Модуль для генерации кодов аутентификации сообщений с использованием хешей.
Модуль base64
Другой способ кодирования двоичных хэшей для небинарных сред.
https://blake2.net
Официальный сайт BLAKE2.
https://csrc.nist.gov/csrc/media/publications/fips/180/2/archive/2002-08-01/documents/fips180-2.pdf
Публикация FIPS 180-2 по алгоритмам безопасного хеширования.
https://en.wikipedia.org/wiki/Cryptographic_hash_function#Cryptographic_hash_algorithms
Статья в Википедии с информацией о том, какие известные проблемы у алгоритмов и что это означает в отношении их использования.
https://www.ietf.org/rfc/rfc2898.txt
PKCS #5: Спецификация криптографии на основе пароля, версия 2.0