Outils développeur

Générateur de hash et somme de contrôle

Obtenez simultanément les MD5, SHA-1, SHA-256, SHA-384 et SHA-512 pour du texte et des fichiers. Vérifiez qu'un fichier téléchargé correspond à sa somme de contrôle officielle pour vous assurer qu'il n'a pas été altéré. Tout est local, rien ne quitte votre navigateur.

5 algorithmes simultanément Somme de contrôle texte + fichier Local, zéro téléversement Résultats instantanés

Algorithmes: MD5 · SHA-1/256/384/512
Moteur: Web Crypto API
Confidentialité: 100% local
Entrée: Texte / fichier

Caractères Octets UTF-8

Résultats des hashs

Collez la somme de contrôle officielle pour vérifier

Réussi : le fichier correspond exactement à la somme de contrôle officielle. Utilisation sans risque.

Échec : le fichier diffère de la somme de contrôle officielle — il est peut-être corrompu ou altéré. Ne l'exécutez pas.

Une somme de contrôle ne peut contenir que des caractères hexadécimaux (0-9, a-f). Vérifiez ce que vous avez copié.

La longueur doit être de 32 (MD5), 40 (SHA-1), 64 (SHA-256), 96 (SHA-384) ou 128 (SHA-512) caractères — assurez-vous que l'intégralité de la valeur a été copiée.

CARACTÉRISTIQUES

Les cinq hashs sur une seule page

Des empreintes rapides aux signatures sécurisées — tous les hashs dont ont besoin les développeurs, les administrateurs systèmes et pour la vérification des téléchargements.

Cinq algorithmes

MD5, SHA-1, SHA-256, SHA-384 et SHA-512 affichés ensemble avec leurs longueurs de sortie en bits — plus besoin de basculer entre les outils.

Calcul en temps réel

Hasher du texte pendant que vous tapez, aucun bouton à appuyer. Résultats en police monospace — cliquez sur une ligne pour copier.

Vérification d'intégrité de fichier

Déposez un installateur, une image disque ou une archive et comparez-la à la somme de contrôle officielle pour confirmer un téléchargement non altéré.

Local, zéro téléversement

La famille SHA utilise l'API Web Crypto intégrée au navigateur. Le texte et les fichiers ne quittent jamais votre machine — le contenu sensible reste donc protégé.

Conformité UTF-8

Le texte est haché sous forme d'octets UTF-8, donc les résultats correspondent exactement à md5sum, md5() de PHP et hashlib de Python.

Copie en un clic

Copiez chaque hachage individuellement ou tous au format de somme de contrôle standard, prêt à être collé dans un terminal.

Ce que vous devez savoir sur les hachages

L'idée est simple, mais utiliser le mauvais pour la mauvaise tâche est une véritable erreur de sécurité.

Que sont exactement MD5 et SHA-1 ?

MD5 (Message-Digest Algorithm 5) a été conçu par Ronald Rivest au MIT et publié en 1992 sous la référence RFC 1321, produisant un condensé fixe de 128 bits (32 caractères hexadécimaux) successeur de MD4. SHA-1 a été conçu par la National Security Agency américaine et publié en 1995 comme norme fédérale FIPS 180-1, produisant 160 bits. Tous deux sont devenus les algorithmes de hachage les plus largement déployés au cours des deux décennies suivantes — utilisés pour les sommes de contrôle de fichiers, le stockage de mots de passe, les signatures numériques et les identifiants de commit Git. Notez qu'ils produisent toujours des condensés corrects aujourd'hui ; « non sécurisé » signifie que leur résistance aux collisions est compromise, pas que leur sortie est erronée.

Le hachage, le chiffrement et l'encodage sont-ils la même chose ?

Non — ils résolvent des problèmes différents. L'encodage (comme Base64 ou l'encodage URL) est une transformation de format réversible que tout le monde peut défaire, sans aucune sécurité. Le chiffrement est réversible avec une clé : le texte clair devient texte chiffré et la bonne clé le déchiffre. Le hachage est unidirectionnel, n'a pas de clé et l'original ne peut pas être récupéré à partir du condensé — il est utilisé pour les empreintes digitales, les vérifications d'intégrité et les signatures. Deux malentendus courants : considérer Base64 comme « chiffrement », et dire qu'un mot de passe a été « chiffré avec MD5 » — c'est du hachage, et une manière dangereuse de stocker les mots de passe en plus.

Pourquoi ne peut-on pas inverser un hachage pour retrouver l'original ?

Un hachage est une fonction unidirectionnelle : une entrée de n'importe quelle longueur est compressée en un condensé de longueur fixe, réduisant la plupart des informations. Tout comme on ne peut pas reconstruire une phrase à partir du nombre de ses mots, l'original ne peut pas être dérivé du condensé. Les algorithmes sécurisés sont spécifiquement conçus pour rendre une telle inversion impossible sur le plan calculatoire.

MD5 et SHA-1 sont-ils encore utilisables ?

Pour vérifier si un fichier a été corrompu accidentellement pendant le transfert — oui, toute modification d'un octet isolé change pratiquement toujours le MD5. Mais jamais pour la sécurité : des attaques pratiques par collision existent pour les deux (des chercheurs peuvent créer deux fichiers différents ayant le même MD5 sous leur contrôle). Utilisez SHA-256 ou supérieur pour les mots de passe, les signatures et les certificats.

Pourquoi mon hachage diffère-t-il d'un autre outil pour le même texte ?

Trois coupables habituels : ① un encodage de caractères différent (cet outil utilise toujours UTF-8 ; les outils anciens peuvent utiliser GBK ou Latin-1) ; ② un saut de ligne final — la commande echo en ajoute un par défaut (utilisez echo -n) ; ③ un espace isolé ou un caractère invisible lors de la copie. Les hachages sont sensibles à chaque octet, donc un seul octet de différence modifie complètement le résultat.

Pourquoi ne peut-on pas stocker les mots de passe sous forme de MD5/SHA-256 en clair ?

Les hachages classiques sont rapides. Avec une table de hachage fuite, les attaquants peuvent essayer des milliards de suppositions par seconde, et les tables arc-en-ciel effectuent des recherches inverses sur les mots de passe courants instantanément. Les mots de passe nécessitent des algorithmes délibérément lents et exigeants en mémoire (bcrypt, scrypt, Argon2) avec un sel unique par mot de passe, rendant la force brute prohibitively coûteuse.

Comment vérifier l'intégrité d'un fichier téléchargé ?

Retrouvez la somme de contrôle publiée sur le site officiel (généralement SHA-256), faites glisser le fichier téléchargé vers l'onglet « Somme de contrôle de fichier » ici, puis collez la valeur officielle dans la zone située au-dessus des résultats. L'outil détecte l'algorithme grâce à la longueur de la valeur et colore la ligne correspondante en vert lorsque les octets du fichier sont exactement ceux publiés par l'éditeur ; le rouge indique une corruption ou une substitution par un intermédiaire malveillant — n'exécutez pas le fichier dans ce cas.

Quel des cinq algorithmes utiliser

Choisissez en fonction de votre cas d'usage. Les algorithmes récents produisent des condensats plus longs, sont mieux résistants aux attaques et nécessitent légèrement plus de ressources pour être calculés.

Algorithme	Date d'introduction	Longueur de sortie	Sécurité	Usage typique
MD5	1992	128 bits (32 caractères)	Cassé ; collisions possibles en pratique	Empreintes non sécurisées, déduplication, compatibilité legacy
SHA-1	1995	160 bits (40 caractères)	Collisions possibles en pratique depuis 2017	ID d'historique Git et autres systèmes legacy ; ne pas utiliser pour des raisons de sécurité nouvelles
SHA-256	2001	256 bits (64 caractères)	Sécurisé aujourd'hui	Sommes de contrôle de fichiers, signatures, certificats TLS, blockchains — la référence universelle
SHA-384	2001	384 bits (96 caractères)	Sécurisé	SHA-512 tronqué, pour les réglementations exigeant 384 bits
SHA-512	2001	512 bits (128 caractères)	Sécurisé	Signatures de haute confiance ; souvent plus rapide que SHA-256 sur les processeurs 64 bits

« Sécurisé » signifie qu'il n'existe à ce jour aucune attaque de collision publique exploitable en pratique. Pour le stockage de mots de passe, utilisez bcrypt/Argon2 quel que soit le choix du hachage.

Sommes de contrôle : comment vérifier effectivement un fichier téléchargé

À quoi sert cette chaîne MD5 ou SHA-256 présente sur une page de téléchargement, comment la comparer et avec quoi la comparer — tout cela dans cette section.

Pourquoi vérifier absolument

Le fichier présent sur votre disque n'est pas nécessairement celui qui se trouve sur le serveur. Une comparaison de somme de contrôle de dix secondes permet de se prémunir contre trois types de problèmes :

Corruption pendant le transfert

Les fichiers volumineux téléchargés avec reprise et sur des réseaux instables capturent étonnamment souvent des octets parasites ; résoudre un problème d'installateur cassé prendra bien plus de dix secondes.

Serveurs miroirs désynchronisés

De nombreux téléchargements proviennent en réalité de miroirs ou de CDN, où un décalage de synchronisation ou un défaut de cache peuvent vous fournir une version obsolète — ou un fichier incomplet.

Altération délibérée

Lorsqu'une source de téléchargement est compromise ou qu'un réseau public est piraté, les fichiers peuvent être backdoorés. En 2016, le site Linux Mint a été piraté et ses liens de téléchargement remplacés par un ISO backdooré — la première réponse du projet a été d'exhorter tout le monde à vérifier la somme de contrôle.

Qu'est-ce qu'une somme de contrôle

L'éditeur calcule le hachage du fichier sur son serveur et publie le résultat sur la page de téléchargement ; après téléchargement, vous le recalculerez localement. Si les deux chaînes correspondent caractère par caractère, les octets du fichier sont exactement ceux diffusés par l'éditeur — ni corrompus, ni modifiés. La vérification est sensible à chaque octet : modifier ne serait-ce qu'un octet change entièrement la valeur. De manière générale, les sommes de contrôle incluent également des schémas plus simples comme CRC32 qui ne détectent que les corruptions accidentelles, tandis que les hachages cryptographiques comme MD5/SHA résistent également à la falsification délibérée.

Vérifier un fichier en trois étapes

1

Obtenir la somme de contrôle officielle

Sur la page de téléchargement, recherchez la valeur MD5 / SHA-256 publiée (généralement étiquetée « checksum » ou fournie dans un fichier annexe .sha256) et copiez l'ensemble de la chaîne.
2

Déposez le fichier et collez

Passez à l'onglet « Somme de contrôle de fichier » ci-dessus, déposez le fichier téléchargé et collez la somme de contrôle dans la zone située au-dessus des résultats.
3

Lire le verdict par couleur

L'outil détecte l'algorithme à partir de la longueur de la valeur : vert signifie que le fichier correspond exactement à la version officielle et est sûr à utiliser ; rouge signifie qu'il pourrait être corrompu ou modifié — ne l'exécutez pas.

Lire les sommes de contrôle sur les sites officiels

Les pages de téléchargement affichent les sommes de contrôle sous de nombreux formats, mais toutes se résument à deux éléments : la valeur du hachage et le nom du fichier. Ces trois formats sont les plus courants — lors du collage, prenez uniquement la partie hachage (cet outil ignore automatiquement les espaces et les sauts de ligne) :

# 1. Ligne unique : uniquement la valeur
a0570aa01532917be820a37994710cf09b6eba198bf9543c27be938c5f09e60a

# 2. Format sha256sum : valeur + deux espaces + nom de fichier (un manifeste SHA256SUMS comporte de nombreuses lignes de ce type)
a0570aa01532917be820a37994710cf09b6eba198bf9543c27be938c5f09e60a  ubuntu-24.04.iso

# 3. Format BSD : Algorithme (nom du fichier) = valeur
SHA256 (ubuntu-24.04.iso) = a0570aa01532917be820a37994710cf09b6eba198bf9543c27be938c5f09e60a

MD5 ou SHA-256

Vérifiez ce que fournit le site officiel, mais si vous devez choisir : MD5 est tout à fait suffisant contre les corruptions accidentelles pendant le transfert (toute modification involontaire modifie pratiquement toujours le MD5). Pour résister à une falsification délibérée — logiciels de sécurité, certificats, paquets signés — vous avez besoin de SHA-256 ou d'un algorithme plus fort, car des attaques par collision permettent actuellement à des attaquants de créer deux fichiers différents avec le même MD5. Ce point est détaillé dans la « historique de sécurité » ci-dessous.

Vérifier depuis la ligne de commande à la place

Sur Linux et macOS, les outils de somme de contrôle acceptent l'option -c pour vérifier automatiquement l'ensemble d'un manifeste — aucune comparaison manuelle n'est nécessaire. Les commandes intégrées de Windows se contentent de calculer la valeur, que vous devez ensuite comparer vous-même avec la chaîne officielle.

Environnement	Commande de vérification
Linux	`sha256sum -c SHA256SUMS (vérifie chaque fichier listé dans le manifeste)`
macOS	`shasum -a 256 -c checksum.txt`
Vérification rapide d'une valeur unique	`echo "valeur-officielle nom-fichier" \| sha256sum -c - (affiche OK en cas de succès)`
Windows	`Calculez avec Get-FileHash <file> -Algorithm SHA256, puis comparez avec la valeur officielle`

Brève histoire de la sécurité : comment MD5 a été brisé

MD5 n'a pas échoué du jour au lendemain — de la première faille découverte en milieu universitaire aux certificats falsifiés en production, cela a pris deux décennies.

1992

MD5 est publié

Ronald Rivest a publié le MD5 dans la RFC 1321. Rapide, simple à mettre en œuvre et produisant systématiquement une empreinte de 128 bits, il est rapidement devenu la référence de facto pour les sommes de contrôle de fichiers et le stockage des mots de passe — et était considéré comme cryptographiquement sécurisé.
2004

L'équipe de Wang Xiaoyun révèle des collisions complètes MD5

Lors de CRYPTO 2004, une équipe dirigée par la mathématicienne chinoise Wang Xiaoyun a démontré une attaque par collision complète sur le MD5 : construction de deux fichiers de contenu différent mais de même empreinte (initialement en environ une heure sur un supercalculateur IBM P690 ; des améliorations ultérieures ont réduit cela à quelques secondes sur du matériel standard). La résistance aux collisions promise par le MD5 n'existait plus ; l'ovation debout qui a suivi est devenue l'un des moments les plus célèbres de la cryptographie.
2008

Des certificats forgés atteignent l'internet réel

Marc Stevens, Alexander Sotirov et d'autres ont utilisé une collision à préfixe choisi pour forger un certificat d'autorité de certification intermédiaire, approuvé par les navigateurs : des certificats avec des préfixes différents portaient la même signature. Un attaquant pouvait alors émettre des certificats HTTPS « valides » pour n'importe quel site frauduleux. Les autorités de certification ont cessé d'émettre des certificats MD5 peu après.
2012

Le malware Flame attaque Windows via MD5

Le malware Flame, financé par un État, a utilisé une collision MD5 pour amener l'autorité de licences de serveurs terminals de Microsoft à signer un certificat de signature de code forgé, lui permettant de se propager au Moyen-Orient sous les traits d'une mise à jour signée par Microsoft. C'était la première attaque dans le monde réel utilisant une collision MD5 ; Microsoft a révoqué le certificat dans un correctif d'urgence.
2017

SHAttered : le SHA-1 tombe

Google et l'institut néerlandais CWI (Marc Stevens et al.) ont publié deux fichiers PDF différents avec une même empreinte SHA-1 — pour un coût d'environ 6 500 années-processeur et 110 années-GPU. Les navigateurs ont retiré leur confiance aux certificats SHA-1 peu après, et les plateformes Git ont accéléré leur migration loin de celui-ci. L'ère des 160 bits était terminée.

Nuance importante : une attaque par collision ne « craque » pas l'empreinte de fichier existant — elle construit deux fichiers spécifiques qui génèrent la même valeur. Mais pour les signatures et les certificats, cela suffit déjà à une falsification fatale.

Hachage depuis la ligne de commande

Quand un navigateur n'est pas disponible, chaque système d'exploitation inclut une commande intégrée (SHA-256 montrée).

Environnement	Commande
Linux / macOS	`sha256sum nomdufichier (sur macOS : shasum -a 256 nomdufichier)`
Windows PowerShell	`Get-FileHash nomdufichier -Algorithm SHA256`
Windows CMD	`certutil -hashfile nomdufichier SHA256`

Hachage en code

Exemples minimaux dans quatre langages courants lorsque vous écrivez des scripts ou intégrez des API.

JavaScript

async function sha256Hex(data) {
  const bytes = typeof data === "string"
    ? new TextEncoder().encode(data)
    : new Uint8Array(data);
  const digest = await crypto.subtle.digest("SHA-256", bytes);
  return [...new Uint8Array(digest)]
    .map((b) => b.toString(16).padStart(2, "0"))
    .join("");
}

// Text
console.log(await sha256Hex("hello"));

// Files: digest accepts an ArrayBuffer directly
const buf = await file.arrayBuffer();
console.log(await sha256Hex(buf));

L'API Web Crypto native du navigateur ne prend en charge que la famille SHA et requiert HTTPS ou localhost ; le MD5 nécessite une bibliothèque tierce.

PHP

echo hash('sha256', 'hello');        // 64 hex characters
echo md5('hello');                   // same as hash('md5', 'hello')

// Streamed: hashes the file without loading it into memory
echo hash_file('sha256', 'setup.exe');

hash() et hash_file() prennent en charge md5, sha1, sha256, sha512 et plus ; le hachage de fichier est réalisé en flux, donc il consomme peu de mémoire.

Python

import hashlib

print(hashlib.sha256(b"hello").hexdigest())
print(hashlib.md5(b"hello").hexdigest())

# Large files: streamed, low memory (Python 3.11+)
with open("setup.exe", "rb") as f:
    print(hashlib.file_digest(f, "sha256").hexdigest())

La bibliothèque standard hashlib ne nécessite aucune installation ; utilisez file_digest() pour le hachage en flux de fichiers volumineux (Python 3.11+).

Rust

use sha2::{Digest, Sha256};
use md5::Md5;

// Text
println!("{:x}", Sha256::digest(b"hello"));
println!("{:x}", Md5::digest(b"hello"));

// Large files: streamed, low memory
let mut file = std::fs::File::open("setup.exe")?;
let mut hasher = Sha256::new();
std::io::copy(&mut file, &mut hasher)?;
println!("{:x}", hasher.finalize());

Le hachage n'est pas inclus dans la bibliothèque standard ; ajoutez les crates RustCrypto sha2 et md-5 dans Cargo.toml. Avec l'option std activée, io::copy transfère les fichiers en flux dans le hacheur.

FAQ

Est-ce que mes textes et fichiers sont téléchargés ?

Non. Tout est calculé dans votre navigateur : les appels à la famille SHA utilisent l'API Web Crypto intégrée, et MD5 s'exécute dans le JavaScript de la page. L'outil fonctionne sans connexion réseau — testez-le avec un fichier sensible.

Pourquoi un texte vide a-t-il toujours un hash ?

Les algorithmes de hash définissent une sortie fixe et unique même pour zéro octet. Le MD5 d'une chaîne vide est d41d8cd98f00b204e9800998ecf8427e et son SHA-256 commence par e3b0c442. Cet outil masque simplement les résultats lorsque l'entrée est vide, afin que vous ne les copiez pas par erreur.

Peut-il hacher des fichiers de n'importe quelle taille ?

Cela dépend de la mémoire disponible du navigateur : les programmes d'installation et images disque de quelques centaines de Mo conviennent généralement. Les fichiers sont chargés en mémoire en une seule passe, donc pour des fichiers de plusieurs Go, préférez des outils en ligne de commande (sha256sum, certutil).

Pourquoi les hashes ont-ils des longueurs différentes ?

La longueur est déterminée par l'algorithme : MD5 fait 32 caractères hexadécimaux, SHA-1 40, SHA-256 64 et SHA-512 128. Deux caractères hexadécimaux par octet — et la longueur est indépendante de la taille de l'entrée : un fichier d'un octet et un fichier de plusieurs Go produisent tous deux 64 caractères avec SHA-256.

Puis-je l'utiliser pour générer des signatures d'API ?

Oui. De nombreuses plateformes ouvertes signent les requêtes en hachant « paramètres + secret » avec MD5 ou SHA-256. Cet outil est parfait pour vérifier une valeur de signature lors du débogage ; en production, calculez les hashes dans la bibliothèque côté serveur et n'incorporez jamais le secret dans le code frontend.

Comment comparer une somme de contrôle avec cet outil ?

Passez à l'onglet « Somme de contrôle de fichier », déposez le fichier, puis collez la somme de contrôle du site officiel dans la zone au-dessus des résultats. L'outil détecte automatiquement l'algorithme par sa longueur (32 caractères MD5, 40 SHA-1, 64 SHA-256, 96 SHA-384, 128 SHA-512) : la ligne correspondante devient verte avec une mention « Validé » lorsqu'elles concordent, et rouge sinon. La casse des lettres, les espaces environnants et les sauts de ligne sont automatiquement ignorés.

Outils associés

Autres outils d'encodage, cryptographie et mots de passe.

Encoder / Décodeur Base64

Convertir entre binaire et texte — pratique pour les Data URIs et le débogage de l'authentification HTTP basique.

Générateur de mots de passe

Générer des mots de passe aléatoires robustes — les mots de passe doivent être aléatoires et uniques, pas « chiffrés » avec un hash.

Vérificateur de robustesse de mot de passe

Vérifier si un mot de passe est suffisamment long et aléatoire, et s'il a déjà été divulgué lors de fuites de données.

Déposez un fichier ici, ou cliquez pour parcourir