Función de generación de máscara

Herramienta criptográfica

Una función de generación de máscara ( MGF ) es una primitiva criptográfica similar a una función hash criptográfica, excepto que, mientras que la salida de una función hash tiene un tamaño fijo, una MGF admite una salida de una longitud variable. En este sentido, una MGF puede considerarse como una función de salida extensible (XOF): puede aceptar una entrada de cualquier longitud y procesarla para producir una salida de cualquier longitud. Las funciones de generación de máscara son completamente deterministas: para cualquier entrada dada y cualquier longitud de salida deseada, la salida siempre es la misma.

Definición

Una función de generación de máscaras toma una cadena de octetos de longitud variable y una longitud de salida deseada como entrada, y genera una cadena de octetos de la longitud deseada. Puede haber restricciones en la longitud de las cadenas de octetos de entrada y salida, pero dichos límites son generalmente muy grandes. Las funciones de generación de máscaras son deterministas; la salida de la cadena de octetos está completamente determinada por la cadena de octetos de entrada. La salida de una función de generación de máscaras debe ser pseudoaleatoria, es decir, si la semilla de la función es desconocida, no debería ser factible distinguir la salida de una cadena verdaderamente aleatoria. ^[1]

Aplicaciones

Las funciones de generación de máscaras, como generalizaciones de las funciones hash, son útiles dondequiera que existan funciones hash. Sin embargo, el uso de una MGF es deseable en casos en los que un hash de tamaño fijo sería inadecuado. Algunos ejemplos incluyen la generación de relleno , la producción de rellenos de un solo uso o flujos de claves en cifrado de clave simétrica y la obtención de resultados para generadores de números pseudoaleatorios .

Esquemas de relleno

Las funciones de generación de máscaras se propusieron por primera vez como parte de la especificación del relleno en el algoritmo RSA-OAEP . El algoritmo OAEP requería una función hash criptográfica que pudiera generar una salida de tamaño igual a un "bloque de datos" cuya longitud fuera proporcional a un mensaje de entrada de tamaño arbitrario. ^[1]

Generadores de números aleatorios

La publicación especial 800-90A del NIST ^[2] define una clase de generadores de números aleatorios criptográficamente seguros, uno de los cuales es el "Hash DRBG", que utiliza una función hash con un contador para producir una secuencia solicitada de bits aleatorios igual en tamaño al número solicitado de bits aleatorios.

Ejemplos

Quizás el mecanismo más común y sencillo para construir un MGF es aplicar iterativamente una función hash junto con un valor de contador que se incrementa. El contador puede incrementarse indefinidamente para generar nuevos bloques de salida hasta que se recopile una cantidad suficiente de salida. Este es el enfoque utilizado en MGF1.

mgf1

MGF1 es una función de generación de máscara definida en el Estándar de criptografía de clave pública n.° 1 publicado por RSA Laboratories: ^[1]

Opciones

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

función hash ( indica la longitud en octetos de la salida de la función hash) ${\displaystyle {\mathsf {hLen}}}$

Aporte

${\displaystyle Z}$

semilla a partir de la cual se genera la máscara, una cadena de octetos

${\displaystyle l}$

longitud prevista en octetos de la máscara, como máximo ${\displaystyle 2^{32}({\mathsf {hLen}})}$

Producción

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

máscara, una cadena de octetos de longitud ; o "máscara demasiado larga" ${\displaystyle l}$

Pasos

1. Si es así , muestra "máscara demasiado larga" y se detiene. ${\displaystyle l>2^{32}({\mathsf {hLen}})}$
2. Sea la cadena de octetos vacía. ${\displaystyle T}$
3. Para desde hasta , haga lo siguiente: ${\displaystyle {\mathsf {counter}}}$ ${\displaystyle 0}$ ${\displaystyle \left\lceil {\tfrac {l}{\mathsf {hLen}}}\right\rceil -1}$
   1. Convierte una cadena de octetos de longitud con el primitivo : ${\displaystyle {\mathsf {counter}}}$ ${\displaystyle C}$ ${\displaystyle 4}$ ${\displaystyle {\mathsf {I2OSP}}}$

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

   2. Concatenar el hash de la semilla y la cadena de octetos : ${\displaystyle Z}$ ${\displaystyle C}$ ${\displaystyle T}$
      ${\displaystyle T=T\shortparallel {\mathsf {Hash}}(Z\shortparallel C)}$
4. Muestra los octetos iniciales como la máscara de cadena de octetos. ${\displaystyle l}$ ${\displaystyle T}$

Código de ejemplo

A continuación se muestra el código Python que implementa MGF1:

importar  hashlibdef  mgf1 ( seed :  bytes ,  length :  int ,  hash_func = hashlib.sha1 ) -> bytes : """Función de generación de máscara.""" hLen = hash_func () . digest_size # https://www.ietf.org/rfc/rfc2437.txt # 1. Si l > 2^32(hLen), genera "máscara demasiado larga" y se detiene. if length > ( hLen << 32 ): raise ValueError ( "máscara demasiado larga" ) # 2. Sea T la cadena de octetos vacía. T = b "" # 3. Para el contador de 0 a \lceil{l / hLen}\rceil-1, haga lo siguiente: # Nota: \lceil{l / hLen}\rceil-1 es el número de iteraciones necesarias, # pero es más fácil verificar si hemos alcanzado la longitud deseada. contador = 0 mientras len ( T ) < length : # a. Convertir contador en una cadena de octetos C de longitud 4 con la primitiva I2OSP: C = I2OSP (contador, 4) C = int . to_bytes ( contador , 4 , "grande" ) # b. Concatenar el hash de la semilla Z y C con la cadena de octetos T: T = T || Hash (Z || C) T += hash_func ( semilla + C ) . digest () contador += 1 # 4. Generar los l octetos iniciales de T como la máscara de cadena de octetos. return T [: length ]                                                

Ejemplos de salidas de MGF1:

Python 3.10.4 (principal, 16 de abril de 2022, 16:28:41) [GCC 8.3.0] en Linux Escriba "ayuda", "derecho de autor", "créditos" o "licencia" para obtener más información. >>> 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 "barra" ,  50 ,  sha256 ) . hex () '382576a7841021cc28fc4c0948753fb8312090cea942ea4c4e735d10dc724b155f9f6069f289d61daca0cb814502ef04eae1'

Referencias

1. Laboratorios RSA. "RFC 2437 PKCS #1".
2. Instituto Nacional de Estándares y Tecnología (2012). "Recomendación para la generación de números aleatorios utilizando generadores de bits aleatorios deterministas" (PDF) . doi :10.6028/NIST.SP.800-90A. {{cite journal}}: Requiere citar revista |journal=( ayuda )