Mask generation function

A mask generation function (MGF) is a cryptographic primitive similar to a cryptographic hash function except that while a hash function's output is a fixed size, a MGF supports output of a variable length. In this respect, a MGF can be viewed as a single-use XOR function: it can accept any length of input and process it to produce any length of output. Mask generation functions are completely deterministic: for any given input and desired output length the output is always the same.

Definition

A mask generation function takes an octet string of variable length and a desired output length as input, and outputs an octet string of the desired length. There may be restrictions on the length of the input and output octet strings, but such bounds are generally very large. Mask generation functions are deterministic; the octet string output is completely determined by the input octet string. The output of a mask generation function should be pseudorandom, that is, if the seed to the function is unknown, it should be infeasible to distinguish the output from a truly random string.[1]

Applications

Mask generation functions, as generalizations of hash functions, are useful wherever hash functions are. However, use of a MGF is desirable in cases where a fixed-size hash would be inadequate. Examples include generating padding, producing one time pads or keystreams in symmetric key encryption, and yielding outputs for pseudorandom number generators.

Padding schemes

Mask generation functions were first proposed as part of the specification for padding in the RSA-OAEP algorithm. The OAEP algorithm required a cryptographic hash function that could generate an output equal in size to a "data block" whose length was proportional to arbitrarily sized input message.[1]

Random number generators

NIST Special Publication 800-90A[2] defines a class of cryptographically secure random number generators, one of which is the "Hash DRBG", which uses a hash function with a counter to produce a requested sequence of random bits equal in size to the requested number of random bits.

Examples

Perhaps the most common and straightforward mechanism to build a MGF is to iteratively apply a hash function together with an incrementing counter value. The counter may be incremented indefinitely to yield new output blocks until a sufficient amount of output is collected. This is the approach used in MGF1.

MGF1

MGF1 is a mask generation function defined in the Public Key Cryptography Standard #1 published by RSA Laboratories[1]:

Options

${\displaystyle {\mathsf {Hash}}}$

hash function (${\displaystyle {\mathsf {hLen}}}$ denotes the length in octets of the hash function output)

Input

${\displaystyle Z}$

seed from which mask is generated, an octet string

${\displaystyle l}$

intended length in octets of the mask, at most ${\displaystyle 2^{32}({\mathsf {hLen}})}$

Output

${\displaystyle {\mathsf {mask}}}$

mask, an octet string of length ${\displaystyle l}$; or "mask too long"

Steps

1. If ${\displaystyle l>2^{32}({\mathsf {hLen}})}$, output "mask too long" and stop.
2. Let ${\displaystyle T}$ be the empty octet string.
3. For ${\displaystyle {\mathsf {counter}}}$ from ${\displaystyle 0}$ to ${\displaystyle \left\lceil {\tfrac {l}{\mathsf {hLen}}}\right\rceil -1}$, do the following:
   1. Convert ${\displaystyle {\mathsf {counter}}}$ to an octet string ${\displaystyle C}$ of length ${\displaystyle 4}$ with the primitive ${\displaystyle {\mathsf {I2OSP}}}$:

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

   2. Concatenate the hash of the seed ${\displaystyle Z}$ and ${\displaystyle C}$ to the octet string ${\displaystyle T}$:

      ${\displaystyle T=T\shortparallel {\mathsf {Hash}}(Z\shortparallel C)}$

4. Output the leading ${\displaystyle l}$ octets of ${\displaystyle T}$ as the octet string mask.

Example code

Below is Python code implementing MGF1:

import hashlib

def i2osp(integer: int, size: int = 4) -> str:
    return "".join([chr((integer >> (8 * i)) & 0xFF) for i in reversed(range(size))])

def mgf1(input_str: str, length: int, hash=hashlib.sha1) -> str:
    """Mask generation function."""
    counter = 0
    output = ""
    while len(output) < length:
        C = i2osp(counter, 4)
        output += hash(input_str + C).digest()
        counter += 1
    return output[:length]

Example outputs of MGF1:

Python 2.7.6 (default, Sep  9 2014, 15:04:36) 
[GCC 4.2.1 Compatible Apple LLVM 6.0 (clang-600.0.39)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> from mgf1 import mgf1
>>> from binascii import hexlify
>>> from hashlib import sha256
>>> hexlify(mgf1('foo', 3))
'1ac907'
>>> hexlify(mgf1('foo', 5))
'1ac9075cd4'
>>> hexlify(mgf1('bar', 5))
'bc0c655e01'
>>> hexlify(mgf1('bar', 50))
'bc0c655e016bc2931d85a2e675181adcef7f581f76df2739da74faac41627be2f7f415c89e983fd0ce80ced9878641cb4876'
>>> hexlify(mgf1('bar', 50, sha256))
'382576a7841021cc28fc4c0948753fb8312090cea942ea4c4e735d10dc724b155f9f6069f289d61daca0cb814502ef04eae1'

References

1. RSA Laboratories. "RFC 2437 PKCS #1".
2. National Institute of Standards and Technology. "Recommendation for Random Number Generation Using Deterministic Random Bit Generators" (PDF).