« SHA-2 » : différence entre les versions
m →Bourrage : tiret |
Retrait d'une virgule qui n'avait rien à faire là. |
||
(23 versions intermédiaires par 17 utilisateurs non affichées) | |||
Ligne 1 : | Ligne 1 : | ||
'''SHA-2''' ({{lang|en|''[[Secure Hash Algorithm]]''}}) est une famille de [[fonction de hachage|fonctions de hachage]] qui ont été conçues par la {{lang|en|''[[National Security Agency]]''}} des États-Unis (NSA), sur le modèle des fonctions [[SHA-1]] et [[SHA-0]], elles-mêmes fortement inspirées de la fonction [[MD4]] de [[Ron Rivest]] (qui a donné parallèlement [[MD5]]). Telle que décrite par le {{lang|en|''[[National Institute of Standards and Technology]]''}} (NIST), elle comporte les fonctions |
'''SHA-2''' ({{lang|en|''[[Secure Hash Algorithm]]''}}) est une famille de [[fonction de hachage|fonctions de hachage]] qui ont été conçues par la {{lang|en|''[[National Security Agency]]''}} des [[États-Unis]] (NSA), sur le modèle des fonctions [[SHA-1]] et [[SHA-0]], elles-mêmes fortement inspirées de la fonction [[MD4]] de [[Ron Rivest]] (qui a donné parallèlement [[MD5]]). Telle que décrite par le {{lang|en|''[[National Institute of Standards and Technology]]''}} (NIST), elle comporte les fonctions '''SHA-256''' et '''SHA-512''' dont les algorithmes sont similaires mais opèrent sur des tailles de mot différentes (32 bits pour SHA-256 et 64 bits pour SHA-512), '''SHA-224''' et '''SHA-384''' qui sont essentiellement des versions des précédentes dont la sortie est tronquée, et plus récemment '''SHA-512/256''' et '''SHA-512/224''' qui sont des versions tronquées de SHA-512. Le dernier suffixe indique le nombre de bits du haché. |
||
Les algorithmes de la famille SHA-2, SHA-256, SHA-384 et SHA-512, sont décrits et publiés en compagnie de SHA-1 comme standard du gouvernement fédéral des États-Unis ([[Federal Information Processing Standard]]) dans le ''FIPS 180-2 (Secure Hash Standard)'' datant de 2002 (une prépublication pour appels à commentaires a été faite en 2001). La fonction SHA-224 est ajoutée un peu plus tard. La dernière version à ce jour, le ''FIPS 180-4 (Secure Hash Standard)'' date de mars 2012 et ajoute les fonctions SHA-512/256 et SHA-512/224<ref>voir la page [http://csrc.nist.gov/groups/ST/toolkit/secure_hashing.html Secure Hashing du NIST]</ref>. |
Les algorithmes de la famille SHA-2, SHA-256, SHA-384 et SHA-512, sont décrits et publiés en compagnie de SHA-1 comme standard du gouvernement fédéral des États-Unis ([[Federal Information Processing Standard]]) dans le ''FIPS 180-2 (Secure Hash Standard)'' datant de 2002 (une prépublication pour appels à commentaires a été faite en 2001). La fonction SHA-224 est ajoutée un peu plus tard. La dernière version à ce jour, le ''FIPS 180-4 (Secure Hash Standard)'' date de {{date-|mars 2012}} et ajoute les fonctions SHA-512/256 et SHA-512/224<ref>voir la page [http://csrc.nist.gov/groups/ST/toolkit/secure_hashing.html Secure Hashing du NIST]</ref>. |
||
En 2005, des problèmes de sécurité de [[SHA-1]] ont été mis en évidence : il existe pour la recherche de collisions une attaque théorique nettement plus rapide que l'[[attaque des anniversaires|attaque générique des anniversaires]] sur les fonctions de hachage. Bien que l'algorithme de SHA-2 partage des similarités avec celui de SHA-1, ces attaques n'ont actuellement pas pu être étendues à SHA-2. Le NIST a cependant organisé un concours pour sélectionner une nouvelle fonction de hachage, [[SHA-3]]. Le concours a débouché fin 2012 sur le choix d'une nouvelle famille de fonctions dont la conception est très différente de SHA-1 et de SHA-2. La nouvelle famille de fonctions est présentée comme un autre choix possible, elle ne remet pas en cause l'utilisation de SHA-2 du moins dans l'immédiat. |
En 2005, des problèmes de sécurité de [[SHA-1]] ont été mis en évidence : il existe pour la recherche de collisions une attaque théorique nettement plus rapide que l'[[attaque des anniversaires|attaque générique des anniversaires]] sur les fonctions de hachage. Bien que l'algorithme de SHA-2 partage des similarités avec celui de SHA-1, ces attaques n'ont actuellement pas pu être étendues à SHA-2. Le NIST a cependant organisé un concours pour sélectionner une nouvelle fonction de hachage, [[SHA-3]]. Le concours a débouché fin 2012 sur le choix d'une nouvelle famille de fonctions dont la conception est très différente de SHA-1 et de SHA-2. La nouvelle famille de fonctions est présentée comme un autre choix possible, elle ne remet pas en cause l'utilisation de SHA-2 du moins dans l'immédiat. |
||
Ligne 83 : | Ligne 83 : | ||
Les opérations utilisées sont les suivantes : |
Les opérations utilisées sont les suivantes : |
||
* les [[opération bit à bit|opérations bit à bit]] sur les mots de 32 bits (voir le paragraphe [[#Symboles]] pour les notations utilisées) ; |
* les [[opération bit à bit|opérations bit à bit]] sur les mots de 32 bits (voir le paragraphe [[#Symboles]] pour les notations utilisées) ; |
||
* l'opération sur les mots correspondant à l’addition modulo {{math|2<sup>32</sup>}}, c'est-à-dire que la somme{{math|§=''z'' = ''x'' + ''y''}} de deux mots {{math|''x''}} |
* l'opération sur les mots correspondant à l’addition modulo {{math|2<sup>32</sup>}}, c'est-à-dire que la somme {{math|§=''z'' = ''x'' + ''y''}} de deux mots {{math|''x''}} et {{math|''y''}} représentant des entiers naturels {{math|''X''}} et {{math|''Y''}} ({{math|0 ≤ ''X'' < 2<sup>32</sup>}} et {{math|0 ≤ ''Y'' < 2<sup>32</sup>}}) est la représentation binaire de l'entier {{math|''Z''}}, tel que {{math|§=''Z'' = ''X'' + ''Y'' mod 2<sup>32</sup>}}, {{math|0 ≤ ''Z'' < 2<sup>32</sup>}}, |
||
* l'opération de décalage des bits à droite <math>SHR^n(x)</math>, où x est un mot de 32 bits et <math>0 \le n < 32</math>, est définie par : |
* l'opération de décalage des bits à droite <math>SHR^n(x)</math>, où x est un mot de 32 bits et <math>0 \le n < 32</math>, est définie par : |
||
*: <math>SHR^n(x) = x >> n</math> ; |
*: <math>SHR^n(x) = x >> n</math> ; |
||
Ligne 142 : | Ligne 142 : | ||
Il s'agit ici de compléter le message ''M'' pour qu'il soit d'une taille multiple de 512 bits. Le [[bourrage]] utilise la représentation binaire de l'entier {{math|''l''}} qui est la longueur en bits du message ''M'' (renforcement de [[Construction de Merkle-Damgård|Merkle-Damgård]]). Pour ce faire on ajoute successivement : |
Il s'agit ici de compléter le message ''M'' pour qu'il soit d'une taille multiple de 512 bits. Le [[bourrage]] utilise la représentation binaire de l'entier {{math|''l''}} qui est la longueur en bits du message ''M'' (renforcement de [[Construction de Merkle-Damgård|Merkle-Damgård]]). Pour ce faire on ajoute successivement : |
||
* un bit à 1 à la fin du message ''M'', |
* un bit à 1 à la fin du message ''M'', |
||
* {{math|''k''}} bits à 0 de bourrage, où {{math|''k''}} est le plus petit entier naturel vérifiant {{math|§=''l'' + 1 + ''k'' ≡ 448 mod 512}} |
* {{math|''k''}} bits à 0 de bourrage, où {{math|''k''}} est le plus petit [[entier naturel]] vérifiant {{math|§=''l'' + 1 + ''k'' ≡ 448 mod 512}} |
||
* un bloc de 64 bits qui donne la représentation binaire de {{math|''l''}}. |
* un bloc de 64 bits qui donne la représentation binaire de {{math|''l''}}. |
||
Exemples : |
Exemples : |
||
* Pour ''M'' = "abc", {{math|§=l = 3 × 8 = 24}}, {{math|''k'' ≡ 448 - (24 + 1) ≡ 423 mod 512}}, donc {{math|§=''k''= 423}} ; |
* Pour ''M'' = "abc", {{math|§=''l'' = 3 × 8 = 24}} bits, {{math|''k'' ≡ 448 - (24 + 1) ≡ 423 mod 512}}, donc {{math|§=''k''= 423}} ; |
||
** on ajoute à ''M'' |
** on ajoute à ''M'' |
||
*** d'abord un bit à 1, |
*** d'abord un bit à 1, |
||
*** puis 423 bits à 0 , |
*** puis 423 bits à 0 , |
||
*** puis 64 bits représentant 24 en binaire, soit « 0000 ... 0000 |
*** puis 64 bits représentant 24 en binaire, soit « 0000 ... 0000 0001 1000 » |
||
*: on obtient alors un message complété dont la longueur est le plus petit multiple de 512 bits supérieur à la longueur initiale de ''M''. |
*: on obtient alors un message complété dont la longueur est le plus petit multiple de 512 bits supérieur à la longueur initiale de ''M''. |
||
* Pour ''M'' de longueur 500 bits, {{math|''k'' ≡ 448 - (500 + 1) ≡ -53 mod 512}} ; donc{{math|§=''k''= 512 - 53 = 459}} ; |
* Pour ''M'' de longueur <math>l=500</math> bits, {{math|''k'' ≡ 448 - (500 + 1) ≡ -53 mod 512}} ; donc {{math|§=''k''= 512 - 53 = 459}} ; |
||
** on ajoute à ''M'' |
** on ajoute à ''M'' |
||
*** d'abord un bit à 1, |
*** d'abord un bit à 1, |
||
Ligne 161 : | Ligne 161 : | ||
===== Découpage en blocs ===== |
===== Découpage en blocs ===== |
||
Le message complété est découpé en N blocs de 512 bits, notés <math>M^{(1)}, M^{(2)}, ..., M^{(N)}~</math>. |
Le message complété est découpé en N blocs de 512 bits, notés <math>M^{(1)}, M^{(2)}, ..., M^{(N)}~</math>. |
||
Chaque bloc de 512 bits est ensuite découpé en 16 mots de 32 bits, notés <math>M_0^{(i)}, M_1^{(i)}, ..., M_{15}^{(i)}</math>. |
Chaque bloc de 512 bits est ensuite découpé en 16 mots de 32 bits, notés <math>\forall i \in [1, N],\ \ M_0^{(i)}, M_1^{(i)}, ..., M_{15}^{(i)}</math>. |
||
===== Initialisations ===== |
===== Initialisations ===== |
||
Ligne 227 : | Ligne 227 : | ||
} |
} |
||
Après répétition des quatre étapes ci-dessus pour les N blocs du message M, (i.e., après traitement de <math>M^{(N)}~</math>), le condensé de 256 bits de M est obtenu par concaténation des valeurs |
Après répétition des quatre étapes ci-dessus pour les N blocs du message M, (i.e., après traitement de <math>M^{(N)}~</math>), le condensé de 256 bits de M est obtenu par [[concaténation]] des valeurs |
||
::<math>H_0^{(N)}||H_1^{(N)}||H_2^{(N)}||H_3^{(N)}||H_4^{(N)}||H_5^{(N)}||H_6^{(N)}||H_7^{(N)}</math> |
::<math>H_0^{(N)}||H_1^{(N)}||H_2^{(N)}||H_3^{(N)}||H_4^{(N)}||H_5^{(N)}||H_6^{(N)}||H_7^{(N)}</math> |
||
Ligne 234 : | Ligne 234 : | ||
La fonction SHA-224 est publiée pour la première fois en 2004. Le résultat produit (haché, « hash » ou condensat) est de 224 [[Bit (informatique)|bits]]. Elle a été spécialement conçue pour fournir une empreinte dont la taille correspond à quatre clés [[Data Encryption Standard|DES]] de 56 bits chacune. L'algorithme est celui de SHA-256 avec pour seules différences |
La fonction SHA-224 est publiée pour la première fois en 2004. Le résultat produit (haché, « hash » ou condensat) est de 224 [[Bit (informatique)|bits]]. Elle a été spécialement conçue pour fournir une empreinte dont la taille correspond à quatre clés [[Data Encryption Standard|DES]] de 56 bits chacune. L'algorithme est celui de SHA-256 avec pour seules différences |
||
* des valeurs différentes pour l'initialisation (variables h0, … , h7) ; |
* des valeurs différentes pour l'initialisation (variables h0, … , h7) ; |
||
* une sortie tronquée à 224 bits (concaténation des contenus des 7 premières variables h0, … , h6). |
* une sortie tronquée à 224 bits ([[concaténation]] des contenus des 7 premières variables h0, … , h6). |
||
== SHA-512 == |
== SHA-512 == |
||
Ligne 252 : | Ligne 252 : | ||
La fonction SHA-384 est apparue en compagnie de SHA-256 et SHA-512. Elle produit un haché de 384 [[Bit (informatique)|bits]]. L'algorithme est celui de SHA-512 avec pour seules différences |
La fonction SHA-384 est apparue en compagnie de SHA-256 et SHA-512. Elle produit un haché de 384 [[Bit (informatique)|bits]]. L'algorithme est celui de SHA-512 avec pour seules différences |
||
* des valeurs différentes pour l'initialisation (variables h0, … , h7) ; |
* des valeurs différentes pour l'initialisation (variables h0, … , h7) ; |
||
* une sortie tronquée à 384 bits (concaténation des contenus des 6 premières variables h0, … , h5). |
* une sortie tronquée à 384 bits ([[concaténation]] des contenus des 6 premières variables h0, … , h5). |
||
== Cryptanalyse == |
== Cryptanalyse == |
||
Ligne 266 : | Ligne 266 : | ||
* {{en}} Henri Gilbert, Helena Handschuh : {{lang|en|''Security Analysis of SHA-256 and Sisters''}}. {{lang|en|Selected Areas in Cryptography}} 2003: 175-193 |
* {{en}} Henri Gilbert, Helena Handschuh : {{lang|en|''Security Analysis of SHA-256 and Sisters''}}. {{lang|en|Selected Areas in Cryptography}} 2003: 175-193 |
||
* Versions successives du ''Secure Hash Standard'' du NIST à partir de l'apparition de SHA-2 (voir aussi la page [http://csrc.nist.gov/groups/ST/toolkit/secure_hashing.html Secure Hashing]) |
* Versions successives du ''Secure Hash Standard'' du NIST à partir de l'apparition de SHA-2 (voir aussi la page [http://csrc.nist.gov/groups/ST/toolkit/secure_hashing.html Secure Hashing]) |
||
** [http://csrc.nist.gov/publications/fips/fips180-2/fips180-2.pdf FIPS 180-2] version d'août 2001 |
** [http://csrc.nist.gov/publications/fips/fips180-2/fips180-2.pdf FIPS 180-2] version d'{{date-|août 2001}} |
||
** [http://csrc.nist.gov/publications/fips/fips180-3/fips180-3_final.pdf FIPS 180-3] version finale d'octobre 2008 |
** [http://csrc.nist.gov/publications/fips/fips180-3/fips180-3_final.pdf FIPS 180-3] version finale d'{{date-|octobre 2008}} |
||
** [http://csrc.nist.gov/publications/fips/fips180-4/fips-180-4.pdf FIPS 180-4] mars 2012 |
** [http://csrc.nist.gov/publications/fips/fips180-4/fips-180-4.pdf FIPS 180-4] {{date-|mars 2012}} |
||
=== Articles connexes === |
=== Articles connexes === |
||
Ligne 276 : | Ligne 276 : | ||
=== Liens externes === |
=== Liens externes === |
||
* [http://www.xorbin.com/tools/sha256-hash-calculator Calculateur en ligne] Encodage de chaînes de caractères par les fonctions de hachage les plus utilisées. |
* [http://www.xorbin.com/tools/sha256-hash-calculator Calculateur en ligne] Encodage de [[Chaîne de caractères|chaînes de caractères]] par les fonctions de hachage les plus utilisées. |
||
* {{fr}} [http://www.sha256.fr/ Calculatrice qui génère SHA-256 en ligne] |
* {{fr}} [http://www.sha256.fr/ Calculatrice qui génère SHA-256 en ligne] |
||
* {{fr}} [http://www.sha512.fr/ Calculatrice qui génère SHA-512 en ligne] |
* {{fr}} [http://www.sha512.fr/ Calculatrice qui génère SHA-512 en ligne] |
||
Ligne 282 : | Ligne 282 : | ||
{{Palette|Fonctions de hachage cryptographiques|Bitcoin}} |
{{Palette|Fonctions de hachage cryptographiques|Bitcoin}} |
||
{{Portail|cryptologie|programmation informatique}} |
{{Portail|cryptologie|programmation informatique|Cryptomonnaies}} |
||
[[Catégorie:Algorithme de hachage]] |
[[Catégorie:Algorithme de hachage]] |
Dernière version du 24 juin 2024 à 16:31
SHA-2 (Secure Hash Algorithm) est une famille de fonctions de hachage qui ont été conçues par la National Security Agency des États-Unis (NSA), sur le modèle des fonctions SHA-1 et SHA-0, elles-mêmes fortement inspirées de la fonction MD4 de Ron Rivest (qui a donné parallèlement MD5). Telle que décrite par le National Institute of Standards and Technology (NIST), elle comporte les fonctions SHA-256 et SHA-512 dont les algorithmes sont similaires mais opèrent sur des tailles de mot différentes (32 bits pour SHA-256 et 64 bits pour SHA-512), SHA-224 et SHA-384 qui sont essentiellement des versions des précédentes dont la sortie est tronquée, et plus récemment SHA-512/256 et SHA-512/224 qui sont des versions tronquées de SHA-512. Le dernier suffixe indique le nombre de bits du haché.
Les algorithmes de la famille SHA-2, SHA-256, SHA-384 et SHA-512, sont décrits et publiés en compagnie de SHA-1 comme standard du gouvernement fédéral des États-Unis (Federal Information Processing Standard) dans le FIPS 180-2 (Secure Hash Standard) datant de 2002 (une prépublication pour appels à commentaires a été faite en 2001). La fonction SHA-224 est ajoutée un peu plus tard. La dernière version à ce jour, le FIPS 180-4 (Secure Hash Standard) date de et ajoute les fonctions SHA-512/256 et SHA-512/224[1].
En 2005, des problèmes de sécurité de SHA-1 ont été mis en évidence : il existe pour la recherche de collisions une attaque théorique nettement plus rapide que l'attaque générique des anniversaires sur les fonctions de hachage. Bien que l'algorithme de SHA-2 partage des similarités avec celui de SHA-1, ces attaques n'ont actuellement pas pu être étendues à SHA-2. Le NIST a cependant organisé un concours pour sélectionner une nouvelle fonction de hachage, SHA-3. Le concours a débouché fin 2012 sur le choix d'une nouvelle famille de fonctions dont la conception est très différente de SHA-1 et de SHA-2. La nouvelle famille de fonctions est présentée comme un autre choix possible, elle ne remet pas en cause l'utilisation de SHA-2 du moins dans l'immédiat.
A, B, C, D, E, F, G et H sont des mots de 32 bits (SHA-256) ou 64 bits (SHA-512) ;
⊞ est l'addition modulo 232 (SHA-256) ou 264 (SHA-512), soit l'addition des entiers machines non signés de 32 ou 64 bits, qui est non linéaire sur F2 ;
les fonctions Ch et Ma se calculent par opérations bit à bit logiques, elles sont non linéaires ;
les fonctions Σ0 et Σ1 se calculent par décalage circulaire et xor (somme sur F2) ;
Kt est une constante (32 ou 64 bits) qui dépend du numéro de tour t ;
Wt est un mot de 32 (SHA-256) ou 64 bits (SHA-512) qui dépend du numéro de tour t ; il est obtenu par une procédure d'expansion à partir du bloc de donnée (512 ou 1024 bits) dont le traitement est en cours.
Description
[modifier | modifier le code]Comme toutes les fonctions de hachage les fonctions SHA-2 prennent en entrée un message de taille arbitraire, avec une borne (toute théorique) pour celle-ci, et produisent un résultat (appelé « hash », haché, condensat ou encore empreinte…) de taille fixe. La taille du haché est indiquée par le suffixe : 224 bits pour SHA-224, 256 bits pour SHA-256, 384 bits pour SHA-384 et 512 bits pour SHA-512.
Les algorithmes de la famille SHA-2 sont très semblables, il y a essentiellement deux fonctions différentes, SHA-256 et SHA-512, les autres étant des variantes de l'une ou l'autre. Les fonctions SHA-256 et SHA-512 ont la même structure mais diffèrent par la taille des mots et des blocs utilisés. Cette structure est assez proche de celle de SHA-1, mais un peu plus complexe et en évite certaines faiblesses connues. Elle se rattache plus généralement à une famille de fonctions de hachage inspirées de MD4 et MD5 de Ron Rivest. On retrouve comme primitives l'addition pour des entiers de taille fixe n soit une addition modulo 2n, opération non linéaire (au sens de l'algèbre linéaire) sur le corps des booléens F2, ainsi que des opérations bit à bit (xor et autres).
Comme toutes les fonctions de cette famille (sauf SHA-3, reposant sur une fonction éponge), elles suivent un schéma itératif qui suit la construction de Merkle-Damgård (sans opération de finalisation). La fonction de compression itérée possède deux entrées de taille fixe, la seconde entrée étant de même taille que la sortie de la fonction :
- une donnée obtenue par découpage du message à traiter, la taille est de 512 bits pour SHA-256 et SHA-224 et de 1024 bits pour SHA-512 et SHA-384,
- le résultat de la fonction de compression à l'itération précédente (256 bits pour SHA-256 et SHA-224, 512 pour SHA-512 et SHA-384).
Les entrées de la fonction de compression sont découpées
- en mots de 32 bits pour SHA-256 et SHA-224,
- en mots de 64 bits pour SHA-512 et SHA-384.
La fonction de compression répète les mêmes opérations un nombre de fois déterminé, on parle de tour ou de ronde, 64 tours pour SHA-256, 80 tours pour SHA-512. Chaque tour fait intervenir comme primitives l'addition entière pour des entiers de taille fixe, soit une addition modulo 232 ou modulo 264, des opérations bit à bit : opérations logiques, décalages avec perte d'une partie des bits et décalages circulaires, et des constantes prédéfinies, utilisées également pour l'initialisation.
Avant traitement, le message est complété par bourrage de façon que sa longueur soit un multiple de la taille du bloc traité par la fonction de compression. Le bourrage incorpore la longueur (en binaire) du mot à traiter : c'est le renforcement de Merkle-Damgård ((en)Merkle-Damgård strengthening), ce qui permet de réduire la résistance aux collisions de la fonction de hachage à celle de la fonction de compression. Cette longueur est stockée en fin de bourrage sur 64 bits dans le cas de SHA-256 (comme pour SHA-1), sur 128 bits dans le cas de SHA-512, ce qui « limite » la taille des messages à traiter à 264 bits pour SHA-256 (et SHA-224) et à 2128 bits pour SHA-512 (et SHA-384).
SHA-256
[modifier | modifier le code]La fonction SHA-256 devient en 2002 un standard fédéral de traitement de l'information (FIPS du NIST). Elle produit un haché de 256 bits. Les caractéristiques de SHA-256 sont les suivantes :
- taille du message : 264 bits maximum
- taille des blocs : 512 bits
- taille des mots : 32 bits
- taille du condensé : 256 bits
- niveau de sécurité attendu (collisions) : 2128 bits (attaque des anniversaires)
- nombre de tours (fonction de compression) : 64
Algorithme
[modifier | modifier le code]L'algorithme peut être découpé en deux phases
- Le prétraitement : le message est complété par remplissage comprenant la taille du message (renforcement de Merkle-Damgård) de façon à pouvoir le découper en blocs de 512 bits ;
- Le calcul du condensé par itération de la fonction de compression sur la suite des blocs obtenus en découpant le message (schéma itératif de Merkle-Damgård).
Symboles et termes utilisés
[modifier | modifier le code]Paramètres
[modifier | modifier le code]a, b, c, ..., h = variables de travail (en l'occurrence des mots de w bits), utilisées dans le calcul des hachés
= la valeur de hachage n° i. est la valeur initiale du hachage. est la dernière valeur de hachage.
= le mot (w bits) n° j de la valeur de hachage n° i, où est le mot de poids le plus fort (à gauche) de la valeur de hachage i.
= constantes itératives selon la valeur de t, utilisées dans le calcul de hachage
k = nombre de 0 ajoutés au message lors du prétraitement (complément)
l = longueur du message M, en bits
m = nombre de bits contenus dans un bloc, soit 512 bits
M = message à traiter
= bloc n° i (m bits), du message M
= mot (w bits) n° j, du bloc (m bits) n° i, du message M
n = nombre de bits de décalage ou de rotation à appliquer au mot quand associé à une fonction binaire
N = nombre de blocs de m bits contenus dans le message M après complément
T = variable temporaire, mot de w bits, utilisée dans le calcul de condensé
w = nombre de bits contenus dans un mot, soit 32 bits.
= le mot n° t du tableau déduit du message
Symboles
[modifier | modifier le code]La notation hexadécimale utilisée ici sera:
- exemple:
= opération binaire AND
= opération binaire OR
= opération binaire XOR
= complément binaire
= addition modulo
= décalage binaire à gauche, où s'obtient en supprimant les n bits de gauche de x et ajoutant n zéros à droite.
= décalage binaire à droite, où s'obtient en supprimant les n bits de droite de x et ajoutant n zéros à gauche.
Opérations sur les mots
[modifier | modifier le code]Les opérations utilisées sont les suivantes :
- les opérations bit à bit sur les mots de 32 bits (voir le paragraphe #Symboles pour les notations utilisées) ;
- l'opération sur les mots correspondant à l’addition modulo 232, c'est-à-dire que la somme z = x + y de deux mots x et y représentant des entiers naturels X et Y (0 ≤ X < 232 et 0 ≤ Y < 232) est la représentation binaire de l'entier Z, tel que Z = X + Y mod 232, 0 ≤ Z < 232,
- l'opération de décalage des bits à droite , où x est un mot de 32 bits et , est définie par :
- ;
- l'opération de rotation binaire vers la droite , où x est un mot de 32 bits et , est définie par :
- .
Fonctions et constantes
[modifier | modifier le code]Fonctions
[modifier | modifier le code]Cette section décrit les fonctions utilisées lors du calcul des valeurs de hachage. SHA-256 utilise 6 fonctions logiques travaillant sur des mots de 32 bits notés x, y, z. Le résultat de chacune de ces fonctions est un nouveau mot de 32 bits en sortie.
Constantes
[modifier | modifier le code]SHA-256 utilise 64 valeurs constantes de mots de 32 bits, notés . ces nombres représentent les 32 premiers bits de la partie décimale des racines cubiques des 64 premiers nombres premiers. Les valeurs suivantes sont exprimées en notation hexadécimale (base 16).
0x428a2f98 | 0x71374491 | 0xb5c0fbcf | 0xe9b5dba5 | 0x3956c25b | 0x59f111f1 | 0x923f82a4 | 0xab1c5ed5 | |
0xd807aa98 | 0x12835b01 | 0x243185be | 0x550c7dc3 | 0x72be5d74 | 0x80deb1fe | 0x9bdc06a7 | 0xc19bf174 | |
0xe49b69c1 | 0xefbe4786 | 0x0fc19dc6 | 0x240ca1cc | 0x2de92c6f | 0x4a7484aa | 0x5cb0a9dc | 0x76f988da | |
0x983e5152 | 0xa831c66d | 0xb00327c8 | 0xbf597fc7 | 0xc6e00bf3 | 0xd5a79147 | 0x06ca6351 | 0x14292967 | |
0x27b70a85 | 0x2e1b2138 | 0x4d2c6dfc | 0x53380d13 | 0x650a7354 | 0x766a0abb | 0x81c2c92e | 0x92722c85 | |
0xa2bfe8a1 | 0xa81a664b | 0xc24b8b70 | 0xc76c51a3 | 0xd192e819 | 0xd6990624 | 0xf40e3585 | 0x106aa070 | |
0x19a4c116 | 0x1e376c08 | 0x2748774c | 0x34b0bcb5 | 0x391c0cb3 | 0x4ed8aa4a | 0x5b9cca4f | 0x682e6ff3 | |
0x748f82ee | 0x78a5636f | 0x84c87814 | 0x8cc70208 | 0x90befffa | 0xa4506ceb | 0xbef9a3f7 | 0xc67178f2 |
Prétraitement
[modifier | modifier le code]Cette opération se déroule en trois étapes : compléter le message M, découper le résultat en blocs, et initialiser les valeurs de hachage
Bourrage
[modifier | modifier le code]Il s'agit ici de compléter le message M pour qu'il soit d'une taille multiple de 512 bits. Le bourrage utilise la représentation binaire de l'entier l qui est la longueur en bits du message M (renforcement de Merkle-Damgård). Pour ce faire on ajoute successivement :
- un bit à 1 à la fin du message M,
- k bits à 0 de bourrage, où k est le plus petit entier naturel vérifiant l + 1 + k ≡ 448 mod 512
- un bloc de 64 bits qui donne la représentation binaire de l.
Exemples :
- Pour M = "abc", l = 3 × 8 = 24 bits, k ≡ 448 - (24 + 1) ≡ 423 mod 512, donc k= 423 ;
- on ajoute à M
- d'abord un bit à 1,
- puis 423 bits à 0 ,
- puis 64 bits représentant 24 en binaire, soit « 0000 ... 0000 0001 1000 »
- on obtient alors un message complété dont la longueur est le plus petit multiple de 512 bits supérieur à la longueur initiale de M.
- on ajoute à M
- Pour M de longueur bits, k ≡ 448 - (500 + 1) ≡ -53 mod 512 ; donc k= 512 - 53 = 459 ;
- on ajoute à M
- d'abord un bit à 1,
- puis 459 bits à 0,
- puis 64 bits représentant 500 en binaire, soit « 0000 ... 0000 0001 1111 0100 »
- on obtient alors un message complété dont la longueur est supérieure de 512 bits au plus petit multiple de 512 bits supérieur à la longueur initiale de M.
- on ajoute à M
Découpage en blocs
[modifier | modifier le code]Le message complété est découpé en N blocs de 512 bits, notés . Chaque bloc de 512 bits est ensuite découpé en 16 mots de 32 bits, notés .
Initialisations
[modifier | modifier le code]Les huit variables suivantes sont affectées de valeurs initiales comme suit :
Calcul du condensé (haché)
[modifier | modifier le code]Pour ce traitement on utilisera
- un tableau de 64 mots, notés
- huit variables notées
- huit variables contenant les valeurs de hachage, notées et initialisées précédemment en
- Ces variables contiendront itérativement de nouvelles valeurs de hachage, , pour finalement contenir le condensé de M, dans .
- deux variables, notées , mots de 32 bits.
On traite successivement les N blocs de M selon les étapes suivantes
Pour i = 1 à N
{
- 1. On remplit le tableau pour t de 0 à 63, selon
- 2. On initialise a,b, c, d, e, f, g et h avec les valeurs de hachage du tour précédent
- 3. Pour t de 0 à 63
- {
- }
- 4. Calcul des valeurs de hachage intermédiaires
}
Après répétition des quatre étapes ci-dessus pour les N blocs du message M, (i.e., après traitement de ), le condensé de 256 bits de M est obtenu par concaténation des valeurs
SHA-224
[modifier | modifier le code]La fonction SHA-224 est publiée pour la première fois en 2004. Le résultat produit (haché, « hash » ou condensat) est de 224 bits. Elle a été spécialement conçue pour fournir une empreinte dont la taille correspond à quatre clés DES de 56 bits chacune. L'algorithme est celui de SHA-256 avec pour seules différences
- des valeurs différentes pour l'initialisation (variables h0, … , h7) ;
- une sortie tronquée à 224 bits (concaténation des contenus des 7 premières variables h0, … , h6).
SHA-512
[modifier | modifier le code]La fonction SHA-512 est apparue en même temps que SHA-256 et devient comme celle-ci en 2002 un standard fédéral de traitement de l'information (FIPS du NIST). Elle produit un haché de 512 bits.
L'algorithme est très similaire à celui de SHA-256 mais avec une différence importante dans la taille des données traitées : la taille de bloc est de 1024 bits (et non 512 bits), et l'algorithme opère sur des mots de 64 bits (la taille de mot-mémoire de beaucoup de processeurs modernes). En particulier les opérations arithmétiques, particulièrement optimisées sur ces processeurs se font sur 64 bits.
La structure de l'algorithme est la même que celle de SHA-256 mais
- le message est découpé en blocs de 1024 bits ;
- les nombres qui apparaissent (variables h0, … , h7, constantes …) sont sur 64 bits et l'addition se fait modulo 264 ;
- les valeurs des initialisations et des constantes sont différentes (forcément puisque sur 64 et non 32 bits) ;
- la fonction de compression utilise 80 tours (au lieu de 64) ;
- la longueur du message (en binaire) ajoutée à celui-ci dans la phase de bourrage (renforcement de Merkle-Damgård) est un entier de 128 bits (big-endian) et non 64 bits, ce qui limite la taille théorique maximale du message à 2128 bits et non plus 264 bits ;
- les valeurs des décalages et décalages circulaires sont modifiées de façon à tenir compte de la nouvelle longueur des mots.
SHA-384
[modifier | modifier le code]La fonction SHA-384 est apparue en compagnie de SHA-256 et SHA-512. Elle produit un haché de 384 bits. L'algorithme est celui de SHA-512 avec pour seules différences
- des valeurs différentes pour l'initialisation (variables h0, … , h7) ;
- une sortie tronquée à 384 bits (concaténation des contenus des 6 premières variables h0, … , h5).
Cryptanalyse
[modifier | modifier le code]SHA-256 est devenu le nouveau standard recommandé en matière de hachage cryptographique après les attaques sur MD5 et SHA-1. Les autres membres de la famille SHA ont été relativement peu cryptanalysés par rapport à SHA-0 et SHA-1. En 2003, Helena Handschuh et Henri Gilbert ont publié une analyse de SHA-256, 384 et 512. Leur étude montre que les autres membres de SHA ne sont pas atteints par les attaques qui avaient fait leurs preuves sur les autres fonctions de hachage (MD4, MD5 et SHA-1 entre autres). La cryptanalyse linéaire et différentielle ne s’appliquent pas.
En revanche, les deux cryptologues ont mis en évidence des faiblesses significatives sur des versions modifiées. En changeant les constantes ou les paramètres d’initialisation de manière à les rendre symétriques tout en remplaçant l’addition modulaire par un XOR, on obtient un hachage qui produit une empreinte symétrique si le message en entrée l’est également.
Références
[modifier | modifier le code]- voir la page Secure Hashing du NIST
Voir aussi
[modifier | modifier le code]Bibliographie
[modifier | modifier le code]- (en) Henri Gilbert, Helena Handschuh : Security Analysis of SHA-256 and Sisters. Selected Areas in Cryptography 2003: 175-193
- Versions successives du Secure Hash Standard du NIST à partir de l'apparition de SHA-2 (voir aussi la page Secure Hashing)
- FIPS 180-2 version d'
- FIPS 180-3 version finale d'
- FIPS 180-4
Articles connexes
[modifier | modifier le code]Liens externes
[modifier | modifier le code]- Calculateur en ligne Encodage de chaînes de caractères par les fonctions de hachage les plus utilisées.
- (fr) Calculatrice qui génère SHA-256 en ligne
- (fr) Calculatrice qui génère SHA-512 en ligne
- (en) Une implémentation open source en C++ Comporte toutes les variantes de l'algorithme.