Générateur de Hash SHA-256

Qu’est-ce que le hachage SHA-256 ?

SHA-256 (Secure Hash Algorithm 256 bits) est une fonction de hachage cryptographique de la famille SHA-2, publiée par le NIST en 2001 dans le cadre de FIPS 180-2 (mise à jour dans FIPS 180-4). Quelle que soit l’entrée — un seul caractère, un fichier de plusieurs gigaoctets ou une chaîne vide — SHA-256 produit un condensat fixe de 256 bits (32 octets), affiché conventionnellement sous forme de 64 caractères hexadécimaux. SHA-256 est aujourd’hui la fonction de hachage la plus largement déployée en production : elle est au cœur des chaînes de certificats TLS, de la preuve de travail de Bitcoin, de la Subresource Integrity (SRI) et des workflows de signature de code.

SHA-256 est une fonction à sens unique : calculer un condensat à partir d’une entrée est rapide (plusieurs centaines de mégaoctets par seconde sur du matériel moderne), mais inverser le processus — trouver une entrée produisant un condensat donné — est informatiquement impossible. Cette propriété, appelée résistance à la préimage, rend SHA-256 adapté au hachage de mots de passe (combiné avec un sel et un étirement de clé), aux signatures numériques et à la vérification d’intégrité des données. Contrairement à MD5 et SHA-1, aucune attaque par collision ou préimage n’a été démontrée contre SHA-256 complet.

La famille SHA-2 comprend six variantes : SHA-224, SHA-256, SHA-384, SHA-512, SHA-512/224 et SHA-512/256. SHA-256 opère sur des mots de 32 bits avec 64 tours par bloc, optimisé pour les processeurs 32 bits. SHA-512 utilise des mots de 64 bits et 80 tours, ce qui peut être plus rapide sur les plateformes 64 bits. Pour la plupart des applications où un condensat de 256 bits est suffisant, SHA-256 reste la recommandation par défaut du NIST, de l’IETF et du CA/Browser Forum.

Pourquoi utiliser un générateur SHA-256 en ligne ?

Calculer un condensat SHA-256 nécessite habituellement une commande en terminal ou quelques lignes de code. Cet outil basé sur le navigateur vous permet de calculer des condensats SHA-256 sans rien installer, sans changer de contexte et sans écrire de script.

Cas d’utilisation de SHA-256

Comparaison des variantes de la famille SHA-2

SHA-256 appartient à la famille SHA-2 définie dans FIPS 180-4. Chaque variante fait des compromis entre la taille du condensat, les caractéristiques de performance et la marge de sécurité. Le tableau ci-dessous compare toutes les variantes SHA-2 que vous êtes susceptible de rencontrer.

SHA-256 vs SHA-1, MD5 et SHA-3

Le choix du bon algorithme de hachage dépend de vos exigences de sécurité et de vos contraintes de compatibilité. SHA-256 occupe la position idéale en pratique : il est sécurisé, universellement pris en charge (y compris par l’API Web Crypto) et suffisamment rapide pour la plupart des charges de travail. Le tableau comparatif ci-dessous couvre les propriétés les plus importantes pour choisir une fonction de hachage.

Fonctionnement interne de SHA-256

SHA-256 traite les données en blocs de 512 bits (64 octets) via une construction de Merkle–Damgård. L’algorithme initialise huit mots d’état de 32 bits (H0–H7) dérivés des parties fractionnaires des racines carrées des huit premiers nombres premiers. Chaque bloc passe par 64 tours de mélange utilisant des opérations sur les bits (AND, XOR, NOT, rotation droite, décalage droite) et 64 constantes de tour dérivées des racines cubiques des 64 premiers nombres premiers.

L’effet avalanche garantit que le changement d’un seul bit en entrée modifie environ 50 % des bits en sortie. Cette propriété, combinée à une résistance aux collisions de 2^128, explique pourquoi SHA-256 reste la recommandation de référence pour les applications sensibles à la sécurité en 2026.

Exemples de code SHA-256

SHA-256 est disponible nativement dans tous les langages et environnements d’exécution majeurs. L’API Web Crypto le fournit dans les navigateurs sans aucune bibliothèque. Les exemples ci-dessous illustrent des patterns d’utilisation réels, notamment la gestion des entrées Unicode et le hachage de fichiers.

// Works in all modern browsers and Node.js 18+
async function sha256(text) {
  const data = new TextEncoder().encode(text)
  const hashBuffer = await crypto.subtle.digest('SHA-256', data)
  const hashArray = Array.from(new Uint8Array(hashBuffer))
  return hashArray.map(b => b.toString(16).padStart(2, '0')).join('')
}

await sha256('hello world')
// → "b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9"

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

import hashlib

# Basic SHA-256 hash
result = hashlib.sha256(b'hello world').hexdigest()
print(result)  # → "b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9"

# Hash a string (encode to bytes first)
text = 'café ☕'
hashlib.sha256(text.encode('utf-8')).hexdigest()
# → "3eb53e00aa1bb4b1e8aab1ab38e56e6b8fb0b20e1cf7e1d19f36e4fad2537445"

# Hash a file in chunks (memory-efficient)
with open('release.tar.gz', 'rb') as f:
    sha = hashlib.sha256()
    for chunk in iter(lambda: f.read(8192), b''):
        sha.update(chunk)
    print(sha.hexdigest())

package main

import (
    "crypto/sha256"
    "fmt"
)

func main() {
    data := []byte("hello world")
    hash := sha256.Sum256(data)
    fmt.Printf("%x\n", hash)
    // → b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9
}

# Using sha256sum (Linux) or shasum (macOS)
echo -n "hello world" | sha256sum
# → b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9  -

# macOS
echo -n "hello world" | shasum -a 256
# → b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9  -

# Verify a file checksum
echo "b94d27b...  myfile.bin" | sha256sum -c
# → myfile.bin: OK

# Using openssl (cross-platform)
echo -n "hello world" | openssl dgst -sha256
# → SHA2-256(stdin)= b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9

Questions fréquentes