Generatore Hash SHA-512 (SHA-2 a 512 bit)

Cos'è 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'

Esempi 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"}

Come Generare Hash SHA-512

1. 1

   Incolla testo o trascina un file

   Seleziona la scheda Testo e incolla qualsiasi stringa nel campo di input — l'hash SHA-512 a 128 caratteri si aggiorna mentre scrivi. Per i file, passa alla scheda File e trascina qualsiasi file nella zona di rilascio; il browser lo hashata localmente usando la Web Crypto API senza upload. Un indicatore di progresso appare per i file grandi (>10 MB). Il selettore dell'algoritmo è già impostato su SHA-512.

2. 2

   Copia l'hash a 128 caratteri

   Clicca il pulsante Copia accanto all'output dell'hash. La stringa hex minuscola completa a 128 caratteri va negli appunti — pronta da incollare in un file di configurazione, manifesto o chiamata API. Usa l'interruttore Maiuscolo se il tuo sistema di destinazione richiede hex maiuscolo (ad es. alcuni strumenti Windows o utilità di certificati).

3. 3

   Verifica con la scheda Confronta

   Passa alla scheda Confronta e incolla due hash SHA-512 affiancati. Lo strumento riporta corrispondenza o mancata corrispondenza usando il confronto a tempo costante, che non perde informazioni di timing. Utile per verificare gli output di derivazione delle chiavi LUKS tra i sistemi, controllare i digest HMAC-SHA-512 o confermare le impronte degli archivi a lungo termine rispetto a un manifesto memorizzato.

Dettagli Tecnici

Algoritmo: blocchi da 1024 bit, 80 round, parole da 64 bit

SHA-512 elabora l'input in blocchi da 1024 bit (128 byte), applicando 80 round di operazioni bitwise (funzioni Ch, Maj, Σ0, Σ1 usando rotazioni e shift a 64 bit) con costanti derivate dalle radici cubiche dei primi 80 numeri primi. Lo stato interno consiste in otto parole da 64 bit (512 bit in totale). Questa è la stessa struttura di SHA-384 — le sole differenze tra SHA-384 e SHA-512 sono il vettore di inizializzazione e il fatto che SHA-512 mantiene tutti i 512 bit dell'output. Implementazione: FIPS 180-4 sezioni 4.2.3 e 6.4.

Output: 512 bit, 128 caratteri esadecimali

Sempre esattamente 128 caratteri nell'intervallo [0-9a-f] (minuscolo) o [0-9A-F] (maiuscolo). L'output è di lunghezza fissa indipendentemente dalla dimensione dell'input. A 512 bit, questo è l'output più lungo della famiglia SHA-2, fornendo 256 bit di resistenza alle collisioni — la raccomandazione standard per i dati che devono rimanere evidenti alle manomissioni oltre il 2050.

Prestazioni: più veloce di SHA-256 sull'hardware a 64 bit

Sui processori x86-64 e ARM64, SHA-512 elabora blocchi da 1024 bit con operazioni native a 64 bit, offrendo circa 600–1.000 MB/s in un browser (Web Crypto API) e 1–4 GB/s negli strumenti nativi con estensioni SHA hardware. SHA-256 elabora blocchi da 512 bit con operazioni a 32 bit, producendo circa 400–700 MB/s — più lento nonostante la dimensione dell'output più piccola. Sull'hardware a 32 bit il rapporto si inverte: l'aritmetica a 64 bit richiede emulazione e SHA-256 è più veloce.

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

Standardizzato in FIPS 180-2 (2001), versione attuale FIPS 180-4 (2015). Approvato da NIST per tutti i livelli di forza di sicurezza fino al 2030 e oltre ai sensi di NIST SP 800-131A Rev 2. Citato in RFC 6234 (algoritmi SHA nei protocolli IETF), RFC 5869 (HKDF) e RFC 2898 (PBKDF2). Mantenuto nella CNSA Suite per la sicurezza a lungo termine; NIST IR 8105 raccomanda SHA-512 per le applicazioni che richiedono margini di sicurezza post-quantistici.

Best Practice

Preferisci SHA-512 quando è richiesta una resistenza alle collisioni oltre 128 bit

Per la maggior parte degli usi quotidiani — checksum file, oggetti Git, firme JWT, impronte di certificati TLS — SHA-256 è lo standard. Aggiorna a SHA-512 quando: (1) i dati devono rimanere evidenti alle manomissioni per 20+ anni, (2) un protocollo specifica una forza di sicurezza a 256 bit, o (3) sei sull'hardware a 64 bit e il vantaggio di prestazioni di SHA-512 rimuove qualsiasi barriera all'uso dell'opzione più forte. Sui server e browser moderni la differenza di prestazioni favorisce SHA-512, quindi raramente c'è un motivo per non usarlo per le nuove applicazioni a 64 bit.

Usa HMAC-SHA-512 per l'autenticazione dei messaggi con chiave

Quando hai bisogno di un MAC con chiave — autenticando richieste API, firmando token o verificando l'integrità dei messaggi con un segreto condiviso — usa HMAC-SHA-512 piuttosto che una costruzione personalizzata. HMAC avvolge SHA-512 in una costruzione comprovata (RFC 2104) che è sicura anche contro gli attacchi di estensione di lunghezza e le debolezze delle chiavi correlate. Evita di concatenare direttamente una chiave con il messaggio (HASH(chiave || messaggio)) — questo è vulnerabile agli attacchi di estensione di lunghezza su SHA-512 grezzo.

SHA-512/256 per immunità alle estensioni di lunghezza con la velocità SHA-2

Se il tuo caso d'uso richiede immunità alle estensioni di lunghezza e compatibilità libreria SHA-2 (non SHA-3), considera SHA-512/256 (FIPS 180-4 sezione 5.3.6) invece di SHA-256 grezzo. SHA-512/256 usa l'aritmetica veloce a 64 bit di SHA-512 ma tronca l'output a 256 bit con un IV distinto, rendendolo resistente alle estensioni di lunghezza. È più veloce di SHA-256 sull'hardware a 64 bit e fornisce la stessa resistenza alle collisioni a 128 bit di SHA-256 con una migliore sicurezza architettonica. La messa in guardia: il supporto librario è meno universale di SHA-256 o SHA-512 — verifica che il tuo runtime di destinazione lo implementi prima di progettare attorno ad esso.

Usa il confronto a tempo costante quando verifichi gli hash SHA-512 nel codice

Quando confronti due hash SHA-512 nel codice, usa una funzione di uguaglianza a tempo costante: Node.js crypto.timingSafeEqual(), Python hmac.compare_digest(), Go subtle.ConstantTimeCompare(). L'uguaglianza di stringhe ingenua (=== o ==) perde informazioni di timing — un attaccante che fa molte richieste può ricostruire l'hash atteso byte per byte in circa 1.024 confronti (128 caratteri × 8 bit). Questa è una difesa in profondità critica per qualsiasi sistema di autenticazione o verifica MAC. La scheda Confronta di questo strumento usa già il confronto a tempo costante.

Domande Frequenti SHA-512