Generatore Hash SHA-256

Cos’è l’hashing SHA-256?

SHA-256 (Secure Hash Algorithm a 256 bit) è una funzione hash crittografica della famiglia SHA-2, pubblicata dal NIST nel 2001 nell’ambito di FIPS 180-2 (aggiornato in FIPS 180-4). Qualunque sia l’input — un singolo carattere, un file da diversi gigabyte o una stringa vuota — SHA-256 produce un digest fisso di 256 bit (32 byte), convenzionalmente rappresentato come 64 caratteri esadecimali. SHA-256 è la funzione hash più diffusa nei sistemi in produzione, alla base delle catene di certificati TLS, del proof-of-work di Bitcoin, della Subresource Integrity (SRI) e dei flussi di firma del codice.

SHA-256 è una funzione unidirezionale: calcolare un hash da un input è veloce (centinaia di megabyte al secondo su hardware moderno), ma invertire il processo — trovare un input che produca un determinato hash — è computazionalmente impraticabile. Questa proprietà, chiamata resistenza alla preimmagine, rende SHA-256 adatto all’hashing delle password (se combinato con un salt e uno stretching della chiave), alle firme digitali e alla verifica dell’integrità dei dati. A differenza di MD5 e SHA-1, nessun attacco di collisione o di preimmagine è stato dimostrato contro SHA-256 completo.

La famiglia SHA-2 comprende sei varianti: SHA-224, SHA-256, SHA-384, SHA-512, SHA-512/224 e SHA-512/256. SHA-256 opera su parole a 32 bit con 64 cicli per blocco, ottimizzato per processori a 32 bit. SHA-512 usa parole a 64 bit e 80 cicli, il che può risultare più veloce su piattaforme a 64 bit. Per la maggior parte delle applicazioni in cui un digest a 256 bit è sufficiente, SHA-256 rimane la raccomandazione predefinita di NIST, IETF e CA/Browser Forum.

Perché usare un generatore SHA-256 online?

Generare un hash SHA-256 di solito richiede un comando da terminale o qualche riga di codice. Questo strumento basato su browser ti permette di calcolare digest SHA-256 senza installare nulla, cambiare contesto o scrivere uno script.

Casi d’uso di SHA-256

Confronto tra le varianti della famiglia SHA-2

SHA-256 appartiene alla famiglia SHA-2 definita in FIPS 180-4. Ogni variante comporta un compromesso tra dimensione del digest, caratteristiche di prestazione e margine di sicurezza. La tabella seguente confronta tutte le varianti SHA-2 che è probabile incontrare.

SHA-256 vs SHA-1, MD5 e SHA-3

La scelta dell’algoritmo hash corretto dipende dai requisiti di sicurezza e dai vincoli di compatibilità. SHA-256 occupa il punto di equilibrio ideale: è sicuro, universalmente supportato (inclusa la Web Crypto API) e sufficientemente veloce per la maggior parte dei carichi di lavoro. La tabella di confronto seguente copre le proprietà più rilevanti nella scelta di una funzione hash.

Come funziona SHA-256 internamente

SHA-256 elabora l’input in blocchi da 512 bit (64 byte) tramite una costruzione di Merkle–Damgård. L’algoritmo inizializza otto parole di stato a 32 bit (H0–H7) derivate dalla parte frazionaria delle radici quadrate dei primi otto numeri primi. Ogni blocco passa attraverso 64 cicli di mescolamento che utilizzano operazioni bit a bit (AND, XOR, NOT, rotazione destra, scorrimento destra) e 64 costanti di ciclo derivate dalle radici cubiche dei primi 64 numeri primi.

L’effetto valanga garantisce che invertire un singolo bit nell’input modifichi circa il 50% dei bit di output. Questa proprietà, combinata con una resistenza alle collisioni di 2^128, è il motivo per cui SHA-256 rimane la raccomandazione di base per le applicazioni sensibili alla sicurezza nel 2026.

Esempi di codice SHA-256

SHA-256 è disponibile nativamente in ogni linguaggio e runtime principale. La Web Crypto API lo fornisce nei browser senza alcuna libreria. Gli esempi seguenti mostrano pattern di utilizzo reali, inclusa la gestione dell’input Unicode e l’hashing di file.

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

await sha256('hello world')
// → "b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9"

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

import hashlib

# Basic SHA-256 hash
result = hashlib.sha256(b'hello world').hexdigest()
print(result)  # → "b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9"

# Hash a string (encode to bytes first)
text = 'café ☕'
hashlib.sha256(text.encode('utf-8')).hexdigest()
# → "3eb53e00aa1bb4b1e8aab1ab38e56e6b8fb0b20e1cf7e1d19f36e4fad2537445"

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

package main

import (
    "crypto/sha256"
    "fmt"
)

func main() {
    data := []byte("hello world")
    hash := sha256.Sum256(data)
    fmt.Printf("%x\n", hash)
    // → b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9
}

# Using sha256sum (Linux) or shasum (macOS)
echo -n "hello world" | sha256sum
# → b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9  -

# macOS
echo -n "hello world" | shasum -a 256
# → b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9  -

# Verify a file checksum
echo "b94d27b...  myfile.bin" | sha256sum -c
# → myfile.bin: OK

# Using openssl (cross-platform)
echo -n "hello world" | openssl dgst -sha256
# → SHA2-256(stdin)= b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9

Domande frequenti