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

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

Для вычисления хеша некоторых данных, сначала необходимо создать объект хеша, вызвав соответствующую конструкторную функцию (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 байт для 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'

Хеширование с ключом

Хеширование с ключом может использоваться для аутентификации в качестве более быстрого и простого замены Hash-based message authentication code (HMAC). BLAKE2 может безопасно использоваться в режиме prefix-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 соль обрабатывается как однократный ввод в функцию хеширования во время инициализации, а не как ввод в каждую функцию сжатия.

>>> import os
>>> from hashlib import blake2b
>>> msg = b'some message'
>>> # Calculate the first hash with a random salt.
>>> salt1 = os.urandom(blake2b.SALT_SIZE)
>>> h1 = blake2b(salt=salt1)
>>> h1.update(msg)
>>> # Calculate the second hash with a different random salt.
>>> salt2 = os.urandom(blake2b.SALT_SIZE)
>>> h2 = blake2b(salt=salt2)
>>> h2.update(msg)
>>> # The digests are different.
>>> h1.digest() != h2.digest()
True

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

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

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

(Семейство функций хеширования Skein, стр. 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)
>>>
>>> # Left leaf
... 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)
>>> # Right leaf
... 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)
>>> # Root node
... 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'