Outil de Vérification de Hachage de Fichier
Calculer les hashes MD5, SHA-1, SHA-256, SHA-384, SHA-512 pour les fichiers
Glisser-déposer un fichier ici
Supporte tout type et taille de fichier
Qu'est-ce que le hachage de fichier ?
Un hash de fichier transforme le contenu d’un fichier en empreinte de longueur fixe selon un algorithme choisi. Le même fichier produit toujours la même valeur, tandis qu’un changement d’un seul octet peut donner un résultat totalement différent. Les hash servent à vérifier des téléchargements, comparer des sauvegardes, détecter des doublons, contrôler l’intégrité après transfert et confronter des checksums de release ou d’avis de sécurité. L’outil prend en charge MD5, SHA-1, SHA-256, SHA-384 et SHA-512. MD5 et SHA-1 existent encore dans des flux anciens, mais ne conviennent plus aux garanties modernes; SHA-256 ou mieux est préférable pour l’intégrité. L’empreinte ne révèle pas le fichier original.
Comment utiliser
Comment utiliser
- Glissez un fichier dans la zone de chargement ou cliquez sur le bouton « Select File »
- Cochez les algorithmes de hachage à calculer (sélection multiple)
- Cliquez sur le bouton « Calculate Hash » pour lancer le calcul
- Après le calcul, copiez les valeurs de hachage une par une ou toutes en une fois
- Pour la vérification, saisissez une valeur de hachage connue dans le champ de comparaison
Processus de vérification
- Calculez le hachage une fois le fichier entièrement téléchargé ou copié ; les fichiers partiels et les interruptions de transfert produisent des valeurs différentes.
- Lors de la comparaison avec une somme de contrôle publiée, copiez-la depuis la source officielle et faites correspondre l'algorithme exactement.
Cas d’utilisation
Principe technique
Tous les digests SHA de la page passent par l'API W3C Web Cryptography, exposée dans le navigateur sous crypto.subtle. L'appel est await crypto.subtle.digest(algorithm, buffer), où algorithm vaut 'SHA-1', 'SHA-256', 'SHA-384' ou 'SHA-512' (sensible à la casse) et buffer est un ArrayBuffer ou n'importe quel TypedArray. La fonction retourne une Promise qui résout vers un ArrayBuffer contenant les octets du digest ; la page le convertit en hex minuscule en le parcourant comme un Uint8Array et en mappant chaque octet sur byte.toString(16).padStart(2, '0'). SubtleCrypto n'est disponible que dans des contextes sécurisés (HTTPS ou localhost), et SHA-1 reste accessible pour la vérification héritée, bien que la spécification le qualifie de cassé en termes de résistance aux collisions. MD5 n'est pas dans la spécification Web Crypto (le W3C l'a omis volontairement à cause des attaques par collision) ; le MD5 de cette page est donc calculé par une implémentation en JavaScript pur qui s'exécute entièrement dans le navigateur. Pour tous les algorithmes — MD5 comme la famille SHA — le fichier est lu en une seule fois en ArrayBuffer via FileReader.readAsArrayBuffer puis transmis à la routine MD5 en JavaScript ou à crypto.subtle.digest. Cet outil ne propose pas d'API incrémentale .append ni de repli vers un Web Worker, donc la mémoire doit contenir le fichier entier d'un coup : convenable pour des téléchargements classiques, moins pour des charges de plusieurs Go, où un outil de bureau qui streame depuis le disque (sha256sum, certutil -hashfile, Get-FileHash) est plus adapté. Longueurs de digest et posture de sécurité : MD5 = 128 bits / 32 caractères hex (RFC 1321, résistance aux collisions cassée depuis Wang Xiaoyun 2004, exploité in the wild par le malware Flame en 2012) ; SHA-1 = 160 bits / 40 caractères hex (FIPS 180-4, collision démontrée par SHAttered de Google en 2017 avec ~9,2 × 10^18 calculs SHA-1, dépréciation formelle prévue par NIST après 2030) ; SHA-256 = 256 bits / 64 caractères hex (FIPS 180-4, pas de collision connue, baseline recommandée) ; SHA-384 et SHA-512 = 384 / 512 bits, sortie tronquée et complète de la famille SHA-512 (FIPS 180-4). L'effet d'avalanche des hachages cryptographiques fait qu'un seul bit d'entrée modifié change en moyenne la moitié des bits de sortie, ce qui explique qu'une modification d'un seul octet produise un digest totalement différent.
- crypto.subtle.digest(algorithm, buffer) accepte 'SHA-1', 'SHA-256', 'SHA-384', 'SHA-512' (sensible à la casse) et rejette 'MD5' ; nécessite un contexte sécurisé (HTTPS ou localhost) et renvoie un Promise<ArrayBuffer>.
- Encodage hexadécimal : parcourez le résultat avec new Uint8Array(digestBuffer) et mappez chaque octet en byte.toString(16).padStart(2, '0') ; comparez les condensés de manière insensible à la casse (normalisez via .toLowerCase()).
- MD5 est volontairement absent de Web Crypto ; cet outil le calcule en JavaScript pur, lit le fichier en un seul ArrayBuffer via FileReader.readAsArrayBuffer et produit un digest hex minuscule de 32 caractères en une passe.
- Profil mémoire : la page lit le fichier complet dans un seul ArrayBuffer (pas d'API incrémentale .append, pas de délégation à un Web Worker) et passe le buffer en un seul appel à la routine MD5 JavaScript ou à crypto.subtle.digest. Pour les fichiers qui dépassent le heap disponible de l'onglet, passe à un outil de bureau (sha256sum, certutil -hashfile, Get-FileHash) qui streame depuis le disque.
- Tailles de condensés (FIPS 180-4) : MD5 128 bits, SHA-1 160 bits, SHA-256 256 bits, SHA-384 384 bits, SHA-512 512 bits ; le nombre de caractères hex est le double du nombre d'octets.
- Attaques de collision connues : MD5 compromis par Wang 2004, exploité par Flame 2012 ; SHA-1 compromis par Google SHAttered 2017 (~9,2 × 10^18 ops, ~110 années-GPU) ; SHA-256 et au-delà n'ont aucune collision pratique connue.
- Effet d'avalanche : un changement d'un seul bit d'entrée inverse ~50% des bits de sortie en moyenne ; c'est pourquoi l'édition d'un seul octet produit un condensé hexadécimal complètement différent et pourquoi des correspondances partielles de fichier n'existent pas.
Exemples
Vérifier un fichier téléchargé par rapport à une somme de contrôle publiée
Fichier : sample.bin (3 octets, contenu : abc)
SHA-256 (calculé) :
ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad
Ligne SHA256SUMS publiée par l'éditeur :
ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad sample.bin
Correspondance -> téléchargement intact, non altéré
(Les deux valeurs sont le vecteur de référence FIPS 180-2 SHA-256 pour
l'entrée de 3 octets 'abc'. Remplacez l'entrée par le vrai fichier en
pratique ; la sortie de l'algorithme est déterministe.)Comparaison multi-algorithmes sur la même entrée
Fichier : sample.txt (3 octets, contenu : abc)
MD5: 900150983cd24fb0d6963f7d28e17f72
SHA-1: a9993e364706816aba3e25717850c26c9cd0d89d
SHA-256: ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad
SHA-512: ddaf35a193617abacc417349ae20413112e6fa4e89a97ea20a9eeee64b55d39a2192992a274fc1a836ba3c23a3feebbd454d4423643ce80e2a9ac94fa54ca49f
Mêmes entrées, algorithmes différents -> utilisez SHA-256 ou plus fort pour les contrôles de sécurité
(MD5 est le vecteur de référence RFC 1321 ; les autres sont les vecteurs
de référence FIPS 180-2, tous pour l'entrée de 3 octets 'abc'.)Détecter un changement d'1 octet (effet d'avalanche)
Entrée A : abc (3 octets)
Entrée B : abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq (56 octets)
SHA-256 de A : ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad
SHA-256 de B : 248d6a61d20638b8e5c026930c3e6039a33ce45964ff2167f6ecedd419db06c1
Un petit changement dans l'entrée produit un condensé
complètement différent -> c'est l'effet d'avalanche en action.
(Les deux valeurs sont des vecteurs de référence FIPS 180-2 SHA-256.)Référence console navigateur pour vérification
// Reproduire dans Node.js pour comparaison
$ printf 'abc' | shasum -a 256
ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad
// PowerShell sous Windows
PS> 'abc' | Get-FileHash -Algorithm SHA256 | Select-Object -ExpandProperty Hash
ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad
// Dans la console du navigateur, avec l'API Web Crypto :
// const buf = new TextEncoder().encode('abc');
// const hash = await crypto.subtle.digest('SHA-256', buf);
// -> ArrayBuffer du SHA-256 de 'abc' (vecteur de référence FIPS 180-2)
Les fichiers restent dans votre navigateur, rien n'est envoyé.FAQ
Quels algorithmes de hachage puis-je générer ?
Les options courantes sont MD5, SHA-1, SHA-224, SHA-256, SHA-384 et SHA-512. La page les calcule via l'API Web Crypto du navigateur (famille SHA) et du JS intégré pour MD5. SHA-256 est aujourd'hui le choix généraliste recommandé.
Le fichier est-il téléversé quelque part ?
Non. Le hachage se fait entièrement dans votre navigateur via la File API et Web Crypto. Les octets sont lus en mémoire par blocs et le hachage est calculé localement — le fichier ne traverse pas le réseau. Vous pouvez le vérifier en consultant l'onglet Réseau pendant le hachage.
Pourquoi MD5 est-il encore proposé s'il est cassé ?
MD5 est cassé pour la sécurité (les collisions sont faciles à construire) mais reste la somme de contrôle de fait pour vérifier qu'un téléchargement est bit à bit identique à la source — beaucoup d'éditeurs publient encore le MD5 à côté du SHA-256. N'utilisez MD5 que pour cela, jamais pour le hachage de mots de passe ou les signatures.
Pourquoi mes hachages SHA-256 diffèrent-ils pour un fichier qui semble identique ?
Les entrées du hachage incluent chaque octet, donc une seule fin de ligne en trop, un BOM ou une fin de ligne différente (CRLF vs LF) change complètement le hachage. Re-téléchargez l'original au lieu de copier-coller, ou utilisez un visualiseur de fichiers binaires pour confirmer que les deux fichiers ont des octets identiques.
Y a-t-il une limite de taille de fichier ?
Le navigateur doit disposer d'assez de mémoire pour lire le fichier. Les ordinateurs de bureau modernes gèrent des fichiers de plusieurs Go, mais les navigateurs mobiles peuvent manquer de mémoire autour de quelques centaines de Mo. Pour les très gros fichiers, utilisez un outil de bureau (sha256sum, certutil, Get-FileHash) — il lit en flux depuis le disque et est plus rapide.
Deux fichiers différents peuvent-ils produire le même hachage ?
En théorie oui (principe des tiroirs), mais pour SHA-256 la probabilité est astronomiquement faible. MD5 et SHA-1 ont des attaques par collision connues, donc deux fichiers ayant le même MD5 ou SHA-1 ne prouvent pas qu'ils sont le même fichier. Les collisions SHA-256 ne sont pas faisables avec les attaques connues.
Pourquoi mes hachages diffèrent-ils du hachage publié sur le site ?
Le plus souvent : vous avez téléchargé une version localisée, signée ou rempaquetée ; la page liste le hachage d'une autre version ; ou votre téléchargement a été tronqué. Re-téléchargez avec un outil propre, puis re-hachez. Si l'écart persiste, ne faites pas confiance au fichier.