Introduction au hachage à l'ère moderne
Les fonctions de hachage cryptographiques sont les héros méconnus de la sécurité numérique. De la sécurisation des mots de passe à la vérification de l'intégrité des distributions logicielles de plusieurs gigaoctets, elles fournissent une « empreinte numérique » aux données. À mesure que la puissance de calcul croît et que les techniques de cryptanalyse évoluent, l'industrie est passée d'algorithmes hérités comme MD5 et SHA-1 à des normes plus robustes : SHA-2 et le plus récent SHA-3.
Dans ce guide, nous explorerons les subtilités des familles SHA-2 et SHA-3, comparerons leurs architectures sous-jacentes et examinerons des alternatives modernes comme BLAKE2.
La famille SHA-2 : le bourreau de travail d'Internet
Développée par la NSA et publiée par le NIST en 2001, la famille SHA-2 (Secure Hash Algorithm 2) a remplacé le SHA-1 vulnérable. SHA-2 est basé sur la construction Merkle-Damgård, une méthode permettant de construire des fonctions de hachage résistantes aux collisions à partir de fonctions de compression à sens unique.
Variantes de SHA-2
La famille SHA-2 se compose de six fonctions de hachage avec différentes tailles de condensé :
- SHA-256 : La variante la plus largement utilisée. Elle produit un hachage de 256 bits (32 octets). C'est l'épine dorsale du Bitcoin et de nombreux certificats SSL/TLS.
- SHA-512 : Conçue pour les processeurs 64 bits, elle produit un hachage de 512 bits (64 octets). Elle est généralement plus rapide que SHA-256 sur du matériel 64 bits.
- SHA-224 : Une version tronquée de SHA-256.
- SHA-384 : Une version tronquée de SHA-512.
- SHA-512/224 et SHA-512/256 : Ce sont des versions tronquées de SHA-512 qui sont plus sûres contre les « attaques par extension de longueur » que SHA-256 tout en maintenant des performances élevées sur les systèmes 64 bits.
La structure Merkle-Damgård
La construction Merkle-Damgård fonctionne en :
- Remplissant le message pour que sa longueur soit un multiple d'une taille de bloc fixe.
- Décomposant le message en blocs.
- Traitant chaque bloc séquentiellement avec une fonction de compression qui prend la sortie du bloc précédent comme entrée.
Note sur la vulnérabilité : Une faiblesse inhérente de cette structure est l'Attaque par extension de longueur, où un attaquant peut calculer Hash(Message || Extension) s'il connaît Hash(Message) et la longueur de Message, sans connaître le message d'origine.
La famille SHA-3 : un changement de paradigme
Alors que SHA-2 reste sécurisé, le NIST a lancé un concours en 2007 pour trouver un algorithme fondamentalement différent pour servir de sauvegarde. Le gagnant a été Keccak, qui est devenu la norme SHA-3 en 2015.
La construction à éponge (Sponge Construction)
Contrairement au SHA-2, le SHA-3 utilise la construction à éponge. Cette architecture implique deux phases :
- Absorption (Absorbing) : Les blocs de message subissent une opération XOR dans un sous-ensemble de l'état interne.
- Essorage (Squeezing) : L'état est transformé et les bits de sortie sont lus (essorés) à partir de celui-ci.
L'état interne étant beaucoup plus grand que le hachage de sortie, le SHA-3 est naturellement résistant aux attaques par extension de longueur, éliminant ainsi un défaut de conception majeur présent dans le SHA-2.
Variantes de SHA-3
SHA-3 reflète les tailles de sortie de SHA-2 pour plus de compatibilité :
- SHA-3-224
- SHA-3-256
- SHA-3-384
- SHA-3-512
SHAKE : Fonctions à sortie extensible (XOF)
L'une des caractéristiques les plus innovantes de la norme SHA-3 est l'introduction de SHAKE (Secure Hash Algorithm and Keccak). Contrairement aux fonctions de hachage traditionnelles qui produisent une sortie de longueur fixe, SHAKE128 et SHAKE256 vous permettent de spécifier n'importe quelle longueur de sortie.
- SHAKE128 : Fournit 128 bits de sécurité contre toutes les attaques, à condition que la sortie soit assez longue.
- SHAKE256 : Fournit 256 bits de sécurité.
Ces fonctions sont incroyablement utiles pour générer de grandes quantités de données pseudonymes ou pour des schémas de remplissage à longueur variable.
BLAKE2 : L'alternative haute performance
Bien qu'il ne s'agisse pas d'une norme NIST, BLAKE2 (basé sur l'algorithme BLAKE du concours SHA-3) est très respecté dans l'industrie.
- BLAKE2b : Optimisé pour les plateformes 64 bits.
- BLAKE2s : Optimisé pour les plateformes 8 bits à 32 bits.
Pourquoi utiliser BLAKE2 ? Il est plus rapide que SHA-3 et même que SHA-2 sur la plupart des processeurs modernes tout en offrant une sécurité équivalente. Il est utilisé dans des projets comme Argon2 (hachage de mot de passe) et WireGuard.
Analyse de sécurité : pourquoi passer au SHA-3 ?
Si le SHA-2 n'est pas cassé, pourquoi s'embêter avec le SHA-3 ?
- Diversité : Si une percée en cryptanalyse casse la structure Merkle-Damgård, le SHA-2 tombe. Le SHA-3 (Éponge) fournit un fondement mathématique complètement différent.
- Résistance à l'extension de longueur : Le SHA-3 est plus sûr pour certaines constructions MAC (Code d'Authentification de Message).
- Pérennité : À mesure que l'informatique quantique se profile, des états plus grands et des structures différentes offrent une meilleure « défense en profondeur ».
Exemples de code
Node.js (utilisant le module crypto)
const crypto = require('crypto');
// SHA-256 (SHA-2)
const sha256 = crypto.createHash('sha256').update('Bonjour le monde').digest('hex');
console.log(`SHA-256: ${sha256}`);
// SHA3-256 (SHA-3)
const sha3 = crypto.createHash('sha3-256').update('Bonjour le monde').digest('hex');
console.log(`SHA3-256: ${sha3}`);
// SHAKE256 avec une sortie de 64 octets
const shake = crypto.createHash('shake256', { outputLength: 64 })
.update('Bonjour le monde')
.digest('hex');
console.log(`SHAKE256: ${shake}`);
Python (utilisant hashlib)
import hashlib
# SHA-256
print(f"SHA-256: {hashlib.sha256(b'Bonjour le monde').hexdigest()}")
# SHA3-256
print(f"SHA3-256: {hashlib.sha3_256(b'Bonjour le monde').hexdigest()}")
# SHAKE256
s = hashlib.shake_256(b'Bonjour le monde')
print(f"SHAKE256 (16 octets): {s.hexdigest(16)}")
FAQ : Idées reçues courantes
1. Le SHA-3 est-il « plus sûr » que le SHA-2 ?
En termes de résistance aux attaques connues, les deux sont actuellement très sûrs. Cependant, la structure du SHA-3 est théoriquement plus robuste contre certains types d'attaques (comme l'extension de longueur).
2. Le SHA-512 est-il toujours meilleur que le SHA-256 ?
Pas nécessairement. Bien qu'il ait un condensé plus long, il peut être plus lent sur les systèmes 32 bits. Cependant, sur les systèmes 64 bits, le SHA-512 est souvent plus rapide grâce à l'utilisation de l'arithmétique 64 bits.
3. Dois-je utiliser MD5 ou SHA-1 pour des tâches non liées à la sécurité ?
Généralement, non. Même pour des tâches non sécurisées (comme les ID d'objets git), les collisions peuvent provoquer des bogues. Utilisez au moins SHA-256 ou BLAKE2, sauf si vous avez une contrainte héritée.
4. Quelle est la différence entre SHAKE et SHA-3 ?
Le SHA-3 a une longueur de sortie fixe. SHAKE est une XOF (fonction à sortie extensible) qui utilise le même moteur Keccak mais vous permet de demander n'importe quel nombre de bits.
Conclusion
Le choix de la bonne fonction de hachage dépend de vos besoins spécifiques. Pour une utilisation générale et une compatibilité, SHA-256 reste la norme de l'industrie. Si vous construisez un nouveau système et souhaitez la sécurité architecturale la plus élevée, SHA-3 est la voie à suivre. Pour les applications hautes performances, BLAKE2 est un choix redoutable.