Generatore Hash SHA-1 (Legacy 160-bit)

Cos'è SHA-1?

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

await sha1('Hello, World!');
// → '0a0a9f2a6772942557ab5355d76af442f8f65e01'
// ⚠️ SHA-1 is broken — use SHA-256 for new work.

Esempi SHA-1

tree 4b825dc642cb6eb9a060e54bf8d69288fbee4904
author A Dev <dev@example.com> 1716854400 +0000
committer A Dev <dev@example.com> 1716854400 +0000

Initial commit

-----BEGIN CERTIFICATE-----
MIIDXTCCAkWgAwIBAgIJAKlL...
-----END CERTIFICATE-----

node-v0.12.7-linux-x64.tar.gz

(Incolla il contenuto del file shattered-1.pdf di Google/CWI tramite la scheda File)

Come Generare Hash SHA-1

1. 1

   Incolla testo o trascina un file

   Seleziona la scheda Testo e incolla qualsiasi stringa — un messaggio di commit, il corpo di un certificato o un input di checksum legacy — nel campo di input. L'hash SHA-1 si aggiorna mentre scrivi. Per i file, passa alla scheda File e trascina qualsiasi file nella zona di rilascio; il browser lo hashata localmente senza alcun upload.

2. 2

   Copia l'hash a 40 caratteri

   Clicca il pulsante Copia accanto all'output dell'hash. La stringa hex minuscola completa a 40 caratteri va negli appunti. Usa l'interruttore Maiuscolo se il tuo sistema legacy richiede hex maiuscolo — alcuni vecchi strumenti e API Windows usano il maiuscolo per default.

3. 3

   Confronta con un'impronta legacy

   Passa alla scheda Confronta e incolla due hash SHA-1 affiancati per confermare se corrispondono. Utile per validare un checksum di un distributore legacy, fare l'audit di un repository Git con mirroring o controllare un'impronta di vecchio certificato TLS da un documento che precede l'adozione di SHA-256.

Dettagli Tecnici

Algoritmo: costruzione Merkle-Damgård, 80 round

SHA-1 elabora l'input in blocchi da 512 bit (64 byte), applicando 80 round di operazioni bitwise raggruppati in quattro stadi da 20 round ciascuno, ognuno con una diversa funzione logica (Ch, Parity, Maj, Parity) e una costante additiva derivata dalle radici quadrate di interi piccoli. Lo stato hash iniziale è cinque parole da 32 bit (A–E), e l'hash finale è la concatenazione di quelle parole dopo l'ultimo blocco. Implementazione definita in FIPS 180-1 (1995), sostituita da FIPS 180-4 (2015) che include formalmente il linguaggio di deprecazione.

Output: 160 bit, 40 caratteri esadecimali

Sempre esattamente 40 caratteri esadecimali minuscoli (160 bit = 20 byte, codificati come 2 caratteri hex per byte). La lunghezza dell'output è fissa indipendentemente dalla dimensione dell'input. Rispetto ai 64 caratteri di SHA-256, l'output più corto fornisce meno bit di resistenza alle collisioni — un fattore chiave del perché SHA-1 è stato violato prima di SHA-256.

Prestazioni: veloce ma questo è parte del problema

SHA-1 è veloce — tipicamente 400–700 MB/s in un browser usando Web Crypto, competitivo con SHA-256. Per un attaccante, questa velocità è un vantaggio: un cluster GPU moderno può calcolare miliardi di hash SHA-1 al secondo, accelerando la ricerca di forza bruta e di collisioni. La velocità è il motivo per cui SHA-1 (come MD5) non deve mai essere usato per la memorizzazione delle password — usa invece bcrypt, scrypt o Argon2.

Standard: FIPS 180-1 (1995) — deprecato nel contesto FIPS 180-4

SHA-1 è stato standardizzato in FIPS 180-1 (1995), sostituendo il difettoso SHA-0. NIST ha deprecato SHA-1 per le firme digitali in NIST SP 800-131A (2011) e in FIPS 186-5 (2023) lo ha formalmente vietato per tutta la generazione di firme digitali. RFC 6194 (2011) ha documentato le considerazioni di sicurezza note. La W3C WebCrypto API include ancora SHA-1 per motivi di interoperabilità legacy, il che è come questo strumento browser può calcolarlo.

Best Practice

Non usare mai SHA-1 per operazioni sensibili alla sicurezza

SHA-1 è deprecato per firme digitali, certificati TLS, firma del codice, memorizzazione delle password e qualsiasi flusso di lavoro in cui conta la resistenza alle collisioni. L'attacco SHAttered del 2017 ha dimostrato collisioni pratiche. Per tutti gli usi di sicurezza, migra a SHA-256 o SHA-3. La differenza di costo è trascurabile sull'hardware moderno — SHA-256 è accelerato hardware in tutti i processori e le pipeline GPU attuali.

SHA-1 per la ricerca di impronte legacy è accettabile

Se devi verificare un checksum di file pre-2017, cercare un ID commit Git o ispezionare un'impronta di vecchio certificato a scopo di audit, SHA-1 è appropriato. L'hash stesso non viene usato per prendere una decisione di fiducia — stai solo riproducendo un'impronta nota per riferimento incrociato. Documenta questo esplicitamente nei tuoi log di audit: 'SHA-1 usato solo per riferimento legacy, non per validazione della sicurezza.'

Fai sempre l'hash dei byte UTF-8, non dei code point Unicode

SHA-1, come tutti gli algoritmi hash, opera su byte, non su caratteri. La stessa stringa codificata come UTF-8 vs UTF-16 produce hash diversi. Questo strumento codifica sempre l'input come UTF-8 senza BOM prima dell'hashing. Se devi corrispondere a un sistema che usa una codifica diversa (Windows UTF-16-LE, Latin-1), devi pre-codificare l'input esternamente prima di confrontare gli hash.

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

Se confronti due hash SHA-1 nel codice, usa un controllo di uguaglianza a tempo costante — Node.js crypto.timingSafeEqual(), Python hmac.compare_digest() — piuttosto che la banale uguaglianza di stringhe (=== o ==). Il confronto ingenuo perde informazioni di timing che possono teoricamente permettere a un attaccante di ricostruire l'hash atteso byte per byte.

Domande Frequenti SHA-1