Fonction de génération de masque

Une fonction de génération de masque ( MGF ) est une primitive cryptographique similaire à une fonction de hachage cryptographique, à ceci près que, alors que la sortie d'une fonction de hachage a une taille fixe, une MGF prend en charge une sortie de longueur variable. À cet égard, une MGF peut être considérée comme une fonction de sortie extensible (XOF) : elle peut accepter une entrée de n'importe quelle longueur et la traiter pour produire une sortie de n'importe quelle longueur. Les fonctions de génération de masque sont complètement déterministes : pour toute entrée donnée et toute longueur de sortie souhaitée, la sortie est toujours la même.

Une fonction de génération de masque prend en entrée une chaîne d'octets de longueur variable et une longueur de sortie souhaitée, et génère en sortie une chaîne d'octets de la longueur souhaitée. Il peut y avoir des restrictions sur la longueur des chaînes d'octets d'entrée et de sortie, mais ces limites sont généralement très grandes. Les fonctions de génération de masque sont déterministes ; la sortie de la chaîne d'octets est entièrement déterminée par la chaîne d'octets d'entrée. La sortie d'une fonction de génération de masque doit être pseudo-aléatoire, c'est-à-dire que si la graine de la fonction est inconnue, il doit être impossible de distinguer la sortie d'une chaîne véritablement aléatoire.

Les fonctions de génération de masque, en tant que généralisations des fonctions de hachage, sont utiles partout où des fonctions de hachage existent. Cependant, l'utilisation d'un MGF est souhaitable dans les cas où un hachage de taille fixe serait inadéquat. Les exemples incluent la génération de remplissage , la production de remplissages à usage unique ou de flux de clés dans le chiffrement à clé symétrique et la production de sorties pour les générateurs de nombres pseudo-aléatoires .

Les fonctions de génération de masque ont été proposées pour la première fois dans le cadre de la spécification du remplissage dans l' algorithme RSA-OAEP . L'algorithme OAEP nécessitait une fonction de hachage cryptographique capable de générer une sortie de taille égale à un « bloc de données » dont la longueur était proportionnelle à un message d'entrée de taille arbitraire.

La publication spéciale NIST 800-90A définit une classe de générateurs de nombres aléatoires cryptographiquement sécurisés, dont le « Hash DRBG », qui utilise une fonction de hachage avec un compteur pour produire une séquence demandée de bits aléatoires de taille égale au nombre demandé de bits aléatoires.

Le mécanisme le plus courant et le plus simple pour créer un MGF consiste peut-être à appliquer de manière itérative une fonction de hachage avec une valeur de compteur incrémentielle. Le compteur peut être incrémenté indéfiniment pour produire de nouveaux blocs de sortie jusqu'à ce qu'une quantité suffisante de sortie soit collectée. C'est l'approche utilisée dans MGF1.

MGF1 est une fonction de génération de masque définie dans la norme de cryptographie à clé publique n°1 publiée par RSA Laboratories :

Options

fonction de hachage ( indique la longueur en octets de la sortie de la fonction de hachage)

Saisir

graine à partir de laquelle le masque est généré, une chaîne d'octets

longueur prévue en octets du masque, au plus

Sortir

masque, une chaîne d'octets de longueur ; ou « masque trop long »

Mesures

1. Si , affiche « masque trop long » et arrête.$2^\{32\}(\{\backslash mathsf\; \{hLen\}\})l>2^{32}\left(hL\mathrm{et}n\right)$2^{32}({\mathsf {hLen}})}" data-src="https://wikimedia.org/api/rest_v1/media/math/render/svg/0eab502edf30e3db8fb6a20261e906c76a77d786">
2. Soit la chaîne d'octets vide.
3. Pour de à , procédez comme suit :
   1. Convertir en une chaîne d'octets de longueur avec la primitive :

   2. Concaténer le hachage de la graine et la chaîne d'octets :
4. Affichez les octets de début sous forme de masque de chaîne d'octets.

Vous trouverez ci-dessous le code Python implémentant MGF1 :

importer 
hashlib
def 
mgf1 ( seed : 
bytes , 
length : 
int , 
hash_func = hashlib . sha1 ) 
-> 
bytes : 
Fonction de génération de masque.""" hLen = hash_func () . digest_size # https://www.ietf.org/rfc/rfc2437.txt # 1. Si l > 2^32(hLen), affiche "mask too long" et arrête. if length > ( hLen << 32 ): raise ValueError ( "mask too long" ) # 2. Soit T la chaîne d'octets vide. T = b # 3. Pour un compteur de 0 à \lceil{l / hLen} ceil-1, procédez comme suit : # Remarque : \lceil{l / hLen} ceil-1 est le nombre d'itérations nécessaires, # mais il est plus facile de vérifier si nous avons atteint la longueur souhaitée. compteur = 0 tant que len ( T ) < longueur : # a. Convertir le compteur en une chaîne d'octets C de longueur 4 avec la primitive I2OSP : C = I2OSP (compteur, 4) C = int . to_bytes ( compteur , 4 , "big" ) # b. Concaténer le hachage de la graine Z et C à la chaîne d'octets T : T = T || Hash (Z || C) T += hash_func ( graine + C ) . digest () compteur += 1 # 4. Afficher les l premiers octets de T sous forme de masque de chaîne d'octets. retourner T [: longueur ]

Exemples de sorties de MGF1 :

Python 3.10.4 (main, 16 avr. 2022, 16:28:41) [GCC 8.3.0] sur Linux 
Tapez "help", "copyright", "credits" ou "license" pour plus d'informations. 
>>> 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 "barre" , 
50 , 
sha256 ) . hex () 
'382576a7841021cc28fc4c0948753fb8312090cea942ea4c4e735d10dc724b155f9f6069f289d61daca0cb814502ef04eae1'