Générateur SHA-3 (Keccak SHA3-256 NIST)

Qu'est-ce que SHA-3 ?

// SHA-3 (NIST FIPS 202 SHA3-256) using js-sha3 library
import { sha3_256 } from 'js-sha3';

const hash = sha3_256('Hello, World!');
// → '882f4b6991a775295186a4e3cc5ece9fc0b618c8c3e7a7beafdd0f56f13ae43b'

// Note: this differs from Ethereum's keccak256 for the same input:
// keccak256('Hello, World!') = 'acaf3289d7b601cbd114fb36c4d29c85bbfd5e133f14cb355c3fd8d99367964f'
// The difference is the padding byte: 0x06 (SHA-3) vs 0x01 (original Keccak)

Exemples SHA-3

abc

3a985da74fe225b2045c172d6bd390bd855f086e3e9d525b46bfe24511431532

Hello

NIST SP 800-57 Part 1 Rev 5 — Recommendation for Key Management

POST /api/ledger
{"amount":250000,"from":"acct-A","to":"acct-B"}

Comment générer des hashes SHA-3

1. 1

   Collez du texte dans le champ de saisie

   Sélectionnez l'onglet Texte et saisissez ou collez n'importe quelle chaîne. Le hash SHA3-256 se met à jour en direct au fil de la frappe. Lors de la première utilisation, la bibliothèque js-sha3 (~10 Ko) est récupérée et mise en cache — vous pouvez remarquer un bref délai lors du tout premier hash ; tous les hashes suivants sont instantanés. L'algorithme est déjà réglé sur SHA-3 (NIST FIPS 202 SHA3-256).

2. 2

   Copiez la sortie hexadécimale de 64 caractères

   Cliquez sur le bouton Copier à côté du résultat du hash. La chaîne hexadécimale en minuscules de 64 caractères est copiée dans votre presse-papiers. Utilisez le bouton Majuscules si votre système cible requiert des majuscules. Cette sortie correspond à ce que produit toute implémentation SHA3-256 conforme à FIPS 202 — mais notez qu'elle diffère du keccak256 d'Ethereum pour la même entrée.

3. 3

   Vérifiez avec l'onglet Comparer

   Passez à l'onglet Comparer et collez deux hashes SHA3-256 côte à côte. L'outil utilise une comparaison en temps constant pour signaler la correspondance ou la non-correspondance sans divulguer d'informations de timing. Utile pour vérifier les vecteurs de test NIST CAVP, vérifier les manifestes d'archives ou confirmer que deux implémentations SHA3-256 produisent une sortie identique.

Détails techniques

Algorithme : construction sponge Keccak-f[1600]

SHA3-256 applique la permutation Keccak-f[1600] (24 tours d'opérations thêta, rho, pi, chi, iota sur un tableau d'état 5×5×64) dans une construction sponge avec débit=1088 bits et capacité=512 bits. L'entrée est absorbée en blocs de 136 octets (1088 bits) ; 256 bits de sortie sont pressés. Le séparateur de domaine FIPS 202 ajoute 0x06 avant le rembourrage. Implémentation : NIST FIPS 202 (2015) section 6.

Sortie : SHA3-256 par défaut, 64 hex (FIPS 202 définit aussi 224/384/512)

Cet outil produit SHA3-256 : toujours exactement 64 caractères hexadécimaux (256 bits = 32 octets). NIST FIPS 202 standardise également SHA3-224 (56 hex), SHA3-384 (96 hex) et SHA3-512 (128 hex) — tous utilisant la même permutation Keccak-f[1600] avec des découpages débit/capacité différents. La longueur de sortie est fixe quelle que soit la taille de l'entrée.

Performance : js-sha3 en chargement différé (~10 Ko) ; ~150–400 Mo/s dans le navigateur

Contrairement aux routes SHA-2 (qui utilisent la Web Crypto API native du navigateur), SHA-3 n'est pas dans la spécification Web Crypto. Cet outil charge la bibliothèque js-sha3 (~10 Ko compressé) lors de la première utilisation, puis la met en cache. Débit typique : 150–400 Mo/s en JavaScript, contre 400–700 Mo/s pour SHA-256 via Web Crypto. Pour le hachage de texte (kilo-octets), la différence est imperceptible. Le bundle principal des autres routes SHA n'est pas affecté par ce chargement différé.

Normes : NIST FIPS 202 (2015), NIST SP 800-185 (KMAC), NIST IR 8105

Standardisé dans FIPS 202 (août 2015). NIST SP 800-185 (2016) définit KMAC128 et KMAC256 — fonctions MAC à clé basées sur SHA-3 nativement immunisées contre l'extension de longueur sans l'encapsulation HMAC. NIST IR 8105 recommande les variantes SHA-3 pour la marge de sécurité post-quantique. Actuellement approuvé pour tous les niveaux de sécurité jusqu'en 2030 et au-delà selon NIST SP 800-131A Rev 2.

Bonnes pratiques

Ne confondez pas SHA3-256 avec le keccak256 d'Ethereum

Ce sont des algorithmes différents produisant des sorties différentes pour chaque entrée. Cet outil calcule le NIST FIPS 202 SHA3-256 (octet de rembourrage 0x06). Le keccak256 d'Ethereum utilise le rembourrage Keccak original (0x01). Si vous calculez des hashes d'adresses Ethereum, des emplacements de stockage EVM ou des résultats de keccak256() Solidity, vous avez besoin d'un outil spécifique à keccak256 — cet outil vous donnera des résultats erronés pour ces cas d'usage.

Utilisez SHA-3 comme couverture aux côtés de SHA-256, pas comme remplacement

SHA-3 et SHA-2 utilisent des conceptions structurellement différentes (sponge vs Merkle-Damgård). Un manifeste à double hash (SHA-256 + SHA3-256) offre une défense en profondeur : si une rupture cryptanalytique est jamais trouvée dans la construction d'une famille, l'autre reste sécurisée. Pour les données archivées long terme et les documents gouvernementaux, le NIST recommande de considérer cette approche à double algorithme. Pour un usage quotidien, SHA-256 seul reste parfaitement suffisant.

Préférez KMAC à HMAC-SHA3-256 pour les nouvelles conceptions de MAC à clé

NIST SP 800-185 définit KMAC128 et KMAC256 — MACs à clé dédiés basés sur SHA-3. Étant donné que la construction sponge est nativement immunisée contre l'extension de longueur, KMAC n'a pas besoin de l'encapsulation à double hachage que HMAC nécessite pour la sécurité. Pour les nouveaux protocoles ayant la flexibilité dans le choix d'algorithme MAC, KMAC128 (sécurité 128 bits) ou KMAC256 (sécurité 256 bits) sont plus propres et légèrement plus efficaces que HMAC-SHA3-256.

Utilisez une comparaison en temps constant lors de la vérification de hashes SHA-3 dans le code

Lors de la comparaison de deux hashes SHA3-256 dans du code, utilisez toujours une fonction d'égalité en temps constant : Node.js crypto.timingSafeEqual(), Python hmac.compare_digest(), Go subtle.ConstantTimeCompare(). L'égalité de chaînes naïve (=== ou ==) divulgue des informations de timing permettant à un attaquant de reconstruire le hash attendu octet par octet. Cela s'applique également à SHA-3 et à toutes les autres fonctions de hachage. L'onglet Comparer de cet outil utilise déjà la comparaison en temps constant.

Questions fréquentes SHA-3