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'

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

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