ToolActToolAct

Outil de Vérification de Hachage de Fichier

Calculer les hashes MD5, SHA-1, SHA-256, SHA-384, SHA-512 pour les fichiers

Télécharger un fichier

Glisser-déposer un fichier ici

Supporte tout type et taille de fichier

Sélectionner l'algorithme de hash
MD5
128 bits
SHA-1
160 bits
SHA-256
256 bits
SHA-384
384 bits
SHA-512
512 bits
Vérifier la somme de contrôle

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

  1. Glissez un fichier dans la zone de chargement ou cliquez sur le bouton « Select File »
  2. Cochez les algorithmes de hachage à calculer (sélection multiple)
  3. Cliquez sur le bouton « Calculate Hash » pour lancer le calcul
  4. Après le calcul, copiez les valeurs de hachage une par une ou toutes en une fois
  5. 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

Calculer plusieurs empreintes de fichier à partir d’un seul importDépose un fichier et choisis MD5 (128 bits), SHA-1 (160 bits), SHA-256 (256 bits), SHA-384 (384 bits) et SHA-512 (512 bits) dans n'importe quelle combinaison pour générer des hashes localement avec un retour de progression. Le fichier est lu en mémoire puis transmis à crypto.subtle.digest (famille SHA) ou à une routine MD5 en JavaScript dans le navigateur ; le contenu binaire ne quitte donc jamais l'appareil, adapté aux firmwares propriétaires, builds internes et artefacts non publiés.
Vérifier une somme de contrôle publiée par rapport aux algorithmes sélectionnésCollez un hash attendu avant ou après le calcul et la page identifiera l’algorithme correspondant lorsque l’une des valeurs générées égale la chaîne de comparaison. La correspondance s’effectue sur du hexadécimal normalisé en minuscules, de sorte qu’une empreinte en majuscules publiée par l’éditeur et une empreinte en minuscules générée localement s’alignent sans ressaisie manuelle.
Utiliser des hashes plus robustes pour les décisions de confianceMD5 et SHA-1 sont utiles pour les vérifications existantes et la détection de doublons (les deux ont des attaques de collision publiées), mais SHA-256 ou mieux est le choix le plus sûr pour la vérification de téléchargements et la preuve de falsification. SHA-256 produit une empreinte hexadécimale de 64 caractères sans collision connue, et SHA-384/512 renforcent encore la sécurité pour les pipelines de livraison à haute exigence. Pour les très gros livrables, BLAKE3 est de plus en plus courant car environ trois à quatre fois plus rapide que SHA-256 sur les CPU modernes (débit soutenu dans la gamme Go/s) tout en conservant une arborescence Merkle compatible avec la lecture en flux vérifiée, bien que les sélecteurs de cet outil couvrent encore la famille SHA que la plupart des éditeurs publient.
Hacher chaque partie d’une archive fractionnée séparémentLes gros téléchargements arrivent souvent sous forme de morceaux .001, .002 ou .zipx avec un hash par partie (généralement SHA-1 ou SHA-256). Hashe chaque morceau face à la liste publiée par le fournisseur avant de les joindre, car une seule pièce mal alignée casse le fichier reconstitué — cette page permet d'exécuter le même algorithme sur toutes les parties sans les uploader. Chaque morceau est lu en mémoire dans le navigateur avant d'être hashé, donc le plafond pratique correspond à ce que le heap de l'onglet peut contenir ; pour les morceaux qui dépassent cette limite, replie-toi sur un outil de bureau (sha256sum, certutil -hashfile, Get-FileHash) qui streame depuis le disque.
Utiliser le champ de comparaison pour des correspondances insensibles à la casseCertains éditeurs publient du hexadécimal en majuscules, d’autres en minuscules. Collez la valeur attendue une seule fois et la page effectue la correspondance par identité d’algorithme et casse normalisée, de sorte qu’il n’est pas nécessaire de ressaisir la casse manuellement pour une vérification propre — la même empreinte en ‘A591A6...’ et en ‘a591a6...’ produit une correspondance réussie.

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.

Outils associés