Générateur de Hash SHA-1

Qu'est-ce que le hachage SHA-1 ?

SHA-1 (Secure Hash Algorithm 1) est une fonction de hachage cryptographique qui produit un condensat fixe de 160 bits (20 octets) à partir de n'importe quelle entrée. Publiée par la NSA et normalisée par le NIST en 1995 sous FIPS PUB 180-1, puis documentée dans la RFC 3174, SHA-1 a été conçue comme un successeur plus robuste de SHA-0 et MD5. L'algorithme traite l'entrée en blocs de 512 bits à travers 80 tours d'opérations bit à bit, produisant une empreinte hexadécimale de 40 caractères qui a constitué l'épine dorsale de SSL/TLS, PGP, SSH et IPsec pendant plus d'une décennie.

Comme toutes les fonctions de hachage cryptographiques, SHA-1 est une transformation à sens unique : calculer le condensat à partir d'une entrée est rapide, mais retrouver l'entrée à partir du seul condensat est computationnellement infaisable. Un changement d'un seul bit dans l'entrée produit un condensat 160 bits entièrement différent — propriété appelée effet avalanche. SHA-1 projette un espace d'entrée arbitrairement grand sur une sortie fixe de 160 bits, ce qui signifie que des collisions (deux entrées différentes produisant le même condensat) doivent exister mathématiquement. La garantie de sécurité d'une fonction de hachage est que trouver de telles collisions devrait nécessiter environ 2^80 opérations — la moitié de la longueur en bits de la sortie.

En 2017, Google et CWI Amsterdam ont publié l'attaque SHAttered, démontrant la première collision SHA-1 pratique en produisant deux fichiers PDF différents avec le même condensat. L'attaque a nécessité environ 2^63.1 calculs SHA-1 — bien en dessous de la borne théorique de 2^80. En 2020, Gaetan Leurent et Thomas Peyrin ont encore réduit ce coût avec une attaque par collision à préfixe choisi nécessitant environ 2^63.4 opérations. En conséquence, tous les grands navigateurs, autorités de certification et organismes de normalisation ont déprécié SHA-1 pour les signatures numériques et les certificats TLS. SHA-1 reste néanmoins utilisé pour des usages non sécuritaires : identifiants d'objets Git (bien que Git migre vers SHA-256), constructions HMAC héritées, et vérifications d'intégrité de fichiers où la résistance aux collisions adversariales n'est pas requise.

Pourquoi utiliser ce générateur SHA-1 ?

Générez des condensats SHA-1 instantanément sans rien installer ni écrire de code. Collez votre texte et obtenez le condensat hexadécimal de 40 caractères en temps réel — utile pour vérifier des sommes de contrôle héritées, déboguer les rouages de Git, ou tester des flux de travail basés sur le hachage.

Cas d'utilisation de SHA-1

SHA-1 vs autres algorithmes de hachage

SHA-1 produit un condensat de 160 bits — plus long que MD5 (128 bits) mais nettement plus court que les algorithmes de la famille SHA-2. Le tableau ci-dessous compare les tailles de condensat, les normes et les cas d'utilisation appropriés pour chaque algorithme.

Comment fonctionne SHA-1

SHA-1 suit la construction de Merkle-Damgard : le message est complété (padded), découpé en blocs de 512 bits, et chaque bloc est traité à travers 80 tours d'opérations bit à bit qui mélangent l'entrée avec un programme de messages dérivé du bloc. Cinq mots d'état de 32 bits (H0 à H4) transportent l'état de hachage en cours, et la concaténation finale de ces mots produit le condensat de 160 bits.

La différence clé entre SHA-1 et MD5 réside dans le nombre de mots d'état (5 vs. 4), le nombre de tours par bloc (80 vs. 64), et l'utilisation d'un programme de messages avec retour de rotation gauche. Ces différences donnent à SHA-1 une sortie plus grande (160 vs. 128 bits) et offraient initialement une marge de sécurité plus élevée, bien que les deux algorithmes soient désormais considérés comme compromis pour la résistance aux collisions.

Exemples de code

Comment générer des condensats SHA-1 dans les langages et environnements courants. Contrairement à MD5, SHA-1 est disponible dans la Web Crypto API du navigateur, ce qui le rend utilisable sans bibliothèques externes aussi bien dans le navigateur que dans Node.js.

// SHA-1 is available in the Web Crypto API
async function sha1(text) {
  const data = new TextEncoder().encode(text)
  const hashBuffer = await crypto.subtle.digest('SHA-1', data)
  const hashArray = Array.from(new Uint8Array(hashBuffer))
  return hashArray.map(b => b.toString(16).padStart(2, '0')).join('')
}

await sha1('hello world')
// → "2aae6c35c94fcfb415dbe95f408b9ce91ee846ed"

// Node.js (built-in crypto module)
const crypto = require('crypto')
crypto.createHash('sha1').update('hello world').digest('hex')
// → "2aae6c35c94fcfb415dbe95f408b9ce91ee846ed"

import hashlib

# Basic SHA-1 hash
result = hashlib.sha1(b'hello world').hexdigest()
print(result)  # → "2aae6c35c94fcfb415dbe95f408b9ce91ee846ed"

# Hash a string (encode to bytes first)
text = 'hello world'
hashlib.sha1(text.encode('utf-8')).hexdigest()
# → "2aae6c35c94fcfb415dbe95f408b9ce91ee846ed"

# Hash a file in chunks
with open('file.bin', 'rb') as f:
    sha1 = hashlib.sha1()
    for chunk in iter(lambda: f.read(8192), b''):
        sha1.update(chunk)
    print(sha1.hexdigest())

package main

import (
    "crypto/sha1"
    "fmt"
)

func main() {
    data := []byte("hello world")
    hash := sha1.Sum(data)
    fmt.Printf("%x\n", hash)
    // → 2aae6c35c94fcfb415dbe95f408b9ce91ee846ed
}

# Using sha1sum (Linux) or shasum (macOS)
echo -n "hello world" | sha1sum
# → 2aae6c35c94fcfb415dbe95f408b9ce91ee846ed  -

# macOS
echo -n "hello world" | shasum -a 1
# → 2aae6c35c94fcfb415dbe95f408b9ce91ee846ed  -

# Hash a file
sha1sum package.json
# → a1b2c3d4e5f6...  package.json

# Using openssl (cross-platform)
echo -n "hello world" | openssl sha1
# → SHA1(stdin)= 2aae6c35c94fcfb415dbe95f408b9ce91ee846ed

Questions fréquentes