Calculateur de hachage SHA-256

Calculateur de hachage SHA-256

Populaire AI Skill PRO

Entrez le calcul

Formule

Hachage=SHA-256(Texte à hacher)\text{Hachage} = \operatorname{SHA\text{-}256}\!\left(\text{Texte à hacher}\right)
Statistiques d'utilisation

Publicité

Résultats

Empreinte SHA-256 (hex)
ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad
256 bits (64 caractères hexadécimaux)
Algorithme SHA-256 (famille SHA-2)
Taille de l'entrée 3 octets (UTF-8)
Taille de la sortie 32 octets / 256 bits

Signaler une erreur sur cette page

Qu'est-ce que le SHA-256 ?

Le SHA-256 fait partie de la famille des fonctions de hachage cryptographiques SHA-2, normalisées par le NIST (l'agence américaine de normalisation). Il accepte un message d'entrée de longueur quelconque et produit une empreinte de taille fixe de 256 bits (32 octets), affichée ici sous la forme de 64 caractères hexadécimaux. Une même entrée donne toujours la même empreinte, tandis qu'un simple changement d'un caractère engendre un résultat totalement différent : c'est l'effet d'avalanche. Le SHA-256 est largement utilisé dans les certificats TLS, les signatures numériques, la blockchain (Bitcoin) et la vérification d'intégrité des fichiers.

Schéma plat montrant un texte d'entrée traversant un bloc de fonction SHA-256 et produisant une empreinte hexadécimale fixe de 64 caractères
SHA-256 transforme n'importe quelle entrée en une empreinte fixe de 256 bits (64 caractères hexadécimaux).

Comment utiliser ce calculateur

Saisissez ou collez n'importe quel texte dans le champ de saisie, puis validez. Le calculateur encode votre texte en UTF-8, exécute l'algorithme SHA-256 et renvoie l'empreinte hexadécimale accompagnée de la taille en octets de votre entrée. Une entrée vide est tout à fait valide : elle produit l'empreinte bien connue de la chaîne vide.

La formule expliquée

$$\text{Hash} = \operatorname{SHA\text{-}256}\!\left(\text{Input Text}\right)$$

Le SHA-256 complète d'abord le message (padding) pour que sa longueur soit un multiple de 512 bits, le découpe en blocs de 512 bits, puis traite chaque bloc à travers 64 tours d'opérations binaires (rotations, décalages, ET/OU exclusif, addition modulaire) qui mélangent huit variables de travail de 32 bits. Ces variables sont initialisées à partir des parties fractionnaires des racines carrées de nombres premiers. Après chaque bloc, les huit registres sont réintégrés à l'état courant du hachage ; leur concaténation forme l'empreinte finale de 256 bits.

Publicité
Schéma plat montrant l'étape de conversion en octets UTF-8, puis SHA-256 produisant une sortie de 256 bits découpée en huit mots de 32 bits
L'entrée est d'abord encodée en octets UTF-8, puis hachée en une empreinte de 256 bits composée de huit mots de 32 bits.

Exemple concret

L'entrée abc (3 octets) produit l'empreinte ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad. La chaîne vide produit quant à elle e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 — un vecteur de test standard.

Constantes SHA-256 et valeurs de hachage initiales

SHA-256 fait partie de la famille SHA-2 normalisée par le NIST dans la norme FIPS 180-4. Il travaille sur des mots de 32 bits, traite le message par blocs de 512 bits et ajoute la longueur du message sous la forme d'un entier de 64 bits en big-endian. Toutes les additions sont effectuées modulo \(2^{32}\).

Valeurs de hachage initiales H0–H7

Les huit valeurs de départ correspondent aux 32 premiers bits des parties fractionnaires des racines carrées des huit premiers nombres premiers (2, 3, 5, 7, 11, 13, 17, 19) :

Registre Nombre premier Valeur initiale (hexadécimal)
H0 2 6a09e667
H1 3 bb67ae85
H2 5 3c6ef372
H3 7 a54ff53a
H4 11 510e527f
H5 13 9b05688c
H6 17 1f83d9ab
H7 19 5be0cd19

Formellement, pour le nombre premier \(p_i\) : $$H_i = \left\lfloor \left(\sqrt{p_i} - \lfloor \sqrt{p_i} \rfloor\right) \cdot 2^{32} \right\rfloor$$ Par exemple, \(\sqrt{2} \approx 1.41421356\), et sa partie fractionnaire multipliée par \(2^{32}\) donne 0x6a09e667.

Constantes de tour K0–K63

Les 64 constantes de tour sont obtenues de la même manière, mais à partir des racines cubiques des 64 premiers nombres premiers (de 2 à 311) : $$K_t = \left\lfloor \left(\sqrt[3]{p_t} - \lfloor \sqrt[3]{p_t} \rfloor\right) \cdot 2^{32} \right\rfloor$$ Les premières sont 428a2f98, 71374491, b5c0fbcf et e9b5dba5. Comme elles proviennent d'une formule transparente plutôt que de choix arbitraires, ce sont des nombres dits « nothing-up-my-sleeve » (sans astuce cachée).

Paramètres de taille

  • Taille du mot : 32 bits
  • Taille du bloc : 512 bits (64 octets, 16 mots)
  • Champ de longueur : 64 bits, ajouté à la fin du message complété
  • Sortie : 256 bits, affichés sous forme de 64 caractères hexadécimaux

Calcul de SHA-256 étape par étape

  1. Encoder l'entrée en UTF-8. Le texte est converti en octets. Les caractères ASCII occupent chacun 1 octet, tandis que les autres caractères occupent de 2 à 4 octets. Le hachage est calculé sur ces octets, et non sur les caractères.
  2. Compléter le message. Ajouter un seul bit 1 (l'octet 0x80), puis ajouter des bits 0 jusqu'à ce que la longueur soit égale à 448 mod 512. Ajouter enfin la longueur du message original en bits, sous la forme d'un entier de 64 bits en big-endian.
  3. Découper en blocs de 512 bits. Chaque bloc est lu comme seize mots de 32 bits en big-endian \(W_0 \dots W_{15}\).
  4. Construire le calendrier des messages. Pour \(16 \le t < 64\) : $$W_t = \sigma_1(W_{t-2}) + W_{t-7} + \sigma_0(W_{t-15}) + W_{t-16}$$ où \(\sigma_0(x) = \text{ROTR}^7(x) \oplus \text{ROTR}^{18}(x) \oplus \text{SHR}^3(x)\) et \(\sigma_1(x) = \text{ROTR}^{17}(x) \oplus \text{ROTR}^{19}(x) \oplus \text{SHR}^{10}(x)\).
  5. Effectuer 64 tours de compression. Initialiser les variables de travail a–h avec l'état de hachage courant. À chaque tour, calculer $$T_1 = h + \Sigma_1(e) + \text{Ch}(e,f,g) + K_t + W_t,\quad T_2 = \Sigma_0(a) + \text{Maj}(a,b,c)$$ avec \(\text{Ch}(e,f,g) = (e \wedge f) \oplus (\lnot e \wedge g)\), \(\text{Maj}(a,b,c) = (a \wedge b) \oplus (a \wedge c) \oplus (b \wedge c)\), \(\Sigma_0(a) = \text{ROTR}^2 \oplus \text{ROTR}^{13} \oplus \text{ROTR}^{22}\) et \(\Sigma_1(e) = \text{ROTR}^6 \oplus \text{ROTR}^{11} \oplus \text{ROTR}^{25}\). Décaler ensuite les variables : h←g, g←f, f←e, e←d+T1, d←c, c←b, b←a, a←T1+T2.
  6. Mettre à jour l'état de hachage. Ajouter a–h à H0–H7 (mod \(2^{32}\)). Répéter les étapes 4 à 6 pour chaque bloc suivant.
  7. Produire le condensé. Concaténer H0 à H7, chacun sur 8 chiffres hexadécimaux, pour obtenir 64 caractères hexadécimaux.

Exemple de complétion : « abc »

L'entrée « abc » correspond aux 3 octets 0x61 0x62 0x63, soit 24 bits. Après complétion :

  • Octets du message : 61 62 63 (24 bits)
  • Ajouter 80 (le bit 1 suivi de sept bits 0) ; la longueur est maintenant de 32 bits
  • Ajouter 52 octets nuls pour que la longueur atteigne 448 bits (24 + 1 + 423 bits nuls)
  • Ajouter la longueur sur 64 bits : 00 00 00 00 00 00 00 18, car 24 = 0x18

Total : 3 + 1 + 52 + 8 = 64 octets = 512 bits, donc un seul bloc suffit.

Publicité

Comparaison des condensés SHA-256 selon les entrées

Quelle que soit la longueur de l'entrée, le condensé SHA-256 fait toujours 256 bits, soit 64 caractères hexadécimaux. Modifier ne serait-ce qu'un seul caractère produit un condensé totalement différent (l'effet avalanche). Seuls les condensés dont je suis certain sont indiqués ci-dessous ; pour les autres, saisissez le texte dans le calculateur pour obtenir le résultat.

Entrée Caractères Octets UTF-8 Condensé SHA-256
(chaîne vide) 0 0 e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855
abc 3 3 ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad
Abc 3 3 Condensé de 64 caractères sans rapport ; saisissez-le dans le calculateur pour le voir
é 1 2 (0xC3 0xA9) Condensé de 64 caractères des 2 octets UTF-8 ; saisissez-le dans le calculateur pour le voir

Ce que montre le tableau

  • Effet avalanche : « abc » et « Abc » ne diffèrent que d'un seul bit (0x61 contre 0x41 dans le premier octet), et pourtant leurs condensés n'ont aucune ressemblance notable. Environ la moitié des bits de sortie changent.
  • Caractères contre octets : « é » est un seul caractère mais deux octets en UTF-8, donc le hachage est calculé sur 2 octets. Un même caractère visible peut être encodé différemment (par exemple, un é précomposé contre « e » suivi d'un accent combinant), et ces encodages donnent des condensés différents.
  • Longueur fixe : la chaîne vide et un long document produisent tous deux 64 caractères hexadécimaux.

FAQ

Le SHA-256 est-il réversible ? Non. Il s'agit d'une fonction à sens unique : il est impossible de retrouver l'entrée à partir de l'empreinte.

Pourquoi le nombre d'octets est-il supérieur au nombre de caractères ? Les caractères non-ASCII (accents, émojis, idéogrammes CJC) occupent plusieurs octets en UTF-8 ; la taille en octets peut donc dépasser le nombre de caractères.

Le SHA-256 est-il toujours sûr ? Oui. À ce jour, aucune attaque pratique par collision ou par préimage ne menace le SHA-256 ; il reste une fonction de hachage recommandée pour un usage courant.

Dernière mise à jour:

Les plus populaires dans Vie numérique

Voir toutes les calculatrices de Vie numérique