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

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


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

Примечание

При необходимости использования хеш-функций adler32 или crc32 они доступны в модуле zlib.

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

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

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

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

Примечание

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

Примечание

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

Конструкторы для алгоритмов хеширования, которые всегда присутствуют в этом модуле, являются sha1(), sha224(), sha256(), sha384(), sha512(), blake2b() и blake2s(). md5() также обычно доступен, хотя он может отсутствовать, если вы используете редкую сборку Python, совместимую с FIPS. Дополнительные алгоритмы могут также быть доступными в зависимости от библиотеки 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: Название атрибут присутствует в CPython с момента его создания, но до Python 3.4 формально не уточнялось, поэтому может не существовать на некоторых платформах.

Хэш-объект имеет следующие методы:

hash.update(data)

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

Изменено в версии 3.1: Python GIL выпущен, чтобы позволить другому потоки бежать, в то время как обновления хэширования на данных, больше, чем 2 047 байтов, происходят, используя алгоритмы хеширования, поставляемые 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)

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

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

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

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

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

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

Примечание

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

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

Функция предоставляет сценарию основанную на пароле ключевую функцию происхождения, как определено в RFC 7914.

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

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

Availability: 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 или BLAKE2s. При необходимости они принимают следующие общие параметры:

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

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

Hash 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 для BLAKE2s, 0 для первого, крайнего левого, листа или в последовательном режиме).
  • node_depth: глубина узла (от 0 до 255, 0 для листьев или в последовательном режиме).
  • inner_size: внутренний размер дайджеста (от 0 до 64 для BLAKE2b, от 0 до 32 для BLAKE2s, 0 в последовательном режиме).
  • last_node: boolean, указывающий, является ли обработанный узел последним («False» для последовательного режима).
Объяснение параметров режима дерева.

Полный обзор хеширования деревьев см. в разделе 2.10 в разделе BLAKE2 specification.

Константы

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() для hex-кодированный строка).

>>> 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 байт для BLAKE2s. Например, чтобы заменить 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$). Криптографические хеш-функции были разработаны с устойчивостью к конфликтам в качестве основной цели, но текущая концентрация на атаке на криптографические хеш-функции может привести к тому, что данная криптографическая хеш-функция обеспечит меньшее сопротивление коллизии, чем ожидалось. Рандомизированное хеширование предлагает дополнительную защиту подписывающего лица, уменьшая вероятность, что выполняющий подготовительную работу может сгенерировать два или больше сообщения, что в конечном счете yield тот же хэш, значение во время цифрового поколения сигнатура обрабатывают —, даже если это практично, чтобы найти столкновения для функции хэширования. Однако использование рандомизированного хеширования может уменьшить степень защиты, обеспечиваемой цифровым сигнатура, когда все части сообщения подготовлены подписавшим.

(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)
>>> # The digests are different.
>>> h1.digest() != h2.digest()
True

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

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

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

(Семейство Skein хэш функции, 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 был разработан Jean-Philippe Aumasson, Samuel Neves, Zooko Wilcox-O’Hearn, и Christian Winnerlein на основе финалиста SHA-3 BLAKE, созданный Jean-Philippe Aumasson, Luca Henzen, Willi Meier и Raphael C.-W. Phan.

Он использует основной алгоритм из шифра ChaCha, разработанного компанией Daniel J. Bernstein.

Реализация stdlib основана на модуле pyblake2. Он был написан Dmitry Chestnykh на основе C реализации, написанной Samuel Neves. Документация была скопирована с pyblake2 и написана Dmitry Chestnykh.

C код был частично переписан для Python Christian Heimes.

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

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

Вы должны были получить копию CC0 Public Domain Dediction вместе с этим программным обеспечением. Если нет, см. https://creativecommons.org/publicdomain/zero/1.0/.

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

  • Alexandr Sokolovskiy

См.также

Модуль 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