Функция генерации маски

Функция генерации маски ( MGF ) — это криптографический примитив, аналогичный криптографической хэш-функции, за исключением того, что, хотя выходные данные хеш-функции имеют фиксированный размер, MGF поддерживает выходные данные переменной длины. В этом отношении MGF можно рассматривать как функцию расширяемого вывода (XOF): она может принимать входные данные любой длины и обрабатывать их для получения выходных данных любой длины. Функции генерации маски полностью детерминированы: для любого заданного входа и любой желаемой длины вывода результат всегда один и тот же.

Определение

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

Приложения

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

Схемы заполнения

Функции генерации маски были впервые предложены как часть спецификации заполнения в алгоритме RSA-OAEP . Алгоритму OAEP требовалась криптографическая хэш-функция, которая могла бы генерировать выходные данные, равные по размеру «блоку данных», длина которого была пропорциональна входному сообщению произвольного размера.

Генераторы случайных чисел

Специальная публикация NIST 800-90A определяет класс криптографически безопасных генераторов случайных чисел, одним из которых является «Hash DRBG», который использует хеш-функцию со счетчиком для создания запрошенной последовательности случайных битов, равного по размеру запрошенному количеству случайных битов.

Примеры

Возможно, наиболее распространенным и простым механизмом построения MGF является итеративное применение хэш-функции вместе с увеличивающимся значением счетчика. Счетчик может увеличиваться бесконечно для получения новых выходных блоков, пока не будет собран достаточный объем выходных данных. Именно этот подход используется в MGF1.

МГФ1

MGF1 — это функция генерации маски, определенная в Стандарте криптографии с открытым ключом № 1, опубликованном RSA Laboratories:

Параметры

${\mathsf {Hash}}$

хеш-функция ( ${\mathsf {hLen}}$ обозначает длину в октетах вывода хеш-функции)

Вход

$Z$

начальное значение, из которого генерируется маска, строка октетов

$l$

предполагаемая длина маски в октетах, не более $2^{32}({\mathsf {hLen}})$

Выход

${\mathsf {mask}}$

маска, строка октетов длины $l$; или «маска слишком длинная»

Шаги

1. Если $l>2^{32}({\mathsf {hLen}})$, выведите «маска слишком длинная» и остановитесь.
2. Позволять $T$ быть пустой строкой октетов.
3. Для ${\mathsf {counter}}$ от $0$ к $\left\lceil {\tfrac {l}{\mathsf {hLen}}}\right\rceil -1$, сделайте следующее:
   1. Конвертировать ${\mathsf {counter}}$ в строку октетов $C$ длины $4$ с примитивом ${\mathsf {I2OSP}}$:

      $C={\mathsf {I2OSP}}({\mathsf {counter}},4)$

   2. Объединить хэш начального числа $Z$ и $C$ к строке октетов $T$:
      $T=T\shortparallel {\mathsf {Hash}}(Z\shortparallel C)$
4. Выведите ведущие $l$ октеты $T$ как маска строки октетов.

Пример кода

Ниже приведен код Python, реализующий MGF1:

import hashlib

def mgf1(seed: bytes, length: int, hash_func=hashlib.sha1) -> bytes:
    """Mask generation function."""
    hLen = hash_func().digest_size
    # https://www.ietf.org/rfc/rfc2437.txt
    # 1. If l > 2^32(hLen), output "mask too long" and stop.
    if length > (hLen << 32):
        raise ValueError("mask too long")
    # 2. Let T be the empty octet string.
    T = b""
    # 3. For counter from 0 to \lceil{l / hLen}\rceil-1, do the following:
    # Note: \lceil{l / hLen}\rceil-1 is the number of iterations needed,
    #       but it's easier to check if we have reached the desired length.
    counter = 0
    while len(T) < length:
        # a. Convert counter to an octet string C of length 4 with the primitive I2OSP: C = I2OSP (counter, 4)
        C = int.to_bytes(counter, 4, "big")
        # b. Concatenate the hash of the seed Z and C to the octet string T: T = T || Hash (Z || C)
        T += hash_func(seed + C).digest()
        counter += 1
    # 4. Output the leading l octets of T as the octet string mask.
    return T[:length]

Пример выходных данных MGF1:

Python 3.10.4 (main, Apr 16 2022, 16:28:41) [GCC 8.3.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> from mgf1 import mgf1
>>> from hashlib import sha256
>>> mgf1(b"foo", 3).hex()
'1ac907'
>>> mgf1(b"foo", 5).hex()
'1ac9075cd4'
>>> mgf1(b"bar", 5).hex()
'bc0c655e01'
>>> mgf1(b"bar", 50).hex()
'bc0c655e016bc2931d85a2e675181adcef7f581f76df2739da74faac41627be2f7f415c89e983fd0ce80ced9878641cb4876'
>>> mgf1(b"bar", 50, sha256).hex()
'382576a7841021cc28fc4c0948753fb8312090cea942ea4c4e735d10dc724b155f9f6069f289d61daca0cb814502ef04eae1'