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'

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

>>> 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'