SHA-2

SHA-2 ( Secure Hash Algorithm 2 ) est un ensemble de fonctions de hachage cryptographiques conçues par la National Security Agency (NSA) des États-Unis et publiées pour la première fois en 2001. ^{[3] [4]} Elles sont construites à l’aide de la construction Merkle–Damgård , à partir de une fonction de compression unidirectionnelle elle-même construite à l’aide de la structure Davies – Meyer à partir d’un chiffrement par blocs spécialisé.

SHA-2

Algorithmes de hachage sécurisés
Notions
fonctions de hachage · SHA · DSA
Principales normes
SHA-0 · SHA-1 · SHA-2 · SHA-3
v t e
Général
Créateurs	Agence de Sécurité Nationale
Première publication	2001 ; il y a 21 ans ( 2001 )
Séries	( SHA-0 ), SHA-1 , SHA-2, SHA-3
Certificat	FIPS PUB 180-4, CRYPTREC , NESSIE
Détail
Tailles de résumé	224, 256, 384 ou 512 bits
Structure	Construction Merkle – Damgård avec fonction de compression Davies – Meyer
Les manches	64 ou 80
Meilleure cryptanalyse publique
Une attaque de 2011 brise la Résistance à la préimage pour 57 des 80 rounds de SHA-512 et 52 des 64 rounds pour SHA-256. [1] Attaque de pseudo-collision contre jusqu’à 46 cartouches de SHA-256. [2] SHA-256 et SHA-512 sont sujets aux attaques d’extension de longueur . En devinant la partie cachée de l’état, les attaques d’extension de longueur sur SHA-224 et SHA-384 réussissent avec probabilité 2 −(256−224) = 2 −32 > 2 −224 et 2 −(512−384) = 2 −128 > 2 −384 respectivement.

SHA-2 inclut des modifications importantes par rapport à son prédécesseur, SHA-1 . La famille SHA-2 se compose de six fonctions de hachage avec des résumés (valeurs de hachage) de 224, 256, 384 ou 512 bits : ^[5] SHA-224, SHA-256, SHA-384, SHA-512, SHA-512/ 224, SHA-512/256 . SHA-256 et SHA-512 sont de nouvelles fonctions de hachage calculées avec huit mots de 32 bits et 64 bits, respectivement. Ils utilisent différentes quantités de décalage et constantes additives, mais leurs structures sont par ailleurs pratiquement identiques, ne différant que par le nombre de tours. SHA-224 et SHA-384 sont respectivement des versions tronquées de SHA-256 et SHA-512, calculées avec des valeurs initiales différentes. SHA-512/224 et SHA-512/256 sont également des versions tronquées de SHA-512, mais les valeurs initiales sont générées à l’aide de la méthode décrite dansNormes fédérales de traitement de l’information (FIPS) PUB 180-4.

SHA-2 a été publié pour la première fois par le National Institute of Standards and Technology (NIST) en tant que norme fédérale américaine (FIPS). La famille d’algorithmes SHA-2 est brevetée aux États-Unis. ^[6] Les États-Unis ont publié le brevet sous une licence libre de droits. ^[7]

En 2011, les meilleures attaques publiques brisent la Résistance à la préimage pour 52 des 64 tours de SHA-256 ou 57 des 80 tours de SHA-512, et la résistance aux collisions pour 46 des 64 tours de SHA-256. ^{[1] [2]}

Norme de hachage

Une itération dans une fonction de compression de la famille SHA-2. Les composants bleus effectuent les opérations suivantes :
Ch ⁡ ( E , F , g ) = ( E ∧ F ) ⊕ ( ¬ E ∧ g ) {displaystyle operatorname {Ch} (E,F,G)=(Eland F)oplus (neg Eland G)}
Maman ⁡ ( UN , B , C ) = ( UN ∧ B ) ⊕ ( UN ∧ C ) ⊕ ( B ∧ C ) {displaystyleoperatorname {Ma} (A,B,C)=(Aland B)oplus (Aland C)oplus (Bland C)}
Σ 0 ( UN ) = ( UN ⋙ 2 ) ⊕ ( A ⋙ 13 ) ⊕ ( A ⋙ 22 ) {displaystyle Sigma _{0}(A)=(A!ggg !2)oplus (A!ggg !13)oplus (A!ggg !22)}
Σ 1 ( E ) = ( E ⋙ 6 ) ⊕ ( E ⋙ 11 ) ⊕ ( E ⋙ 25 ) {displaystyle Sigma _{1}(E)=(E!ggg !6)oplus (E!ggg !11)oplus (E!ggg !25)}
La rotation au niveau du bit utilise différentes constantes pour SHA-512. Les nombres donnés sont pour SHA-256.
Le rouge ⊞ {displaystyle color {rouge}boxplus } est l’addition modulo 2 ³² pour SHA-256, ou 2 ⁶⁴ pour SHA-512.

Avec la publication de FIPS PUB 180-2, le NIST a ajouté trois fonctions de hachage supplémentaires dans la famille SHA. Les algorithmes sont collectivement connus sous le nom de SHA-2, nommés d’après leurs longueurs de résumé (en bits) : SHA-256, SHA-384 et SHA-512.

Les algorithmes ont été publiés pour la première fois en 2001 dans le projet FIPS PUB 180-2, date à laquelle l’examen public et les commentaires ont été acceptés. En août 2002, FIPS PUB 180-2 est devenu le nouveau Secure Hash Standard , remplaçant FIPS PUB 180-1, qui a été publié en avril 1995. La norme mise à jour comprenait l’algorithme SHA-1 d’origine, avec une notation technique mise à jour cohérente avec celle décrivant le fonctionnement interne de la famille SHA-2. ^[4]

En février 2004, un avis de modification a été publié pour FIPS PUB 180-2, spécifiant une variante supplémentaire, SHA-224, définie pour correspondre à la longueur de clé du Triple DES à deux clés . ^[8] En octobre 2008, la norme a été mise à jour dans FIPS PUB 180-3, y compris SHA-224 de l’avis de modification, mais n’apportant par ailleurs aucun changement fondamental à la norme. La principale motivation pour mettre à jour la norme était de déplacer les informations de sécurité sur les algorithmes de hachage et les recommandations pour leur utilisation dans les publications spéciales 800-107 et 800-57. ^{[9] [10] [11]} Des données de test détaillées et des exemples de résumés de messages ont également été supprimés de la norme et fournis sous forme de documents séparés. ^[12]

En janvier 2011, le NIST a publié le SP800-131A, qui spécifiait le passage du minimum actuel de sécurité de 80 bits (fourni par SHA-1) autorisé pour une utilisation par le gouvernement fédéral jusqu’à la fin de 2013, à la sécurité de 112 bits (à condition que par SHA-2) étant à la fois l’exigence minimale (à partir de 2014) et le niveau de sécurité recommandé (à partir de la date de publication en 2011). ^[13]

En mars 2012, la norme a été mise à jour dans FIPS PUB 180-4, ajoutant les fonctions de hachage SHA-512/224 et SHA-512/256, et décrivant une méthode pour générer des valeurs initiales pour les versions tronquées de SHA-512. De plus, une restriction sur le rembourrage des données d’entrée avant le calcul du hachage a été supprimée, permettant aux données de hachage d’être calculées simultanément avec la génération de contenu, comme un flux vidéo ou audio en temps réel. Le remplissage du bloc de données final doit toujours avoir lieu avant la sortie du hachage. ^[14]

En juillet 2012, le NIST a révisé le SP800-57, qui fournit des conseils pour la gestion des clés cryptographiques. La publication a interdit la création de signatures numériques avec une sécurité de hachage inférieure à 112 bits après 2013. La révision précédente de 2007 spécifiait que la date limite était fin 2010. ^[11] En août 2012, le NIST a révisé SP800-107 de la même manière. ^[dix]

Le concours de fonctions de hachage du NIST a sélectionné une nouvelle fonction de hachage, SHA-3 , en 2012. ^[15] L’algorithme SHA-3 n’est pas dérivé de SHA-2.

Applications

La fonction de hachage SHA-2 est implémentée dans certaines applications et protocoles de sécurité largement utilisés, notamment TLS et SSL , PGP , SSH , S/MIME et IPsec .

SHA-256 est utilisé pour authentifier les packages logiciels Debian ^[16] et dans la norme de signature de message DKIM ; SHA-512 fait partie d’un système d’authentification des archives vidéo du Tribunal pénal international pour le génocide rwandais . ^[17] SHA-256 et SHA-512 sont proposés pour une utilisation dans DNSSEC . ^[18] Les fournisseurs Unix et Linux se tournent vers l’utilisation de SHA-2 256 et 512 bits pour le hachage sécurisé des mots de passe. ^[19]

Plusieurs crypto -monnaies , dont Bitcoin , utilisent SHA-256 pour vérifier les transactions et calculer la preuve de travail ^[20] ou la preuve de participation . ^[21] La montée en puissance des puces accélératrices ASIC SHA-2 a conduit à l’utilisation de schémas de preuve de travail basés sur scrypt .

SHA-1 et SHA-2 sont les algorithmes de hachage sécurisés requis par la loi pour une utilisation dans certaines applications du gouvernement américain , y compris une utilisation dans d’autres algorithmes et protocoles cryptographiques, pour la protection des informations sensibles non classifiées. FIPS PUB 180-1 a également encouragé l’adoption et l’utilisation de SHA-1 par des organisations privées et commerciales. SHA-1 est retiré pour la plupart des utilisations gouvernementales ; l’Institut national des normes et de la technologie des États-Unis déclare: “Les agences fédérales devraient cesser d’utiliser SHA-1 pour … les applications qui nécessitent une résistance aux collisions dès que possible, et doivent utiliser la famille de fonctions de hachage SHA-2 pour ces applications après 2010″ (souligné dans l’original). ^[22]La directive du NIST selon laquelle les agences gouvernementales américaines doivent arrêter les utilisations de SHA-1 après 2010 ^[23] était censée accélérer la migration loin de SHA-1.

Les fonctions SHA-2 n’ont pas été rapidement adoptées au départ, malgré une meilleure sécurité que SHA-1. Les raisons peuvent inclure le manque de prise en charge de SHA-2 sur les systèmes exécutant Windows XP SP2 ou une version antérieure ^[24] et un manque d’urgence perçue puisque les collisions SHA-1 n’avaient pas encore été trouvées. L’ équipe Google Chrome a annoncé un plan pour que son navigateur Web cesse progressivement d’honorer les certificats TLS dépendants de SHA-1 sur une période allant de fin 2014 à début 2015. ^{[25] [26] [27]} De même, Microsoft a annoncé ^[28] qu’Internet Explorer et Edge cesseraient d’honorer les certificats TLS publics signés SHA-1 à partir de février 2017. Mozillaa désactivé SHA-1 début janvier 2016, mais a dû le réactiver temporairement via une mise à jour de Firefox , après des problèmes avec les interfaces utilisateur Web de certains modèles de routeurs et dispositifs de sécurité . ^[29]

Cryptanalyse et validation

Pour une fonction de hachage pour laquelle L est le nombre de bits dans le résumé de message , trouver un message qui correspond à un résumé de message donné peut toujours être fait en utilisant une recherche par force brute dans 2 ^L évaluations. C’est ce qu’on appelle une attaque de préimage et peut ou non être pratique en fonction de L et de l’environnement informatique particulier. Le deuxième critère, trouver deux messages différents qui produisent le même condensé de message, connu sous le nom de collision , ne nécessite en moyenne que 2 ^{L /2} évaluations en utilisant une attaque d’anniversaire .

Certaines des applications qui utilisent des hachages cryptographiques, telles que le stockage de mots de passe, ne sont que très peu affectées par une attaque par collision . Construire un mot de passe qui fonctionne pour un compte donné nécessite une attaque de préimage, ainsi que l’accès au hachage du mot de passe d’origine (généralement dans le shadowfichier) qui peut ou non être trivial. L’inversion du cryptage du mot de passe (par exemple, pour obtenir un mot de passe à essayer avec le compte d’un utilisateur ailleurs) n’est pas rendue possible par les attaques. (Cependant, même un hachage de mot de passe sécurisé ne peut pas empêcher les attaques par force brute sur les mots de passe faibles .)

Dans le cas de la signature de documents, un attaquant ne pourrait pas simplement simuler une signature à partir d’un document existant – l’attaquant devrait produire une paire de documents, l’un inoffensif et l’autre dommageable, et demander au détenteur de la clé privée de signer le document inoffensif. Il existe des circonstances pratiques dans lesquelles cela est possible; jusqu’à la fin de 2008, il était possible de créer de faux certificats SSL en utilisant une collision MD5 qui serait acceptée par les navigateurs Web largement utilisés. ^[30]

L’intérêt accru pour l’analyse de hachage cryptographique lors de la compétition SHA-3 a produit plusieurs nouvelles attaques contre la famille SHA-2, dont les meilleures sont présentées dans le tableau ci-dessous. Seules les attaques par collision sont d’une complexité pratique ; aucune des attaques ne s’étend à la fonction de hachage complète.

Au FSE 2012, des chercheurs de Sony ont fait une présentation suggérant que les attaques de pseudo-collision pourraient être étendues à 52 tours sur SHA-256 et 57 tours sur SHA-512 en s’appuyant sur l’ attaque de pseudo-préimage biclique . ^[31]

Publié dans	An	Méthode d’attaque	Attaque	Une variante	Les manches	Complexité
Nouvelles attaques par collision contre jusqu’à 24 étapes SHA-2 [32]	2008	Déterministe	Collision	SHA-256	24/64	2 28,5
SHA-512	24/80	2 32,5
Préimages pour SHA-2 réduit [33]	2009	Rencontrer dans le milieu	Préimage	SHA-256	42/64	2 251,7
43/64	2 254,9
SHA-512	42/80	2 502,3
46/80	2 511,5
Attaques avancées de préimage de rencontre au milieu [34]	2010	Rencontrer dans le milieu	Préimage	SHA-256	42/64	2 248,4
SHA-512	42/80	2 494,6
Attaque différentielle d’ordre supérieur sur SHA-256 réduit [2]	2011	Différentiel	Pseudo-collision	SHA-256	46/64	2 178
33/64	2 46
Bicliques for Preimages: Attacks on Skein-512 and the SHA-2 family [1]	2011	Biclique	Préimage	SHA-256	45/64	2 255,5
SHA-512	50/80	2 511,5
Pseudo-préimage	SHA-256	52/64	2 255
SHA-512	57/80	2 511
Amélioration des collisions locales : nouvelles attaques contre le SHA-256 réduit [35]	2013	Différentiel	Collision	SHA-256	31/64	2 65,5
Pseudo-collision	SHA-256	38/64	2 37
Heuristique de branchement dans la recherche de collision différentielle avec des applications à SHA-512 [36]	2014	Différentiel heuristique	Pseudo-collision	SHA-512	38/80	2 40,5
Analyse de SHA-512/224 et SHA-512/256 [37]	2016	Différentiel	Collision	SHA-256	28/64	pratique
SHA-512	27/80	pratique
Pseudo-collision	SHA-512	39/80	pratique

Validation officielle

Les implémentations de toutes les fonctions de sécurité approuvées par FIPS peuvent être officiellement validées via le programme CMVP , géré conjointement par le National Institute of Standards and Technology (NIST) et le Communications Security Establishment (CSE). Pour une vérification informelle, un package permettant de générer un nombre élevé de vecteurs de test est mis à disposition en téléchargement sur le site du NIST ; la vérification qui en résulte, cependant, ne remplace pas la validation formelle CMVP, qui est requise par la loi ^{[ citation nécessaire ]} pour certaines applications.

En décembre 2013 ^[update], il y avait plus de 1300 implémentations validées de SHA-256 et plus de 900 de SHA-512, dont seulement 5 étaient capables de gérer des messages d’une longueur en bits non multiple de huit tout en prenant en charge les deux variantes. ^[38]

Tester les vecteurs

Valeurs de hachage d’une chaîne vide (c’est-à-dire un texte d’entrée de longueur nulle).

SHA224(“”) 0x d14a028c2a3a2bc9476102bb288234c415a2b01f828ea62ac5b3e42f SHA256(“”) 0x e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 SHA384(“”) 0x 38b060a751ac96384cd9327eb1b1e36a21fdb71114be07434c0cc7bf63f6e1da274edebfe76f65fbd51ad2f14898b95b SHA512(“”) 1x SHA512/224(“”) 0x 6ed0dd02806fa89e25de060c19d3ac86cabb87d6a0ddd05c333b84f4 SHA512/256(“”) 0x c672b8d1ef56ed28ab87c3622c5114069bdd3ad7b8f9737498d0c01ecef0967a

Même un petit changement dans le message entraînera (avec une probabilité écrasante) un hachage essentiellement différent, en raison de l’ effet d’avalanche . Par exemple, ajouter un point à la fin de la phrase suivante modifie presque la moitié (111 sur 224) des bits du hachage :

SHA224(” Le renard brun rapide saute par-dessus le chien paresseux “) 0x 730e109bd7a8a32b1cb9d9a09aa2325d2430587ddbc0c38bad911525 SHA224(” Le renard brun rapide saute par-dessus le chien paresseux . “) 0x 619cba8e8e05826e9b8c519c0a5c68f4fb653e8a3d8aa04bb2c8cd4c

Pseudocode

Le pseudocode de l’algorithme SHA-256 suit. Notez la forte augmentation du mélange entre les bits des w[16..63]mots par rapport à SHA-1.

Note 1 : Toutes les variables sont des entiers non signés de 32 bits et l’addition est calculée modulo 2 ³² 63 Remarque 3 : La fonction de compression utilise 8 variables de travail, a à h Remarque 4 : La convention big-endian est utilisée lors de l’expression des constantes dans ce pseudocode, et lors de l’analyse des données de bloc de message d’octets en mots, par exemple, le premier mot de le message d’entrée “abc” après le remplissage est 0x61626380 Initialiser les valeurs de hachage : (32 premiers bits des parties fractionnaires des racines carrées des 8 premiers nombres premiers 2..19) : h0 := 0x6a09e667 h1 := 0xbb67ae85 h2 := 0x3c6ef372 h3 := 0xa54ff53a h4 := 0x510e527f h5 := 0x9b05688c h6 := 0x1f83d9ab h7 := 0x5be0cd19 Initialiser le tableau de constantes rondes : (32 premiers bits des parties fractionnaires des racines cubiques des 64 premiers nombres premiers 2..311) : k[0..63] := 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 (Remplissage): commencer par le message d’origine de longueur L bits ajouter un seul bit ‘1’ ajouter K ‘0’ bits, où K est le nombre minimum >= 0 tel que (L + 1 + K + 64) est un multiple de 512 ajouter L comme un entier gros boutien de 64 bits, faisant de la longueur totale post-traitée un multiple de 512 bits tel que les bits dans le message sont : <message original de longueur L> 1 <K zéros> <L comme entier de 64 bits> , (le nombre de bits sera un multiple de 512) Traitez le message par tranches successives de 512 bits : diviser le message en morceaux de 512 bits pour chaque morceau créer un tableau de programme de messages à 64 entrées w[0..63] de mots de 32 bits (Les valeurs initiales dans w[0..63] n’ont pas d’importance, tant d’implémentations les mettent à zéro ici) copier le bloc dans les 16 premiers mots w[0..15] du tableau de programme de messages Étendre les 16 premiers mots dans les 48 mots restants w[16..63] du tableau de programme de messages : pour i de 16 à 63 s0 := (w[i-15] rotation droite 7) xor (w[i-15] rotation droite 18) xor (w[i-15] décalage vers la droite 3) s1 := (w[i-2] rotation droite 17) xor (w[i-2] rotation droite 19) xor (w[i-2] décalage vers la droite 10) w[i] := w[i-16] + s0 + w[i-7] + s1 Initialisez les variables de travail à la valeur de hachage actuelle : un := h0 b := h1 c := h2 d := h3 e := h4 f := h5 g := h6 h := h7 Boucle principale de la fonction de compression : pour i de 0 à 63 S1 := (e rotation droite 6) xor (e rotation droite 11) xor (e rotation droite 25) ch := (e et f) xor (( pas e) et g) temp1 := h + S1 + ch + k[i] + w[i] S0 := (une rotation droite 2) xor (une rotation droite 13) xor (une rotation droite 22) maj := (a et b) xor (a et c) xor (b et c) temp2 := S0 + maj h := g g := f f := e e := d + temp1 ré := c c := b b := un un := temp1 + temp2 Ajoutez le bloc compressé à la valeur de hachage actuelle : h0 := h0 + a h1 := h1 + b h2 := h2 + c h3 := h3 + d h4 := h4 + e h5 := h5 + f h6 := h6 + g h7 := h7 + h Produire la valeur de hachage finale (big-endian) : digest := hash := h0 ajouter h1 ajouter h2 ajouter h3 ajouter h4 ajouter h5 ajouter h6 ajouter h7

Le calcul des valeurs chet peut être optimisé de la même manière que celle décrite pour SHA-1 .maj

SHA-224 est identique à SHA-256, sauf que :

• les valeurs de hachage initiales h0sont h7différentes, et
• la sortie est construite en omettant h7.

Valeurs de hachage initiales SHA-224 (en gros boutien) : (Les 32 secondes bits des parties fractionnaires des racines carrées des 9e à 16e nombres premiers 23..53) h[0..7] := 0xc1059ed8, 0x367cd507, 0x3070dd17, 0xf70e5939, 0xffc00b31, 0x68581511, 0x64f98fa7, 0xbefa4fa4

SHA-512 a une structure identique à SHA-256, mais :

• le message est divisé en morceaux de 1024 bits,
• les valeurs de hachage initiales et les constantes rondes sont étendues à 64 bits,
• il y a 80 tours au lieu de 64,
• le tableau de programme de messages w comporte 80 mots de 64 bits au lieu de 64 mots de 32 bits,
• pour étendre le tableau de programme de messages w, la boucle est de 16 à 79 au lieu de 16 à 63,
• les constantes rondes sont basées sur les 80 premiers nombres premiers 2..409,
• la taille du mot utilisé pour les calculs est de 64 bits,
• la longueur ajoutée du message (avant le prétraitement), en bits , est un entier gros boutien de 128 bits, et
• les quantités de décalage et de rotation utilisées sont différentes.

Valeurs de hachage initiales SHA-512 (en gros boutien) : h[0..7] := 0x6a09e667f3bcc908, 0xbb67ae8584caa73b, 0x3c6ef372fe94f82b, 0xa54ff53a5f1d36f1, 0x510e527fade682d1, 0x9b05688c2b3e6c1f, ​​0x1f83d9abfb41bd6b, 0x5be0cd19137e2179 Constantes rondes SHA-512 : k[0..79] := 0x428a2f98d728ae22, 0x7137449123ef65cd, 0xb5c0fbcfec4d3b2f, 0xe9b5dba58189dbbc, 0x3956c25bf348b538, 0x59f111f1b605d019, 0x923f82a4af194f9b, 0xab1c5ed5da6d8118, 0xd807aa98a3030242, 0x12835b0145706fbe, 0x243185be4ee4b28c, 0x550c7dc3d5ffb4e2, 0x72be5d74f27b896f, 0x80deb1fe3b1696b1, 0x9bdc06a725c71235, 0xc19bf174cf692694, 0xe49b69c19ef14ad2, 0xefbe4786384f25e3, 0x0fc19dc68b8cd5b5, 0x240ca1cc77ac9c65, 0x2de92c6f592b0275, 0x4a7484aa6ea6e483, 0x5cb0a9dcbd41fbd4, 0x76f988da831153b5, 0x983e5152ee66dfab, 0xa831c66d2db43210, 0xb00327c898fb213f, 0xbf597fc7beef0ee4, 0xc6e00bf33da88fc2, 0xd5a79147930aa725, 0x06ca6351e003826f, 0x142929670a0e6e70, 0x27b70a8546d22ffc, 0x2e1b21385c26c926, 0x4d2c6dfc5ac42aed, 0x53380d139d95b3df, 0x650a73548baf63de, 0x766a0abb3c77b2a8, 0x81c2c92e47edaee6, 0x92722c851482353b, 0xa2bfe8a14cf10364, 0xa81a664bbc423001, 0xc24b8b70d0f89791, 0xc76c51a30654be30, 0xd192e819d6ef5218, 0xd69906245565a910, 0xf40e35855771202a, 0x106aa07032bbd1b8, 0x19a4c116b8d2d0c8, 0x1e376c085141ab53, 0x2748774cdf8eeb99, 0x34b0bcb5e19b48a8, 0x391c0cb3c5c95a63, 0x4ed8aa4ae3418acb, 0x5b9cca4f7763e373, 0x682e6ff3d6b2b8a3, 0x748f82ee5defb2fc, 0x78a5636f43172f60, 0x84c87814a1f0ab72, 0x8cc702081a6439ec, 0x90befffa23631e28, 0xa4506cebde82bde9, 0xbef9a3f7b2c67915, 0xc67178f2e372532b, 0xca273eceea26619c, 0xd186b8c721c0c207, 0xeada7dd6cde0eb1e, 0xf57d4f7fee6ed178, 0x06f067aa72176fba, 0x0a637dc5a2c898a6, 0x113f9804bef90dae, 0x1b710b35131c471b, 0x28db77f523047d84, 0x32caab7b40c72493, 0x3c9ebe0a15c9bebc, 0x431d67c49c100d4c, 0x4cc5d4becb3e42b6, 0x597f299cfc657e2a, 0x5fcb6fab3ad6faec, 0x6c44198c4a475817 Somme et sigma SHA-512 : S0 := (une rotation droite 28) xor (une rotation droite 34) xor (une rotation droite 39) S1 := (e rotation droite 14) xor (e rotation droite 18) xor (e rotation droite 41) s0 := (w[i-15] rotation droite 1) xor (w[i-15] rotation droite 8) xor (w[i-15] décalage vers la droite 7) s1 := (w[i-2] rotation droite 19) xor (w[i-2] rotation droite 61) xor (w[i-2] décalage vers la droite 6)

SHA-384 est identique à SHA-512, sauf que :

• les valeurs de hachage initiales h0sont h7différentes (prises du 9e au 16e nombre premier), et
• la sortie est construite en omettant h6et h7.

Valeurs de hachage initiales SHA-384 (en gros boutien) : h[0..7] := 0xcbbb9d5dc1059ed8, 0x629a292a367cd507, 0x9159015a3070dd17, 0x152fecd8f70e5939, 0x67332667ffc00b31, 0x8eb44a8768581511, 0xdb0c2e0d64f98fa7, 0x47b5481dbefa4fa4

SHA-512/t est identique à SHA-512 sauf que :

• les valeurs de hachage initiales sont données par la h0fonction de génération SHA-512/t IV ,h7
• la sortie est construite en tronquant la concaténation de h0through h7à t bits,
• t égal à 384 n’est pas autorisé, à la place SHA-384 doit être utilisé comme spécifié, et
• Les valeurs t 224 et 256 sont spécialement mentionnées comme approuvées.

La fonction de génération SHA-512/t IV évalue un SHA-512 modifié sur la chaîne ASCII “SHA-512/ t “, remplacée par la représentation décimale de t . Le SHA-512 modifié est le même que le SHA-512, sauf que ses valeurs initiales ont chacune été h0XORed avec la constante hexadécimale .h70xa5a5a5a5a5a5a5a5

Un exemple d’implémentation C pour la famille SHA-2 de fonctions de hachage peut être trouvé dans RFC 6234.

Comparaison des fonctions SHA

Dans le tableau ci-dessous, l’état interne signifie la “somme de hachage interne” après chaque compression d’un bloc de données.

Comparaison des fonctions SHA

• voir
• parler
• Éditer

Algorithme et variante	Taille de sortie (bits)	Taille de l’état interne (bits)	Taille de bloc (bits)	Les manches	Opérations	Sécurité contre les attaques par collision (bits)	Sécurité contre les attaques par extension de longueur (bits)	Performance sur Skylake ( cpb médian ) [39]	Première publication
Messages longs	8 octets
MD5 (comme référence)	128	128 (4 × 32)	512	64	Et, Xor, Rot, Add (mod 2 32 ), Ou	≤ 18 (collisions trouvées) [40]	0	4,99	55,00	1992
SHA-0	160	160 (5 × 32)	512	80	Et, Xor, Rot, Add (mod 2 32 ), Ou	< 34 (collisions trouvées)	0	≈ SHA-1	≈ SHA-1	1993
SHA-1	< 63 (collisions trouvées) [41]	3.47	52,00	1995
SHA-2	SHA-224 SHA-256	224 256	256 (8 × 32)	512	64	Et, Xor, Rot, Ajouter (mod 2 32 ), Ou, Shr	112 128	32 0	7,62 7,63	84,50 85,25	2004 2001
SHA-384	384	512 (8 × 64)	1024	80	Et, Xor, Rot, Ajouter (mod 2 64 ), Ou, Shr	192	128 (≤ 384)	5.12	135,75	2001
SHA-512	512	512 (8 × 64)	1024	80	Et, Xor, Rot, Ajouter (mod 2 64 ), Ou, Shr	256	0 [42]	5.06	135,50	2001
SHA-512/224 SHA-512/256	224 256	512 (8 × 64)	1024	80	Et, Xor, Rot, Ajouter (mod 2 64 ), Ou, Shr	112 128	288 256	≈ SHA-384	≈ SHA-384	2012
SHA-3	SHA3-224 SHA3-256 SHA3-384 SHA3-512	224 256 384 512	1600 (5 × 5 × 64)	1152 1088 832 576	24 [43]	Et, Xor, Rot, Not	112 128 192 256	448 512 768 1024	8,12 8,59 11,06 15,88	154,25 155,50 164,00 164,00	2015
SHAKE128 SHAKE256	d (arbitraire) d (arbitraire)	1344 1088	min( j /2, 128) min( j /2, 256)	256 512	7.08 8.59	155,25 155,50

Dans la colonne des opérations au niveau du bit, “Rot” signifie rotate no carry et “Shr” signifie right logical shift . Tous ces algorithmes utilisent l’addition modulaire d’une manière ou d’une autre, à l’exception de SHA-3.

Des mesures de performances plus détaillées sur les architectures de processeur modernes sont données dans le tableau ci-dessous.

Architecture du processeur	La fréquence	Algorithme	Taille du mot (bits)	Cycles/octet x86	Mio/s x86	Cycles/octet x86-64	Mio/s x86-64
Pont Intel Ivy	3,5 GHz	SHA-256	32	16.80	199	13.05	256
SHA-512	64	43,66	76	8.48	394
APU AMD Piledriver	3,8 GHz	SHA-256	32	22,87	158	18h47	196
SHA-512	64	88,36	41	12h43	292

Les numéros de performance étiquetés «x86» utilisaient du code 32 bits sur des processeurs 64 bits, tandis que les numéros «x86-64» sont du code 64 bits natif. Bien que SHA-256 soit conçu pour les calculs 32 bits, il bénéficie d’un code optimisé pour les processeurs 64 bits sur l’architecture x86. Les implémentations 32 bits de SHA-512 sont nettement plus lentes que leurs homologues 64 bits. Les variantes des deux algorithmes avec des tailles de sortie différentes fonctionneront de la même manière, car les fonctions d’expansion et de compression des messages sont identiques, et seules les valeurs de hachage initiales et les tailles de sortie sont différentes. Les meilleures implémentations de MD5 et SHA-1 effectuent entre 4,5 et 6 Cycles par octet sur les processeurs modernes.

Les tests ont été effectués par l’ Université de l’Illinois à Chicago sur leur système hydra8 exécutant un Intel Xeon E3-1275 V2 à une vitesse d’horloge de 3,5 GHz, et sur leur système hydra9 exécutant un APU AMD A10-5800K à une vitesse d’horloge de 3,8 GHz. ^[44] Les vitesses de Cycles par octet référencées ci-dessus sont les performances médianes d’un algorithme digérant un message de 4 096 octets à l’aide du logiciel d’analyse comparative cryptographique SUPERCOP. ^[45] Les performances en MiB/s sont extrapolées à partir de la vitesse d’horloge du processeur sur un seul cœur ; les performances réelles varient en raison de divers facteurs.

Implémentations

Vous trouverez ci-dessous une liste des bibliothèques de chiffrement prenant en charge SHA-2 :

• botanique
• Château gonflable
• Cryplib
• Crypto++
• Libgcrypt
• Mbed TLS ^{[46] [47]}
• libsodium
• Ortie
• LibreSSL
• OpenSSL
• GnuTLSGenericName
• wolfSSL

L’accélération matérielle est fournie par les extensions de processeur suivantes :

• Extensions Intel SHA : Disponibles sur certains processeurs Intel et AMD x86.
• Cadenas VIA
• Extensions de cryptographie ARMv8 ^[48]

Voir également

• Comparaison des fonctions de hachage cryptographique
• Comparaison des bibliothèques de cryptographie
• Résumé de la sécurité de la fonction de hachage
• Haschcash
• HMAC
• Association internationale pour la recherche cryptologique (IACR)
• sha1sum( sha224sum, sha256sum, sha384sumet sha512sum) commandes
• Horodatage de confiance

Références

1. ^ ^{un bc Dmitry Khovratovich} , Christian Rechberger et Alexandra Savelieva (2011). “Bicliques for Preimages: Attacks on Skein-512 and the SHA-2 family” (PDF) . Archive ePrint de cryptologie IACR . 2011 :286.
2. ^ ^{un bc Mario Lambberger} & Florian Mendel (2011). “Attaque différentielle d’ordre supérieur sur SHA-256 réduit” (PDF) . Archive ePrint de cryptologie IACR . 2011:37.
3. ^ “Sur la famille Secure Hash Algorithm” (PDF) . Archivé de l’original (PDF) le 2016-03-30.
4. ^ ^{un b} Avis de registre fédéral 02-21599, annonçant l’approbation de la publication FIPS 180-2
5. ^ “Détails IPR: Les États-Unis d’Amérique représentés par la déclaration de licence générale de la National Security Agency” . Traqueur de données IETF . 858 . Récupéré le 17/02/2008 .
6. ^ US 6829355 , Lilly, Glenn M., “Dispositif et méthode de hachage cryptographique unidirectionnel”, publié le 07/12/2004, attribué à la National Security Agency
7. ^ “Détails IPR: Les États-Unis d’Amérique représentés par la déclaration de licence générale de la National Security Agency” . Traqueur de données IETF . 858 . Récupéré le 17/02/2008 .
8. ^ “FIPS 180-2 avec avis de modification 1” (PDF) . csrc.NIST.gov .
9. ^ Avis de registre fédéral E8-24743, annonçant l’approbation de la publication FIPS 180-3
10. ^ ^{a b} Recommandation FIPS SP 800-107 pour les applications utilisant des algorithmes de hachage approuvés
11. ^ ^{a b} Recommandation FIPS SP 800-57 pour la gestion des clés: Partie 1: Général
12. ^ “NIST.gov – Division de la sécurité informatique – Centre de ressources sur la sécurité informatique” . 29 décembre 2016.
13. ^ Recommandation FIPS SP 800-131A pour la transition de l’utilisation des algorithmes cryptographiques et des longueurs de clé
14. ^ Avis de registre fédéral 2012-5400, annonçant l’approbation de la publication FIPS 180-4
15. ^ “Le NIST sélectionne le gagnant du concours Secure Hash Algorithm (SHA-3)” . 2 octobre 2012 . Récupéré le 24 février 2015 .
16. ^ “La base de code Debian dans Google Code” . Archivé de l’original le 7 novembre 2011 . Récupéré le 08/11/2011 .
17. ^ John Markoff, Un outil pour vérifier les enregistrements numériques, même lorsque la technologie évolue , New York Times , 26 janvier 2009
18. ^ RFC 5702, RFC-Editor.org
19. ^ Ulrich Drepper, crypte Unix avec SHA-256/512
20. ^ Bitcoin, Excédent. “Bitcoin ne gaspille pas d’énergie” . Bitcoin excédentaire . Récupéré le 20/04/2020 .
21. ^ “Qu’est-ce que SHA-256 et comment est-il lié au Bitcoin? – Mycryptopedia” . Mycryptopédie . 2017-09-21 . Récupéré le 17/09/2018 .
22. ^ National Institute on Standards and Technology Computer Security Resource Center, NIST‘s Policy on Hash Functions Archivé le 09/06/2011 à la Wayback Machine , consulté le 29 mars 2009.
23. ^ “Hachage sécurisé” . NIST . Archivé de l’original le 2011-06-25 . Récupéré le 25/11/2010 .
24. ^ “Aperçu de Windows XP Service Pack 3” (PDF) . Microsoft Corporation. Archivé de l’original (PDF) le 30 mai 2008.
25. ^ Chromium Blog, 5 septembre 2014, Suppression progressive de SHA-1
26. ^ Éric Moulin. « SHAAAAAAAAAAAAAA » . SHAAAAAAAAAAAAA.com .
27. ^ Filippo Valsorda, La FAQ non officielle sur la dépréciation de Chrome SHA1
28. ^ “Une mise à jour de notre feuille de route d’obsolescence SHA-1 – Microsoft Edge Dev BlogMicrosoft Edge Dev Blog” . blogs.windows.com . 29 avril 2016 . Récupéré le 28/11/2016 .
29. ^ Fabian A. Scherschel, HeiseSecurity: Firefox: Mozilla schaltet SHA-1 ab … und direkt wieder an (allemand)
30. ^ Alexander Sotirov, Marc Stevens, Jacob Appelbaum, Arjen Lenstra, David Molnar, Dag Arne Osvik, Benne de Weger, MD5 considéré comme nuisible aujourd’hui : Création d’un certificat CA voyou , consulté le 29 mars 2009.
31. ^ Ji Li, Takanori Isobe et Kyoji Shibutani, Sony China Research Laboratory et Sony Corporation, Converting Meet-in-the-Middle Preimage Attack into Pseudo Collision Attack: Application to SHA-2
32. ^ Somitra Kumar Sanadhya & Palash Sarkar (2008). “Nouvelles attaques de collision contre jusqu’à 24 étapes SHA-2” (PDF) . Archive ePrint de cryptologie IACR . 2008 :270.
33. ^ Kazumaro Aoki; Jian Guo; Krystian Matusiewicz ; Yu Sasaki et Lei Wang (2009). Préimages pour SHA-2 réduit par étapes . Avancées en cryptologie – ASIACRYPT 2009 . Notes de cours en informatique. Vol. 5912. Springer Berlin Heidelberg. pages 578–597. doi : 10.1007/978-3-642-10366-7_34 . ISBN 978-3-642-10366-7. ISSN 0302-9743 .
34. ^ Jian Guo; San Ling; Christian Rechberger et Huaxiong Wang (2010). Attaques avancées de préimage par rencontre du milieu : premiers résultats sur Tiger complet et résultats améliorés sur MD4 et SHA-2 (PDF) . Avancées en cryptologie – ASIACRYPT 2010 . Notes de cours en informatique. Vol. 6477. Springer Berlin Heidelberg. p. 56–75. doi : 10.1007/978-3-642-17373-8_4 . ISBN 978-3-642-17373-8. ISSN 0302-9743 .
35. ^ Florian Mendel; Tomislav Nad; Martin Schläffer (2013). Amélioration des collisions locales : nouvelles attaques sur le SHA-256 réduit . Avancées en Cryptologie – EUROCRYPT 2013 . Notes de cours en informatique. Vol. 7881. Springer Berlin Heidelberg. p. 262–278. doi : 10.1007/978-3-642-38348-9_16 . ISBN 978-3-642-38348-9. ISSN 0302-9743 .
36. ^ Maria Eichlseder et Florian Mendel et Martin Schläffer (2014). “Heuristique de branchement dans la recherche de collision différentielle avec des applications à SHA-512” (PDF) . Archive ePrint de cryptologie IACR . 2014 :302.
37. ^ Christoph Dobraunig; Maria Eichlseder & Florian Mendel (2016). “Analyse de SHA-512/224 et SHA-512/256” (PDF) . Association internationale pour la recherche cryptologique .
38. ^ “Liste de validation SHS” . NIST . 2017-06-16. Archivé de l’original le 17/06/2017.
39. ^ “Tableau des mesures” . banc.cr.yp.to .
40. ^ Tao, Xie; Liu, Fanbao ; Feng, Dengguo (2013). Attaque par collision rapide sur MD5 (PDF) . Cryptology ePrint Archive (Rapport technique). AICR .
41. ^ Stevens, Marc ; Bursztein, Elie ; Karpman, Pierre; Albertini, Ange; Markov, Yarik. La première collision pour le SHA-1 complet (PDF) (Rapport technique). Recherche Google .
    • Marc Stevens; Elie Bursztein; Pierre Karpman; Ange Albertini; Yarik Markov; Alex Petit Bianco; Clément Baisse (23 février 2017). “Annonce de la première collision SHA1” . Blog de sécurité Google .
42. ^ Sans troncature, l’état interne complet de la fonction de hachage est connu, quelle que soit la résistance aux collisions. Si la sortie est tronquée, la partie supprimée de l’état doit être recherchée et trouvée avant que la fonction de hachage puisse être reprise, permettant à l’attaque de se poursuivre.
43. ^ “La famille de fonctions d’éponge Keccak” . Récupéré le 27/01/2016 .
44. ^ SUPERCOP Benchmarks Mesures des fonctions de hachage, indexées par machine
45. ^ “SUPERCOP” . Récupéré le 24 février 2015 .
46. ^ Suites de chiffrement SSL / TLS prises en charge
47. ^ Journal des modifications Mbed TLS , 7 juillet 2007
48. ^ “Extension de cryptographie du manuel de référence technique du processeur MPCore ARM Cortex-A53” .

Lectures complémentaires

• Henri Gilbert, Helena Handschuh : analyse de la sécurité de SHA-256 et des sœurs. Domaines sélectionnés en cryptographie 2003 : pp175–193
• “Proposition de révision de la Norme fédérale de traitement de l’information (FIPS) 180, norme de hachage sécurisée” . Registre fédéral . 59 (131): 35317–35318. 1994-07-11 . Récupéré le 26/04/2007 .^{[ lien mort permanent ]}

Liens externes

• Descriptions de SHA-256, SHA-384 et SHA-512 du NIST
• SHA-2 Checker – SHAChecker pour vérifier sa compatibilité SSL pour SHA-2
• Spécifications pour une norme de hachage sécurisée (SHS) – Ébauche de SHS proposé (SHA-0)
• Norme de hachage sécurisé (SHS) – SHS proposé (SHA-0)
• CSRC Cryptographic Toolkit – Site officiel du NIST pour la Norme de hachage sécurisé
• FIPS PUB 180-4 : Secure Hash Standard (SHS) ( PDF , 834 Ko) – Version actuelle de Secure Hash Standard (SHA-1, SHA-224, SHA-256, SHA-384 et SHA-512), août 2015
• Vecteurs de test pour SHA-256/384/512 du projet NESSIE
• Tester les vecteurs pour SHA-1, SHA-2 du site NIST
• NIST Cryptographic Hash Project – Concours SHA-3
• RFC 3874 : “Une fonction de hachage unidirectionnelle 224 bits : SHA-224”
• RFC 6234 : “Algorithmes de hachage sécurisés américains (SHA et HMAC et HKDF basés sur SHA)” ; contient un exemple d’implémentation C
• Démonstration de l’algorithme SHA-256