SHA-2

SHA-2 ( Secure Hash Algorithm 2 ) est un ensemble de fonctions de hachage cryptographique conçues par l' Agence de sécurité nationale des États-Unis (NSA) et publiées pour la première fois en 2001. Elles sont construites en utilisant la construction de Merkle–Damgård , à partir d'une fonction de compression unidirectionnelle elle-même construite en utilisant la structure Davies–Meyer à partir d'un chiffrement par blocs spécialisé.

SHA-2 inclut des changements significatifs par rapport à son prédécesseur, SHA-1 . La famille SHA-2 se compose de six fonctions de hachage avec des condensés (valeurs de hachage) de 224, 256, 384 ou 512 bits : SHA-224, SHA-256, SHA-384, SHA-512, SHA-512/224, SHA-512/256 . SHA-256 et SHA-512 sont des fonctions de hachage dont les condensés sont respectivement huit mots de 32 et 64 bits. Ils utilisent des quantités de décalage et des constantes additives différentes, mais leurs structures sont par ailleurs pratiquement identiques, ne différant que par le nombre de tours. SHA-224 et SHA-384 sont des versions tronquées de SHA-256 et SHA-512 respectivement, 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 dans les normes 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. La famille d'algorithmes SHA-2 est brevetée aux États-Unis Les États-Unis ont publié le brevet sous une licence libre de droits .

En 2011, les meilleures attaques publiques brisent la résistance à la préimage pour 52 des 64 rounds de SHA-256 ou 57 des 80 rounds de SHA-512, et la résistance aux collisions pour 46 des 64 rounds de SHA-256.

Avec la publication de la norme FIPS PUB 180-2, le NIST a ajouté trois fonctions de hachage supplémentaires à la famille SHA. Ces algorithmes sont connus sous le nom collectif de SHA-2, d'après leurs longueurs de condensé (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 et les commentaires du public ont été acceptés. En août 2002, FIPS PUB 180-2 est devenu la nouvelle norme de hachage sécurisé , remplaçant FIPS PUB 180-1, qui a été publiée 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.

En février 2004, un avis de modification a été publié pour la norme 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 . En octobre 2008, la norme a été mise à jour dans la norme FIPS PUB 180-3, incluant SHA-224 de l'avis de modification, mais sans apporter de modifications fondamentales à la norme. La principale motivation de la mise à jour de la norme était de déplacer les informations de sécurité sur les algorithmes de hachage et les recommandations pour leur utilisation vers les publications spéciales 800-107 et 800-57. 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.

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

En mars 2012, la norme a été mise à jour dans la norme FIPS PUB 180-4, ajoutant les fonctions de hachage SHA-512/224 et SHA-512/256, et décrivant une méthode de génération de valeurs initiales pour les versions tronquées de SHA-512. De plus, une restriction sur le remplissage des données d'entrée avant le calcul du hachage a été supprimée, ce qui permet de calculer les données de hachage 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.

En juillet 2012, le NIST a révisé la norme SP800-57, qui fournit des conseils pour la gestion des clés cryptographiques. La publication 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. En août 2012, le NIST a révisé la norme SP800-107 de la même manière.

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

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 . La demande de calcul inhérente aux algorithmes SHA-2 a conduit à la proposition de solutions plus efficaces, telles que celles basées sur des accélérateurs matériels à circuits intégrés spécifiques aux applications (ASIC).

SHA-256 est utilisé pour authentifier les paquets logiciels Debian et dans la norme de signature de messages DKIM ; SHA-512 fait partie d'un système d'authentification des vidéos d'archives du Tribunal pénal international du génocide rwandais . SHA-256 et SHA-512 sont proposés pour une utilisation dans DNSSEC . Les fournisseurs Unix et Linux s'orientent vers l'utilisation de SHA-2 256 et 512 bits pour le hachage sécurisé des mots de passe.

Plusieurs crypto-monnaies , dont Bitcoin , utilisent SHA-256 pour vérifier les transactions et calculer la preuve de travail ou la preuve d'enjeu . L'essor 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 l'utilisation dans d'autres algorithmes et protocoles cryptographiques, pour la protection des informations sensibles non classifiées. La norme FIPS PUB 180-1 a également encouragé l'adoption et l'utilisation de SHA-1 par les organisations privées et commerciales. SHA-1 est en cours de retrait pour la plupart des utilisations gouvernementales ; le National Institute of Standards and Technology 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). La directive du NIST selon laquelle les agences gouvernementales américaines devraient, sans y être explicitement obligées, cesser d'utiliser SHA-1 après 2010 avait pour objectif d'accélérer la migration vers l'abandon 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 et un manque d'urgence perçue puisque les collisions SHA-1 n'avaient pas encore été détectées. L' équipe de Google Chrome a annoncé un plan pour que son navigateur Web cesse progressivement de respecter les certificats TLS dépendants de SHA-1 sur une période allant de fin 2014 à début 2015. De même, Microsoft a annoncé qu'Internet Explorer et Edge cesseraient de respecter les certificats TLS publics signés SHA-1 à partir de février 2017. Mozilla a 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 d'appareils de sécurité .

Pour une fonction de hachage pour laquelle L est le nombre de bits dans le condensé de message , la recherche d'un message correspondant à un condensé de message donné peut toujours être effectuée à l'aide d'une recherche par force brute en 2 évaluations ^L. 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, à savoir la recherche de 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 évaluations ^{L /2 à l'aide d'une} attaque d'anniversaire .

Certaines applications qui utilisent des hachages cryptographiques, comme le stockage de mots de passe, ne sont que très peu affectées par une attaque par collision . La création d'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), ce qui peut être trivial ou non. L'inversion du chiffrement du mot de passe (par exemple, pour obtenir un mot de passe à essayer sur 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 falsifier une signature à partir d'un document existant : il lui faudrait produire une paire de documents, l'un inoffensif et l'autre nuisible, et faire signer le document inoffensif par le détenteur de la clé privée. Il existe des circonstances pratiques dans lesquelles cela est possible ; jusqu'à la fin de l'année 2008, il était possible de créer de faux certificats SSL en utilisant une collision MD5 qui était acceptée par les navigateurs Web les plus répandus.

L'intérêt croissant pour l'analyse du hachage cryptographique lors de la compétition SHA-3 a produit plusieurs nouvelles attaques sur 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 ronde complète.

Lors du 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 .

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

En décembre 2013, il existait plus de 1 300 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.

Hacher les valeurs 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("") 0x cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce 47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e SHA512/224("") 0x 6ed0dd02806fa89e25de060c19d3ac86cabb87d6a0ddd05c333b84f4 SHA512/256("") 0x c672b8d1ef56ed28ab87c3622c5114069bdd3ad7b8f9737498d0c01ecef0967a 

Même un petit changement dans le message entraînera (avec une probabilité écrasante) un hachage différent, en raison de l' effet d'avalanche . Par exemple, l'ajout d'un point à la fin de la phrase suivante modifie environ la moitié (111 sur 224) des bits du hachage, ce qui équivaut à choisir un nouveau hachage au hasard :

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 

Le pseudo-code de l'algorithme SHA-256 est le suivant. Notez la grande augmentation du mélange entre les bits des w[16..63]mots par rapport à SHA-1.

Remarque 1 : toutes les variables sont des entiers non signés de 32 bits et l'addition est calculée modulo 2 32.
 Remarque 2 : pour chaque tour, il existe une constante de tour k[i] et une entrée dans le tableau de planification des messages w[i], 0 ≤ i ≤ 63. Remarque 3 : la fonction de compression utilise 8 variables de travail, de a à h. Remarque 4 : la convention big-endian est utilisée lors de l'expression des constantes dans ce pseudo-code et lors de l'analyse des données du bloc de messages des octets aux mots. Par exemple, le premier mot du 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 (rembourrage) : commencer par le message original de longueur L bits ajouter un seul bit « 1 » ajouter K bits '0', où K est le nombre minimum >= 0 tel que (L + 1 + K + 64) soit un multiple de 512 ajouter L comme un entier big-endian de 64 bits, ce qui fait de la longueur totale post-traitée un multiple de 512 bits de telle sorte que les bits du message soient : <message d'origine de longueur L> 1 <K zéros> <L comme entier de 64 bits> , (le nombre de bits sera un multiple de 512) Traiter le message en blocs successifs de 512 bits : diviser le message en morceaux de 512 bits pour chaque morceau créer un tableau de planification 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, donc de nombreuses implémentations les mettent à zéro ici) copier le fragment dans les 16 premiers mots w[0..15] du tableau de planification des messages Étendez les 16 premiers mots aux 48 mots restants w[16..63] du tableau de planification des 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 à droite 3) s1 := (w[i-2] rotation à droite 17) xor (w[i-2] rotation à droite 19) xor (w[i-2] décalage à droite 10) w[i] := w[i-16] + s0 + w[i-7] + s1 Initialiser les variables de travail à la valeur de hachage actuelle : a := h0 b := h1 c := h2 d := h3 e := h4 f := h5 g := h6 h := h7 Fonction de compression boucle principale :
 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 d := c c := b b := un a := 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 append h1 append h2 append h3 append h4 append h5 append h6 append h7 

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

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 big endian) : 
(Les 32 secondes bits des parties fractionnaires des racines carrées des nombres premiers de 9 à 16, 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 arrondies sont étendues à 64 bits,
• il y a 80 tours au lieu de 64,
• le tableau de planification des messages w contient 80 mots de 64 bits au lieu de 64 mots de 32 bits,
• pour étendre le tableau de planification des messages w, la boucle va 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 big-endian 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 big-endian) : 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 SHA-512 Somme et Sigma : 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 à droite 7) s1 := (w[i-2] rotation à droite 19) xor (w[i-2] rotation à droite 61) xor (w[i-2] décalage à droite 6) 

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

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

Valeurs de hachage initiales SHA-384 (en big-endian) : 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 h0données h7par la fonction de génération SHA-512/t IV ,
• la sortie est construite en tronquant la concaténation de àh0 t h7bits ,
• 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 particulièrement mentionnées comme approuvées.

Valeurs de hachage initiales SHA-512/224 (en big-endian) : h[0..7] := 0x8c3d37c819544da2, 0x73e1996689dcd4d6, 0x1dfab7ae32ff9c82, 0x679dd514582f9fcf, 0x0f6d2b697bd44da8, 0x77e36f7304C48942, 0x3f9d85a86a1d36C8, 0x1112e6ad91d692a1 Valeurs de hachage initiales SHA-512/256 (en big-endian) : h[0..7] := 0x22312194fc2bf72c, 0x9f555fa3c84c64c2, 0x2393b86b6f53b151, 0x963877195940eabd, 0x96283ee2a88effe3, 0xbe5e1e2553863992, 0x2b0199fc2c85b8aa, 0x0eb72ddC81c52ca2 

La fonction de génération SHA-512/t IV évalue un SHA-512 modifié sur la chaîne ASCII « SHA-512/ t », substituée par la représentation décimale de t . Le SHA-512 modifié est identique au SHA-512, sauf que ses valeurs initiales h0à h7ont chacune été XORées avec la constante hexadécimale 0xa5a5a5a5a5a5a5a5.

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

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

Dans la colonne des opérations au niveau du bit, « Rot » signifie « rotate no carry » (rotation sans retenue ) et « Shr » signifie « right logical shift » (décalage logique à droite) . 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 processeurs modernes sont données dans le tableau ci-dessous.

Les chiffres de performance étiquetés « x86 » s'exécutaient en utilisant du code 32 bits sur des processeurs 64 bits, tandis que les chiffres « 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 manière similaire, 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 exécutent 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. 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. Les performances en Mio/s sont extrapolées à partir de la vitesse d'horloge du processeur sur un seul cœur ; les performances réelles varient en fonction de divers facteurs.

Vous trouverez ci-dessous une liste des bibliothèques de cryptographie qui prennent en charge SHA-2 :

• Botanique
• Château gonflable
• Cryptlib
• Crypto++
• Libgcrypt
• Mbed TLS
• libsodium
• Ortie
• LibreSSL
• OpenSSL
• GnuTLS
• loupSSL

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
• IBM z/Architecture : Disponible depuis 2005 dans le cadre des extensions Message-Security-Assist 1 (SHA-256) et 2 (SHA-512)
• IBM Power ISA depuis la version 2.07