Outil générateur de hash en ligne

Les hash résument des données pour détecter les modifications, vérifier des téléchargements et servir de brique dans des protocoles plus larges.

Générez des hachages MD5, SHA-1, SHA-256 et plus à partir de votre texte — instantanément dans votre appareil.

Avantages

• Intégrité : Comparez les digests pour repérer les altérations.
• Mots de passe : Utilisez salage + KDF ; n’exposez pas MD5 seul.
• Signatures : Beaucoup de schémas signent le hash du message.
• Checksums : Vérification rapide d’artefacts.
• Empreintes : Identifiants compacts pour cache et dédup.

Chaque fonction produit une sortie de longueur fixe ; la résistance aux collisions détermine l’usage sécurisé.

Algorithmes proposés

• MD5 : 128 bits ; rapide et très répandu, mais sans résistance aux collisions pour un usage de sécurité.
• SHA-1 : 160 bits ; déconseillé pour tout nouvel usage de sécurité, encore présent dans d'anciennes sommes et dans les identifiants Git.
• SHA-256 : 256 bits, famille SHA-2 ; la valeur par défaut courante aujourd'hui pour l'intégrité et les signatures.
• SHA-384 : état interne de 512 bits tronqué à 384 ; prévu par plusieurs suites TLS et profils de certificats.
• SHA-512 : 512 bits ; état plus large, utile pour une empreinte plus longue ou certaines performances.
• SHA3-256 : 256 bits sur l'éponge Keccak, une construction totalement différente de SHA-2 : casser l'une n'implique pas casser l'autre.
• SHA3-512 : 512 bits d'éponge ; l'empreinte la plus large ici, et la plus lente, car elle n'absorbe que 72 octets par permutation.
• CRC-32 : une somme de 32 bits, pas une empreinte cryptographique. Elle détecte la corruption accidentelle et c'est ce qu'enregistrent les archives ZIP, les blocs PNG et gzip.

Comment choisir

La réponse est le plus souvent imposée par ce avec quoi vous devez interopérer. Sinon, la liste est courte.

• Pour vérifier un téléchargement, utilisez l'algorithme publié par l'éditeur. Un autre ne prouve rien, aussi robuste soit-il.
• Pour un nouveau projet, SHA-256 est la valeur par défaut que tous les langages et outils possèdent déjà.
• Utilisez SHA-512 pour une empreinte plus large, ou sur du matériel 64 bits où il est souvent plus rapide que SHA-256.
• Utilisez SHA3-256 quand vous voulez une construction sans lien avec SHA-2, par exemple si une norme impose la diversité d'algorithmes.
• N'utilisez CRC-32 que pour la corruption accidentelle. Il est trivial à falsifier et n'a jamais visé à résister à un attaquant.
• Ne choisissez jamais MD5 ni SHA-1 pour du neuf. Ils sont là parce que des systèmes réels en émettent encore, pas parce qu'ils sont sûrs.

Produit des digests sans envoyer vos données.

1. Saisir le texte — Saisissez ou collez ; les hash se mettent à jour automatiquement.
2. Choisir l’algorithme — Affichez tout ou filtrez MD5, SHA-1, SHA-256, SHA-512.
3. Copier — Cliquez sur Copier à côté du digest. Les données restent sur l’appareil.

C'est la raison la plus fréquente pour laquelle une somme de contrôle « ne correspond pas » alors que tout va bien. Une empreinte porte sur des octets, et un même document peut être plusieurs suites d'octets différentes.

• Fins de ligne : un fichier texte enregistré sous Windows termine chaque ligne par CRLF, et par LF sous macOS ou Linux. Ce sont des octets différents, donc des empreintes différentes, même si le fichier paraît identique.
• Marques d'ordre des octets : un fichier UTF-8 enregistré « avec BOM » commence par trois octets invisibles qui changent complètement l'empreinte.
• Saut de ligne final : la plupart des éditeurs en ajoutent un à l'enregistrement. Coller le contenu visible dans un champ, non.
• Encodage : le texte saisi ici est haché en UTF-8. Un fichier en UTF-16 ou dans une page de code ancienne contient d'autres octets pour les mêmes caractères.

La règle qui en découle est simple : pour vérifier quelque chose, hachez le fichier lui-même plutôt que son contenu collé dans un champ. Le mode texte sert aux chaînes que vous hachez volontairement.

Publier une somme à côté d'un téléchargement permet à chacun de confirmer que les octets reçus sont ceux qui ont été publiés. C'est la raison la plus courante d'ouvrir un outil de hachage, et cela tient en quatre étapes.

1. Déposez le fichier téléchargé et lancez le calcul. Le fichier est lu sur votre appareil ; rien n'est envoyé, ce qui compte car vous n'avez peut-être pas le droit de le partager.
2. Copiez la somme depuis la page de l'éditeur ou son fichier de signatures.
3. Collez-la dans le champ de vérification. L'algorithme est déduit de la longueur collée : inutile de savoir s'il s'agit de SHA-256 ou de MD5 — et lorsqu'une longueur est ambiguë, comme les 64 caractères communs à SHA-256 et SHA3-256, les deux sont vérifiés.
4. Lisez le verdict. Une correspondance signifie que le fichier est octet pour octet celui qui a été publié. Sinon, refaites le téléchargement depuis une source de confiance.

Une somme affichée sur la même page que le téléchargement protège d'un transfert corrompu, pas d'un site compromis : qui peut modifier le fichier peut modifier le nombre à côté. Pour cela il faut une signature.

Une empreinte simple prouve que les données n'ont pas changé, pas qui les a produites, puisque n'importe qui peut la calculer. HMAC comble cet écart en mêlant une clé secrète : seul celui qui la détient peut produire ou vérifier la valeur.

• Signatures de webhooks : les services signent chaque envoi pour que votre point de terminaison rejette ce qui ne vient pas d'eux. Presque tous utilisent HMAC-SHA-256.
• Signature de requêtes d'API : une chaîne canonique est hachée avec un secret partagé et envoyée dans un en-tête.
• Authentification de messages : une valeur conservée à côté des données pour détecter toute altération par qui n'a pas la clé.

Une clé n'est pas toujours du texte. Un secret est souvent publié en hexadécimal ou en Base64, et saisir ces caractères comme du texte utiliserait de mauvais octets et donnerait une valeur qui ne correspond jamais. D'où la question sur l'encodage de la clé, et la prise en charge d'UTF-8, hex et Base64. CRC-32 n'accepte pas de clé et est écarté automatiquement.

Un hash n’est pas du chiffrement : il ne cache pas le message.

Propriétés

• Taille de sortie fixe par algorithme.
• Même entrée → même hash.
• Petit changement → digest totalement différent.
• Fonction à sens pratique unique.
• SHA-256/512 pour résistance aux collisions.

Bonnes pratiques

Adaptez l’algorithme au niveau de menace.

• Préférer SHA-256 ou SHA-512 pour du neuf.
• Éviter MD5/SHA-1 seuls pour mots de passe.
• Comparaison en temps constant côté appli si possible.
• Protéger les digests stockés.
• Ne pas confondre encodage et confidentialité.

Cas d’usage

• Identifiants : KDF modernes pour les secrets utilisateur.
• Téléchargements : Confronter au checksum publié.
• API : Empreintes pour idempotence.
• Config : Détecter les dérives de fichier.
• Chaînes : Démo locale de la primitive seulement.

Le hachage parcourt chaque octet de façon strictement séquentielle. Les seules façons honnêtes de l'accélérer sont donc de lire le fichier une fois au lieu d'une fois par algorithme, d'utiliser l'accélération matérielle de l'appareil là où elle existe, et de faire tourner en parallèle les algorithmes qui ne peuvent pas en profiter. Cet outil fait les trois.

• Une seule lecture du fichier : choisir quatre algorithmes lit le fichier une fois, pas quatre. Ajouter un algorithme ne coûte presque rien en lecture.
• Accélération matérielle là où elle existe : les familles SHA-1 et SHA-2 passent par l'implémentation accélérée de votre appareil, qui est plusieurs fois plus rapide que le même travail fait en logiciel.
• Travail parallèle pour le reste : MD5, SHA-3 et CRC-32 n'ont de voie accélérée nulle part ; ils tournent donc côte à côte en parallèle plutôt que l'un après l'autre. L'attente est celle de l'algorithme le plus lent, pas la somme de tous.
• En flux, sans tout charger : le fichier est lu par morceaux : une image disque de plusieurs gigaoctets n'a pas à tenir en mémoire et la page reste réactive.
• Une annulation qui arrête vraiment : Annuler met fin au travail immédiatement, au lieu de lever un drapeau que personne ne lit.

En pratique, les quatre algorithmes par défaut sur un fichier de 100 Mo se terminent en une demi-seconde environ sur un ordinateur récent, et le plus long instant où la page est occupée dure environ trois millisecondes — d'où l'absence de saccade dans le champ de texte.

Tout ce qui décide si la réponse est JUSTE est gratuit. Pro achète l'échelle, c'est-à-dire la part qui coûte du temps réel à votre appareil.

Gratuit

• Les huit algorithmes, sans restriction sur ceux que vous pouvez choisir.
• Du texte de n'importe quelle longueur jusqu'à 5 Mo, et un fichier à la fois jusqu'à 250 Mo.
• Des clés HMAC en UTF-8, hexadécimal ou Base64.
• Sortie en hexadécimal minuscule, HEXADÉCIMAL majuscule ou Base64.
• Vérification de somme avec détection automatique de l'algorithme.
• Copie de n'importe quelle empreinte et téléchargement des résultats d'un calcul.

Pro

• Mettez jusqu'à 100 fichiers dans une même série.
• Aucune limite de taille imposée : le plafond est ce que votre appareil supporte.
• Exportez un fichier de sommes au format coreutils que sha256sum -c lit directement.
• Exportez un manifeste CSV avec une ligne par fichier et une colonne par algorithme.
• Téléchargez tout le lot dans une seule archive.

• Générateur MD5
• Générateur SHA-256
• Générateur SHA-1
• Encodeur/décodeur Base64
• Tous les convertisseurs