Générateur SHA-512 (SHA-2 512 bits)

Qu'est-ce que SHA-512 ?

// Hash text using Web Crypto API (SHA-512)
async function sha512(text) {
  const data = new TextEncoder().encode(text);
  const hash = await crypto.subtle.digest('SHA-512', data);
  return Array.from(new Uint8Array(hash))
    .map(b => b.toString(16).padStart(2, '0'))
    .join('');
}

await sha512('Hello, World!');
// → '374d794a95cdcfd8b35993185fef9ba368f160d8daf432d08ba9f1ed1e5abe6cc69291e0fa2fe0006a52570ef18c19def4e617c33ce52ef0a6e5fbe318cb0387'

Exemples SHA-512

PBKDF2-SHA-512 passphrase for disk encryption

Apple HFS+ catalog node data

NIST SP 800-57 Part 1 Rev 5 — Recommendation for Key Management

POST /api/v3/ledger
Content-Type: application/json
{"amount":500000,"from":"acct-A","to":"acct-B"}

Comment générer des hashes SHA-512

1. 1

   Collez du texte ou déposez un fichier

   Sélectionnez l'onglet Texte et collez n'importe quelle chaîne dans la zone de saisie — le hash SHA-512 de 128 caractères se met à jour au fil de la frappe. Pour les fichiers, passez à l'onglet Fichier et faites glisser n'importe quel fichier dans la zone de dépôt ; le navigateur le hache localement via la Web Crypto API sans envoi. Un indicateur de progression apparaît pour les fichiers volumineux (>10 Mo). Le sélecteur d'algorithme est déjà réglé sur SHA-512.

2. 2

   Copiez le hash de 128 caractères

   Cliquez sur le bouton Copier à côté de la sortie du hash. La chaîne hexadécimale complète en minuscules de 128 caractères va dans votre presse-papiers — prête à coller dans un fichier de configuration, un manifeste ou un appel API. Utilisez le bouton Majuscules si votre système cible requiert de l'hexadécimal en majuscules (par exemple certains outils Windows ou utilitaires de certificats).

3. 3

   Vérifiez avec l'onglet Comparer

   Passez à l'onglet Comparer et collez deux hashes SHA-512 côte à côte. L'outil signale la correspondance ou la non-correspondance en utilisant une comparaison en temps constant, sans divulguer d'informations de timing. Utile pour vérifier les sorties de dérivation de clés LUKS entre systèmes, vérifier les digests HMAC-SHA-512 ou confirmer les empreintes d'archives long terme par rapport à un manifeste stocké.

Détails techniques

Algorithme : blocs de 1024 bits, 80 tours, mots de 64 bits

SHA-512 traite l'entrée en blocs de 1024 bits (128 octets), appliquant 80 tours d'opérations binaires (fonctions Ch, Maj, Σ0, Σ1 utilisant des rotations et décalages 64 bits) avec des constantes dérivées des racines cubiques des 80 premiers nombres premiers. L'état interne est composé de huit mots de 64 bits (512 bits au total). C'est la même structure que SHA-384 — les seules différences entre SHA-384 et SHA-512 sont le vecteur d'initialisation et le fait que SHA-512 conserve les 512 bits entiers de sortie. Implémentation : FIPS 180-4 sections 4.2.3 et 6.4.

Sortie : 512 bits, 128 caractères hexadécimaux

Toujours exactement 128 caractères dans la plage [0-9a-f] (minuscules) ou [0-9A-F] (majuscules). La sortie est de longueur fixe quelle que soit la taille de l'entrée. À 512 bits, c'est la sortie la plus longue de la famille SHA-2, offrant 256 bits de résistance aux collisions — la recommandation standard pour les données devant rester infalsifiables au-delà de 2050.

Performance : plus rapide que SHA-256 sur le matériel 64 bits

Sur les CPU x86-64 et ARM64, SHA-512 traite des blocs de 1024 bits avec des opérations natives de 64 bits, offrant environ 600–1 000 Mo/s dans un navigateur (Web Crypto API) et 1–4 Go/s dans les outils natifs avec les extensions SHA matérielles. SHA-256 traite des blocs de 512 bits avec des opérations de 32 bits, produisant environ 400–700 Mo/s — plus lent malgré la plus petite taille de sortie. Sur le matériel 32 bits, la relation s'inverse : l'arithmétique 64 bits nécessite une émulation et SHA-256 est plus rapide.

Normes : FIPS 180-4, NIST SP 800-107, RFC 6234

Standardisé dans FIPS 180-2 (2001), version actuelle FIPS 180-4 (2015). Approuvé par le NIST pour tous les niveaux de sécurité jusqu'en 2030 et au-delà selon NIST SP 800-131A Rev 2. Référencé dans RFC 6234 (algorithmes SHA dans les protocoles IETF), RFC 5869 (HKDF) et RFC 2898 (PBKDF2). Conservé dans la suite CNSA pour la sécurité long terme ; NIST IR 8105 recommande SHA-512 pour les applications nécessitant des marges de sécurité post-quantiques.

Bonnes pratiques

Préférez SHA-512 quand une résistance aux collisions supérieure à 128 bits est requise

Pour la plupart des usages quotidiens — sommes de contrôle de fichiers, objets Git, signatures JWT, empreintes de certificats TLS — SHA-256 est la norme. Passez à SHA-512 quand : (1) les données doivent rester infalsifiables pendant 20+ ans, (2) un protocole spécifie une sécurité de 256 bits, ou (3) vous êtes sur du matériel 64 bits et l'avantage de performance de SHA-512 supprime tout obstacle à l'utilisation de l'option plus forte. Sur les serveurs et navigateurs modernes, la différence de performance favorise SHA-512, donc il y a rarement une raison de ne pas l'utiliser pour les nouvelles applications 64 bits.

Utilisez HMAC-SHA-512 pour l'authentification de messages à clé

Quand vous avez besoin d'un MAC à clé — authentification de requêtes API, signature de tokens, vérification d'intégrité de messages avec un secret partagé — utilisez HMAC-SHA-512 plutôt qu'une construction personnalisée. HMAC encapsule SHA-512 dans une construction éprouvée (RFC 2104) sécurisée même contre les attaques par extension de longueur et les faiblesses de clés liées. Évitez de concaténer directement une clé avec le message (HASH(clé || message)) — c'est vulnérable aux attaques par extension de longueur sur SHA-512 brut. Utilisez une bibliothèque HMAC bien testée : Node.js crypto.createHmac('sha512', key), Python hmac.new(key, msg, 'sha512'), ou crypto_auth_hmacsha512() de libsodium.

SHA-512/256 pour l'immunité contre l'extension de longueur avec la vitesse SHA-2

Si votre cas d'usage requiert l'immunité contre l'extension de longueur et la compatibilité avec les bibliothèques SHA-2 (pas SHA-3), envisagez SHA-512/256 (FIPS 180-4 section 5.3.6) plutôt que SHA-256 brut. SHA-512/256 utilise l'arithmétique rapide 64 bits de SHA-512 mais tronque la sortie à 256 bits avec un IV distinct, le rendant résistant à l'extension de longueur. Il est plus rapide que SHA-256 sur le matériel 64 bits et offre la même résistance aux collisions de 128 bits que SHA-256 avec une sécurité architecturale meilleure. Le caveat : le support de bibliothèques est moins universel que SHA-256 ou SHA-512 — vérifiez que votre runtime cible l'implémente avant de concevoir autour de lui.

Utilisez une comparaison en temps constant lors de la vérification de hashes SHA-512 dans le code

Lors de la comparaison de deux hashes SHA-512 dans du code, utilisez une fonction d'égalité en temps constant : Node.js crypto.timingSafeEqual(), Python hmac.compare_digest(), Go subtle.ConstantTimeCompare(). L'égalité de chaînes naïve (=== ou ==) divulgue des informations de timing — un attaquant effectuant de nombreuses requêtes peut reconstruire le hash attendu octet par octet en environ 1 024 comparaisons (128 caractères × 8 bits). C'est une défense en profondeur critique pour tout système d'authentification ou de vérification MAC. L'onglet Comparer de cet outil utilise déjà la comparaison en temps constant.

Questions fréquentes SHA-512