Quando si crea un hash con PBKDF2, consente allo sviluppatore di scegliere la dimensione dell'hash. È sempre meglio? Inoltre, che dire delle dimensioni del sale casuale? Dovrebbe avere le stesse dimensioni dell'hash?
EDIT: in particolare nelle password di hashing.
Per la funzione di hash, si desidera utilizzare una funzione per la quale il tipo di piattaforma più efficiente (quello che produrrà più hash calcoli al secondo e per dollaro) è la macchina che si intende utilizzare (cioè un PC) . Questo perché sei in una corsa agli armamenti con l'attaccante e l'attaccante può acquistare altri tipi di hardware per ottenere un vantaggio su di te (come una GPU). Le GPU sono molto buone con l'aritmetica a 32 bit, ma non con l'aritmetica a 64 bit, mentre un PC (in modalità a 64 bit) sarà piuttosto veloce in quest'ultimo.
Quindi, usa una funzione di hash che gira su operazioni aritmetiche a 64 bit. Questo indica SHA-512 .
PBKDF2 è una funzione di derivazione della chiave : produce un output di dimensioni configurabili. Per l'hashing della password, si desidera che le dimensioni siano sufficientemente grandi da impedire attacchi generici di preimage (ovvero, tentare password casuali fino a quando non viene trovata una corrispondenza), quindi questo avrebbe bisogno, ad esempio, di almeno 80 bit di output. Se solo per rendere la sicurezza più convincente per gli incauti, e anche per l'estetica, scegli la potenza successiva di 2: un output a 128 bit . Non è utile andare oltre.
Il sale deve essere unico - il più unico possibile. Un modo semplice per raggiungere valori salini unici è generare sali con un PRNG crittografico strong : la probabilità di riutilizzare un valore salato sarà sufficientemente bassi da essere trascurati se questi sali casuali sono abbastanza grandi e "abbastanza grandi" significa "128 bit". Quindi utilizza sali a 128 bit casuali .
Personalmente, preferisco bcrypt su PBKDF2 per l'hashing della password.
Secondo lo standard PBKDF2, la dimensione minima raccomandata per il sale è 64 bit, anche se personalmente raccomanderei 128 bit o superiore per un margine di sicurezza decente. La dimensione del sale è indipendente dalla tua scelta di hash.
Per quanto riguarda la sicurezza, consiglio di scegliere una lunghezza della chiave derivata di almeno la stessa dimensione dell'output di Salt, con un minimo di 256 bit. Qualsiasi dimensione di hash inferiore a 256 bit è comunque al di sotto del limite di sicurezza delle più moderne funzioni di hash.
La scelta di una lunghezza della chiave derivata inferiore alla lunghezza di output della funzione di hash ha poco senso, a meno che non si stia utilizzando la chiave per un codice a blocchi che non può gestire una chiave di tale dimensione.
In termini di sicurezza ottimale, suggerirei SHA-512 come PRF, con una chiave derivata a 512 bit, un sale a 128 bit e tutte le iterazioni che la situazione può garantire.
Nel caso in cui la tua piattaforma di scelta sia .NET, c'è un articolo OWASP specificamente dedicato alla sua classe Rfc2898DeriveBytes . Specificamente nota (sottolineatura mia):
The built-in .NET implementation of Rfc2898DeriveBytes limits the user to one psudorandom function - HMAC with SHA-1. This is acceptable in most scenarios today, but in the future, a more complex hashing function may be required.
Using PBKDF2 for password storage, one should never output more bits than the base hash function's size. With PBKDF2-SHA1 this is 160 bits or 20 bytes. Output more bits doesn't make the hash more secure, but it costs the defender a lot more time while not costing the attacker. An attacker will just compare the first hash function sized output saving them the time to generate the reset of the PBKDF2 output.
Hanno anche un esempio di codice, che ho modificato in base alla guida delle altre risposte:
public static string Hash(string str)
{
// Generate the hash, with an automatic 16 byte salt
using (var rfc2898DeriveBytes = new Rfc2898DeriveBytes(str, 16))
{
rfc2898DeriveBytes .IterationCount = 10000 // or whatever you can afford
byte[] hash = rfc2898DeriveBytes.GetBytes(20);
byte[] salt = rfc2898DeriveBytes.Salt;
return Convert.ToBase64String(salt) + "|" + Convert.ToBase64String(hash);
}
}