MD5, SHA-256, SHA-512 : générateur de hachage gratuit et quand utiliser chacun

Chaque fois que vous téléchargez une version d'un logiciel, vérifiez l'authenticité d'un fichier, signez un jeton JWT ou stockez le mot de passe d'un utilisateur, une fonction de hachage cryptographique travaille en arrière-plan. Les fonctions de hachage sont l'une des primitives fondamentales de la sécurité informatique moderne — et pourtant les différences entre MD5, SHA-1, SHA-256 et SHA-512 sont largement mal comprises, entraînant de véritables erreurs de sécurité dans les systèmes de production.

Ce guide explique ce que sont les fonctions de hachage, comment fonctionne chaque algorithme majeur, quand chacun est approprié (et quand il est dangereusement inapproprié), et comment utiliser le Générateur de hachage de BrowseryTools pour calculer des empreintes instantanément dans votre navigateur en toute confidentialité.

Qu'est-ce qu'une fonction de hachage cryptographique ?

Une fonction de hachage cryptographique prend une entrée de longueur arbitraire et produit une sortie de longueur fixe appelée empreinte ou hachage. Quatre propriétés définissent une bonne fonction de hachage cryptographique :

• Déterministe : la même entrée produit toujours exactement la même sortie. Les fonctions de hachage n'ont aucun état interne — avec les mêmes octets, vous obtenez toujours la même empreinte.
• À sens unique (résistance à la préimage) : à partir d'une sortie de hachage, il devrait être calculatoirement impossible de récupérer l'entrée d'origine. Les fonctions de hachage sont conçues pour être faciles à calculer dans un sens et effectivement impossibles à inverser.
• Longueur de sortie fixe : que l'entrée fasse un octet ou un gigaoctet, la sortie a toujours la même longueur. SHA-256 produit toujours une empreinte de 256 bits (32 octets).
• Effet d'avalanche : un changement d'un seul bit dans l'entrée transforme complètement la sortie. Le hachage de hello ne ressemble en rien au hachage de hello! — ils ne partagent aucune structure prévisible. Cela rend les empreintes utiles comme empreintes digitales.

Une cinquième propriété — la résistance aux collisions — sépare les hachages cryptographiquement solides de ceux qui sont cassés : il devrait être calculatoirement impossible de trouver deux entrées différentes qui produisent la même sortie. C'est là que MD5 et SHA-1 ont échoué.

MD5 : rapide, omniprésent et cassé pour la sécurité

MD5 (Message Digest 5) a été conçu par Ron Rivest et publié en 1991. Il produit une empreinte de 128 bits (16 octets), généralement représentée sous forme de chaîne hexadécimale de 32 caractères comme 5d41402abc4b2a76b9719d911017c592. Pendant plus d'une décennie, ce fut l'algorithme de hachage dominant pour tout, des sommes de contrôle de fichiers au stockage de mots de passe.

En 2004, des cryptographes ont démontré des attaques par collision pratiques contre MD5. En 2008, des chercheurs avaient utilisé des attaques par collision pour forger un certificat d'autorité de certification frauduleux approuvé par tous les principaux navigateurs. MD5 est désormais définitivement cassé pour tout usage de sécurité où la résistance aux collisions importe.

Là où MD5 est encore acceptable :

• Les contrôles d'intégrité de fichiers hors sécurité où vous contrôlez à la fois la génération et la vérification (confirmer qu'un fichier n'a pas été corrompu en transit, et non qu'il n'a pas été altéré).
• Les sommes de contrôle dans les systèmes internes où un acteur malveillant ne fait pas partie du modèle de menace.
• La compatibilité avec des systèmes hérités où vous n'avez d'autre choix que de correspondre à une implémentation existante.
• Les clés de cache et les tables de hachage où la sécurité est sans importance et la vitesse compte.

Là où MD5 ne doit jamais être utilisé : les certificats TLS, les signatures numériques, la signature de code, ou tout ce où un attaquant pourrait tirer profit de la découverte d'une collision.

SHA-1 : 160 bits, déprécié, toujours partout

SHA-1 (Secure Hash Algorithm 1) a été publié par le NIST en 1995 et produit une empreinte de 160 bits. C'était la norme pour les certificats TLS, les signatures numériques et la signature de logiciels tout au long des années 2000. Le Project Zero de Google a démontré une collision SHA-1 pratique en 2017 (l'attaque SHAttered), produisant deux fichiers PDF différents avec des empreintes SHA-1 identiques. Cela a mis fin à l'utilisation de SHA-1 dans TLS — tous les principaux éditeurs de navigateurs ont cessé d'accepter les certificats SHA-1 cette même année.

SHA-1 se trouve encore dans quelques endroits notables :

• Git : Git a historiquement utilisé SHA-1 pour identifier chaque objet d'un dépôt — commits, blobs, arbres et tags. Git migre activement vers SHA-256 (voir ci-dessous), mais les dépôts Git en SHA-1 restent extrêmement courants. Pour ce cas d'usage, la résistance aux collisions importe moins car un attaquant aurait besoin d'un accès au système de fichiers pour exploiter une collision.
• Les systèmes d'authentification hérités et les anciennes implémentations HMAC.
• Certains anciens logiciels d'entreprise qui n'ont pas été mis à jour.

Pour tout nouveau travail : évitez SHA-1. Utilisez SHA-256 ou SHA-512.

SHA-256 : la norme actuelle

SHA-256 fait partie de la famille SHA-2, publiée par le NIST en 2001. Il produit une empreinte de 256 bits (32 octets) — deux fois la longueur de sortie de MD5 et 60 % plus grande que SHA-1. Aucune attaque pratique par collision ou par préimage contre SHA-256 n'a été démontrée. Il reste la norme pour le hachage sensible à la sécurité en 2026.

SHA-256 est utilisé partout :

• Les certificats TLS : le CA/Browser Forum a imposé SHA-256 comme minimum pour les signatures de certificats. Chaque connexion HTTPS que vous établissez est ancrée par SHA-256.
• La signature de code : macOS, Windows Authenticode et les gestionnaires de paquets Linux (APT, RPM) utilisent SHA-256 pour vérifier l'intégrité des logiciels.
• Les jetons JWT : l'algorithme HS256 dans les jetons web JSON est HMAC-SHA-256. C'est de loin l'algorithme de signature JWT le plus courant dans les systèmes déployés.
• Bitcoin : l'algorithme de preuve de travail de Bitcoin est le double-SHA-256 (SHA-256 appliqué deux fois).
• Git (nouvelle génération) : le format d'objet SHA-256 de Git (activé avec --object-format=sha256) utilise SHA-256 pour tous les identifiants d'objets.
• La vérification d'intégrité des fichiers publiée aux côtés des téléchargements de logiciels.

Si vous devez choisir une fonction de hachage et que vous n'avez aucune contrainte spécifique, SHA-256 est le choix par défaut correct en 2026.

SHA-512 : sortie plus grande, parfois plus rapide

SHA-512 fait également partie de la famille SHA-2 et produit une empreinte de 512 bits (64 octets). Il offre une marge de sécurité plus grande que SHA-256 — 512 bits de sortie signifient que l'espace théorique d'attaque par force brute est 2²⁵⁶ fois plus grand. En pratique, cette marge supplémentaire est sans importance pour la plupart des applications puisque SHA-256 est déjà calculatoirement impossible à casser.

La caractéristique de performance contre-intuitive : SHA-512 est plus rapide que SHA-256 sur les CPU 64 bits modernes lors du hachage de données volumineuses. SHA-512 traite les données en blocs de 1024 bits avec des opérations sur mots de 64 bits, tandis que SHA-256 utilise des blocs de 512 bits avec des opérations sur 32 bits. Sur un processeur 64 bits, les opérations 64 bits se mappent plus efficacement au matériel. Cela fait de SHA-512 le choix privilégié pour les applications qui hachent de gros fichiers sur des serveurs 64 bits.

Utilisez SHA-512 lorsque :

• Vous hachez de grandes quantités de données sur du matériel 64 bits et voulez un débit maximal.
• Votre système exige la marge de sécurité supplémentaire pour des raisons réglementaires ou de conformité.
• Vous implémentez HMAC-SHA-512 (utilisé dans certaines implémentations JWT avec HS512).

Tableau comparatif des algorithmes

Vérification de l'intégrité des fichiers : un exemple pratique

L'un des usages les plus courants et les plus légitimes des empreintes cryptographiques est de vérifier qu'un fichier téléchargé est exactement ce que l'éditeur a prévu — non corrompu en transit et non altéré par un tiers. La plupart des grands projets logiciels publient des sommes de contrôle SHA-256 aux côtés de leurs téléchargements.

Le flux de travail ressemble à ceci :

• Téléchargez le fichier depuis la source officielle.
• Téléchargez la somme de contrôle publiée depuis la même source officielle (idéalement signée avec PGP).
• Calculez le hachage SHA-256 du fichier téléchargé.
• Comparez votre hachage calculé au hachage publié caractère par caractère. Toute différence signifie que le fichier n'est pas ce que l'éditeur a distribué.

Le Générateur de hachage de BrowseryTools prend en charge le hachage de fichiers — glissez-y un fichier et il calculera le hachage localement dans votre navigateur sans rien téléverser. Comparez le résultat directement à la somme de contrôle publiée.

Stockage des mots de passe : la seule chose que les hachages ne peuvent pas faire en toute sécurité

Comment Git utilise SHA-1 (et migre vers SHA-256)

Git utilise une fonction de hachage pour identifier chaque objet d'un dépôt. Chaque commit, fichier (blob), liste de répertoire (arbre) et tag est stocké dans la base de données d'objets sous son empreinte SHA-1. Lorsque vous exécutez git log, les longues chaînes hexadécimales que vous voyez — comme c206f4b3a9d72bc0e53a0e1a6e4bdf8c7f9d2e51 — sont des empreintes SHA-1 d'objets de commit.

Git a choisi SHA-1 en 2005 pour la vitesse et parce qu'à l'époque SHA-1 n'était pas cassé. Le rôle des empreintes dans Git diffère légèrement de l'usage de sécurité traditionnel : Git les utilise comme clés de stockage adressables par le contenu, et non comme preuves d'authentification. Le contenu lui-même est ce à quoi vous faites confiance — l'empreinte n'est qu'un moyen efficace de le rechercher et de détecter une corruption accidentelle.

Après la collision SHA-1 SHAttered en 2017, le projet Git a commencé à travailler sur la transition vers SHA-256. Le nouveau format d'objet (--object-format=sha256) est disponible dans Git 2.29+ et est utilisé par défaut sur certains nouveaux hébergeurs de dépôts. Les dépôts existants peuvent être migrés, bien que la transition soit complexe car chaque identifiant d'objet change.

HMAC : authentification de messages basée sur le hachage

Un simple hachage vérifie l'intégrité des données (les données n'ont pas changé) mais pas l'authenticité (les données proviennent de qui vous pensez qu'elles proviennent). Si un attaquant peut intercepter un message et recalculer l'empreinte après l'avoir modifié, un simple hachage n'offre aucune protection.

HMAC (Hash-based Message Authentication Code) résout cela en incorporant une clé secrète dans le calcul du hachage. Le résultat ne peut être produit que par quelqu'un qui connaît la clé. Vérifier un HMAC prouve à la fois que les données sont intactes et qu'elles ont été produites par une partie ayant accès au secret partagé.

HMAC-SHA256 est partout :

• Les jetons JWT (HS256) : le serveur signe l'en-tête et la charge utile du jeton avec HMAC-SHA256 à l'aide d'une clé secrète. Les clients ne peuvent pas forger de jetons valides sans la clé.
• La signature des requêtes d'API : AWS Signature Version 4 utilise HMAC-SHA256 pour authentifier les requêtes d'API. Les détails de la requête et une clé de signature dérivée sont hachés ensemble afin que ni l'un ni l'autre ne puisse être modifié sans invalider la signature.
• L'intégrité des cookies : de nombreux frameworks web utilisent HMAC pour signer les cookies de session, empêchant les utilisateurs d'altérer leurs propres données de session.

Comment utiliser le Générateur de hachage de BrowseryTools

Le Générateur de hachage prend en charge le hachage à la fois de texte saisi et de fichiers téléversés, entièrement dans votre navigateur. Voici comment cela fonctionne :

• Hachage de texte : collez n'importe quel texte dans le champ de saisie. L'outil calcule immédiatement et affiche le hachage pour chaque algorithme pris en charge simultanément — MD5, SHA-1, SHA-256 et SHA-512 — afin que vous puissiez les comparer côte à côte et choisir celui dont vous avez besoin.
• Hachage de fichiers : cliquez sur le champ de fichier ou glissez-déposez n'importe quel fichier. Le fichier est lu par l'API File de votre navigateur et haché localement. Les gros fichiers sont traités par morceaux pour éviter la pression sur la mémoire. Aucun octet de votre fichier ne quitte votre appareil.
• Choisissez l'algorithme : sélectionnez l'algorithme spécifique sur lequel vous concentrer pour votre cas d'usage. L'empreinte hexadécimale complète est affichée et peut être copiée en un clic.
• Téléchargez sous forme de fichier : à des fins de documentation ou de distribution, exportez l'empreinte de hachage sous forme de fichier texte — utile pour publier des sommes de contrôle aux côtés de vos propres versions de logiciels.

Confidentialité : l'API Web Crypto

Choisir le bon algorithme : un guide de décision

• Intégrité de fichiers / sommes de contrôle (hors sécurité) : MD5 ou SHA-256. SHA-256 est privilégié pour tout ce qui est public même si le modèle de menace ne concerne que la corruption accidentelle, car utiliser un algorithme cassé par choix est difficile à justifier auprès des auditeurs.
• TLS, signature de code, opérations sur certificats : SHA-256 (obligatoire — SHA-1 est rejeté).
• Signature JWT : HMAC-SHA-256 (HS256) pour le symétrique, ou RS256/ES256 pour l'asymétrique. Jamais MD5 ni SHA-1.
• Stockage des mots de passe : Argon2id, bcrypt ou scrypt. Aucun SHA quel qu'il soit.
• Hachage de gros fichiers sur des serveurs 64 bits : SHA-512 pour le meilleur débit.
• Marge de sécurité maximale : SHA-512 ou SHA-3 (SHA3-256, SHA3-512).
• Compatibilité héritée : ce que le système hérité exige — mais planifiez la migration hors de MD5 et SHA-1.