Générateur de Hash SHA-384

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

SHA-384 est une fonction de hachage cryptographique définie dans NIST FIPS 180-4, au sein de la famille SHA-2. Elle accepte une entrée de longueur quelconque et produit un condensat fixe de 384 bits (48 octets), affiché conventionnellement sous forme d'une chaîne hexadécimale de 96 caractères. SHA-384 est largement utilisé dans les suites de chiffrement TLS, les signatures de certificats numériques et les systèmes gouvernementaux qui requièrent une marge de résistance aux collisions supérieure à celle de SHA-256.

Internalement, SHA-384 est une variante tronquée de SHA-512. Il utilise la même taille de bloc de 1 024 bits, les mêmes 80 tours de compression et la même arithmétique sur des mots de 64 bits que SHA-512, mais démarre avec un ensemble différent de valeurs de hachage initiales (dérivées des 9e au 16e nombres premiers) et ne produit que les 384 premiers bits de l'état final. Cette troncature signifie que SHA-384 produit un condensat différent de SHA-512 pour des entrées identiques, bien qu'ils partagent le même algorithme de base.

Parce que SHA-384 opère sur des mots de 64 bits, il s'exécute plus rapidement que SHA-256 sur les processeurs 64 bits modernes tout en produisant un condensat plus grand. Il constitue ainsi un compromis pratique : plus solide que SHA-256 (résistance aux collisions de 192 bits contre 128 bits) sans la charge de stockage de la sortie hex à 128 caractères de SHA-512. SHA-384 est le hachage par défaut pour les signatures de vérification de certificats TLS 1.3 et est requis par la NSA Suite B (désormais CNSA) pour les données TRÈS SECRET.

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

Générer des hachages SHA-384 nécessite habituellement une commande en terminal ou l'écriture de code. Cet outil basé sur le navigateur vous permet de calculer des condensats SHA-384 instantanément sans rien installer ni envoyer de données à un serveur. Que vous ayez besoin de générer un hash SRI pour un fichier CDN, de vérifier une somme de contrôle ou de comparer la sortie SHA-384 avec SHA-256 pour la même entrée, cet outil vous offre un moyen immédiat et sans dépendance de travailler avec des condensats SHA-384 dans n'importe quel navigateur moderne.

Cas d'utilisation du Générateur de Hash SHA-384

Comparaison des variantes de la famille SHA-2

SHA-384 appartient à la famille SHA-2 aux côtés de plusieurs autres variantes. Le tableau ci-dessous montre comment elles diffèrent en termes de taille de condensat, de longueur de sortie et d'applications typiques.

SHA-384 vs SHA-256 vs SHA-512 vs SHA-3-384

Le choix entre SHA-384 et d'autres algorithmes de hachage dépend de vos exigences de sécurité, des contraintes de la plateforme et des besoins en performance. Cette comparaison couvre les propriétés les plus pertinentes.

Fonctionnement interne de SHA-384

SHA-384 traite l'entrée via la même construction de Merkle–Damgård que SHA-512. L'entrée est complétée jusqu'à un multiple de 1 024 bits, découpée en blocs, et chaque bloc est traité par 80 tours de mélange utilisant les fonctions Ch, Maj et deux fonctions Sigma avec une arithmétique sur des mots de 64 bits. La différence clé avec SHA-512 réside dans les valeurs de hachage initiales : SHA-384 utilise des valeurs dérivées des parties fractionnaires des racines carrées des 9e au 16e nombres premiers, tandis que SHA-512 utilise les 8 premiers. Une fois tous les blocs traités, SHA-384 tronque l'état interne de 512 bits à ses 384 premiers bits.

La troncature et l'initialisation différente signifient que SHA-384 et SHA-512 produisent toujours des condensats différents pour la même entrée. Cela rend également SHA-384 intrinsèquement résistant aux attaques par extension de longueur, contrairement à SHA-256 et SHA-512 où un attaquant peut ajouter des données et calculer un hash valide sans connaître le message original.

Exemples de code SHA-384

SHA-384 est pris en charge nativement dans tous les langages et environnements d'exécution majeurs. Voici des exemples fonctionnels que vous pouvez copier directement dans vos projets.

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

await sha384('hello world')
// → "fdbd8e75a67f29f701a4e040385e2e23986303ea10239211af907fcbb83578b3e417cb71ce646efd0819dd8c088de1bd"

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

import hashlib

# Basic SHA-384 hash
result = hashlib.sha384(b'hello world').hexdigest()
print(result)
# → "fdbd8e75a67f29f701a4e040385e2e23986303ea10239211af907fcbb83578b3e417cb71ce646efd0819dd8c088de1bd"

# Hash a string with Unicode characters
text = 'café ☕'
hashlib.sha384(text.encode('utf-8')).hexdigest()
# → 96-character hex string

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

package main

import (
    "crypto/sha512"
    "fmt"
)

func main() {
    data := []byte("hello world")
    // SHA-384 lives in the crypto/sha512 package
    hash := sha512.Sum384(data)
    fmt.Printf("%x\n", hash)
    // → fdbd8e75a67f29f701a4e040385e2e23986303ea10239211af907fcbb83578b3e417cb71ce646efd0819dd8c088de1bd
}

# Using sha384sum (Linux)
echo -n "hello world" | sha384sum
# → fdbd8e75a67f29f701a4e040385e2e23...  -

# macOS
echo -n "hello world" | shasum -a 384
# → fdbd8e75a67f29f701a4e040385e2e23...  -

# Using openssl (cross-platform)
echo -n "hello world" | openssl dgst -sha384
# → SHA2-384(stdin)= fdbd8e75a67f29f701a4e040385e2e23986303ea...

# Verify a file checksum
sha384sum myfile.bin > checksum.txt
sha384sum -c checksum.txt
# → myfile.bin: OK

Questions fréquentes