Generatore Hash SHA-384

Cos'è l'Hashing SHA-384?

SHA-384 è una funzione hash crittografica definita nel NIST FIPS 180-4 come parte della famiglia SHA-2. Accetta un input di lunghezza arbitraria e produce un message digest fisso a 384 bit (48 byte), tipicamente visualizzato come stringa esadecimale di 96 caratteri. SHA-384 è ampiamente utilizzato nelle cipher suite TLS, nelle firme digitali dei certificati e nei sistemi governativi che richiedono un margine di resistenza alle collisioni superiore a quello offerto da SHA-256.

Internamente, SHA-384 è una variante troncata di SHA-512. Utilizza lo stesso block size a 1024 bit, 80 round di compressione e aritmetica a 64 bit di SHA-512, ma parte da un diverso insieme di valori hash iniziali (derivati dal 9° al 16° numero primo) e restituisce solo i primi 384 bit dello stato finale. Questa troncatura fa sì che SHA-384 produca un digest diverso da SHA-512 per input identici, pur condividendo lo stesso algoritmo di base.

Poiché SHA-384 opera su parole a 64 bit, risulta più veloce di SHA-256 sui moderni processori a 64 bit pur producendo un digest più grande. Questo lo rende un compromesso pratico: più robusto di SHA-256 (resistenza alle collisioni a 192 bit contro 128 bit) senza il costo in spazio dell'output esadecimale a 128 caratteri di SHA-512. SHA-384 è l'hash predefinito per le firme certificate verify in TLS 1.3 ed è richiesto da NSA Suite B (ora CNSA) per i dati TOP SECRET.

Perché Usare un Generatore SHA-384 Online?

Generare hash SHA-384 richiede di solito un comando da terminale o la scrittura di codice. Questo strumento basato su browser ti permette di calcolare digest SHA-384 istantaneamente senza installare nulla o inviare dati a un server. Che tu debba generare un hash SRI per una risorsa CDN, verificare un checksum di file o confrontare l'output SHA-384 con quello SHA-256 per lo stesso input, questo strumento offre un modo immediato e senza dipendenze per lavorare con i digest SHA-384 in qualsiasi browser moderno.

Casi d'Uso del Generatore Hash SHA-384

Confronto delle Varianti della Famiglia SHA-2

SHA-384 appartiene alla famiglia SHA-2 insieme a diverse altre varianti. La tabella seguente mostra le differenze in termini di dimensione del digest, lunghezza dell'output e applicazioni tipiche.

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

La scelta tra SHA-384 e altri algoritmi hash dipende dai requisiti di sicurezza, dai vincoli della piattaforma e dalle esigenze di prestazioni. Questo confronto copre le proprietà più rilevanti.

Come Funziona SHA-384 Internamente

SHA-384 elabora l'input attraverso la stessa costruzione di Merkle–Damgård di SHA-512. L'input viene completato fino a un multiplo di 1024 bit, suddiviso in blocchi, e ogni blocco viene processato attraverso 80 round di mixing usando le funzioni Ch, Maj e due funzioni Sigma con aritmetica a 64 bit. La differenza chiave rispetto a SHA-512 è nei valori hash iniziali: SHA-384 usa valori derivati dalle parti frazionarie delle radici quadrate del 9° al 16° numero primo, mentre SHA-512 usa i primi 8 numeri primi. Dopo l'elaborazione di tutti i blocchi, SHA-384 tronca lo stato interno a 512 bit ai suoi primi 384 bit.

La troncatura e la diversa inizializzazione fanno sì che SHA-384 e SHA-512 producano sempre digest diversi per lo stesso input. Questo rende anche SHA-384 intrinsecamente resistente agli attacchi di estensione della lunghezza, a differenza di SHA-256 e SHA-512 dove un attaccante può aggiungere dati e calcolare un hash valido senza conoscere il messaggio originale.

Esempi di Codice SHA-384

SHA-384 è supportato nativamente in tutti i principali linguaggi e runtime. Di seguito trovi esempi funzionanti che puoi copiare direttamente nei tuoi progetti.

// 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

Domande Frequenti