Proteggi le credenziali con hashing sicuro come Argon2
Argon2id, salt per utente e architettura split-salt: come rendere il furto di credenziali economicamente inutile per un attaccante.
Risposta rapida
Per proteggere le credenziali degli utenti con un algoritmo di hashing sicuro come Argon2 devi memorizzare non la password ma il suo hash, calcolato con Argon2id — la variante raccomandata da OWASP — usando un salt univoco per utente e parametri di costo (memoria, iterazioni, parallelismo) tarati per rendere il brute-force economicamente insostenibile. Argon2 è memory-hard: costringe l'attaccante a impiegare grandi quantità di memoria, neutralizzando gli attacchi massivi con GPU e ASIC che affliggono algoritmi più vecchi. LoginMaster protegge le credenziali con Argon2 e uno schema split-salt che distribuisce i componenti crittografici tra più entità: nessun singolo componente — nemmeno il fornitore — possiede le informazioni per ricostruire la credenziale originale.
I principi che contano
Memory-hard by design
Argon2 richiede molta memoria per ogni calcolo di hash. Questo rende inefficaci gli attacchi paralleli su GPU e ASIC, che eccellono nel calcolo ma sono limitati dalla memoria disponibile.
Argon2id: la variante raccomandata
Argon2id combina la resistenza agli attacchi side-channel di Argon2i con la resistenza al cracking su GPU di Argon2d. È la prima scelta indicata da OWASP per lo storage delle password.
Salt univoco per utente
Ogni credenziale usa un salt diverso: due utenti con la stessa password producono hash diversi. Questo annulla le rainbow table e impedisce di attaccare più account con un unico sforzo.
Split-salt: nessun punto singolo
LoginMaster va oltre il salt classico: i componenti crittografici sono separati tra più entità (Tenant e Cloud). Una violazione di un solo archivio non fornisce abbastanza informazioni per ricostruire le credenziali.
Argon2 vs altri algoritmi
Quale algoritmo di hashing scegliere per le password, in una tabella.
| Algoritmo | Memory-hard | Resistenza GPU/ASIC | Raccomandazione |
|---|---|---|---|
| Argon2id | Sì | Alta | OWASP: prima scelta |
| scrypt | Sì | Media-alta | Buona alternativa |
| bcrypt | No (memoria fissa limitata) | Media | Accettabile, ormai legacy |
| PBKDF2 | No | Bassa | Solo se richiesto (es. FIPS) |
| MD5 / SHA-1 / SHA-256 (semplice) | No | Nessuna | Mai per le password |
Parametri di configurazione di Argon2id
Argon2id si tara con tre parametri di costo: memoria (m), iterazioni (t) e parallelismo (p). OWASP documenta cinque configurazioni equivalenti per robustezza: si sceglie quella compatibile con la memoria disponibile sul proprio hardware.
| Memoria (m) | Iterazioni (t) | Parallelismo (p) |
|---|---|---|
| 47104 KiB (46 MiB) | 1 | 1 |
| 19456 KiB (19 MiB) | 2 | 1 |
| 12288 KiB (12 MiB) | 3 | 1 |
| 9216 KiB (9 MiB) | 4 | 1 |
| 7168 KiB (7 MiB) | 5 | 1 |
Configurazioni indicate dalla OWASP Password Storage Cheat Sheet per Argon2id.
Memoria (m): è il parametro che dà ad Argon2 la sua resistenza. Più memoria richiedi per singolo hash, meno hash in parallelo può calcolare una GPU. È la prima leva da alzare.
Iterazioni (t): il numero di passate sulla memoria. Si alza per compensare quando la memoria disponibile è poca — è il compromesso alla base delle configurazioni equivalenti qui sopra.
Parallelismo (p): quanti thread usa il calcolo. Va allineato ai core che vuoi dedicare all'autenticazione, tenendo conto dei picchi di login concorrenti.
Salt e lunghezza dell'hash: salt casuale di almeno 16 byte, univoco per utente e mai riutilizzato; hash in uscita di 32 byte.
Regola pratica di taratura: scegli i parametri più alti che mantengono la verifica entro circa 0,5-1 secondo sull'hardware di produzione, e rimisurala a ogni cambio di infrastruttura.
Argon2id in codice: hash e verifica
Come si calcola e si verifica un hash Argon2id in TypeScript e in .NET, con i parametri della prima riga della tabella.
TypeScript / Node.js
import argon2 from "argon2";
// Configurazione Argon2id (OWASP: m=47104 KiB, t=1, p=1)
const OPTIONS = {
type: argon2.argon2id,
memoryCost: 47104, // KiB
timeCost: 1, // iterazioni
parallelism: 1, // thread
hashLength: 32, // byte
// il salt (16 byte casuali) è generato e incorporato automaticamente
};
export async function hashPassword(password: string): Promise<string> {
return argon2.hash(password, OPTIONS);
}
export async function verifyPassword(hash: string, password: string) {
// confronto a tempo costante; i parametri sono letti dall'hash stesso
return argon2.verify(hash, password);
}.NET / C#
using System.Security.Cryptography;
using Konscious.Security.Cryptography;
byte[] salt = RandomNumberGenerator.GetBytes(16);
using var argon2 = new Argon2id(Encoding.UTF8.GetBytes(password))
{
Salt = salt,
MemorySize = 47104, // KiB
Iterations = 1,
DegreeOfParallelism = 1,
};
byte[] hash = argon2.GetBytes(32);Il formato dell'hash codificato
Argon2 restituisce una stringa che incorpora variante, versione, parametri di costo, salt e hash. È il motivo per cui la verifica non ha bisogno di conoscere in anticipo i parametri: li rilegge dall'hash stesso, e questo permette di alzare i costi nel tempo senza invalidare le credenziali già memorizzate.
$argon2id$v=19$m=47104,t=1,p=1$c29tZXNhbHR2YWx1ZQ$RdescudvJCsgt3ub+b+dWRWJTmaaJObGDelegando l'autenticazione a LoginMaster non devi mantenere tu questo codice: hashing Argon2, gestione dei salt, taratura dei parametri e rotazione degli algoritmi sono a carico della piattaforma, con lo schema split-salt che separa i componenti crittografici tra il Tenant del cliente e il Cloud.
Domande frequenti
Argon2 ha vinto la Password Hashing Competition nel 2015 ed è memory-hard: obbliga l'attaccante a impiegare molta memoria per ogni tentativo, rendendo inefficaci gli attacchi massivi con GPU e ASIC che rendono economico il brute-force su bcrypt o PBKDF2. Con parametri di costo adeguati, provare miliardi di password diventa proibitivo.
Per nuovi sistemi, Argon2id è la scelta consigliata da OWASP perché è memory-hard e più resistente al cracking su hardware specializzato. bcrypt resta accettabile e ampiamente diffuso, ma la sua memoria fissa e limitata lo rende meno robusto contro gli attacchi paralleli moderni. LoginMaster usa Argon2.
È la variante ibrida di Argon2 che unisce Argon2i (resistente agli attacchi side-channel basati sui tempi di accesso alla memoria) e Argon2d (resistente al cracking su GPU). OWASP la indica come prima scelta per l'archiviazione delle password, con parametri di memoria, iterazioni e parallelismo da tarare in base all'hardware.
LoginMaster calcola l'hash delle credenziali con Argon2 e applica uno schema split-salt che distribuisce i componenti crittografici tra il Tenant del cliente e il Cloud. Il Cloud non contiene mai dati personali leggibili e nessun singolo archivio possiede le informazioni per ricostruire la password: nemmeno il fornitore può accedere alle credenziali.
Con l'hashing tradizionale, salt e hash risiedono nello stesso database: chi lo viola ha tutto il necessario per un attacco offline. Con lo split-salt i componenti sono separati tra più entità, quindi la violazione di un solo archivio non basta. È una difesa in profondità sopra Argon2.
Non è necessario. Delegando l'autenticazione a LoginMaster, l'hashing Argon2, la gestione dei salt, i parametri di costo e la rotazione degli algoritmi sono gestiti dalla piattaforma, aggiornati nel tempo rispetto alle raccomandazioni NIST/OWASP. La tua applicazione riceve solo un token firmato e non conserva mai le password.
Approfondisci
Smetti di gestire le password da solo
Lascia a LoginMaster hashing Argon2, gestione dei salt e rotazione degli algoritmi. Tu ricevi solo token firmati.