5.2 PBKDF2

PBKDF2 applica una funzione pseudocasuale (vedere l'Appendice B.1 per un esempio) per derivare le chiavi. La lunghezza della chiave derivata è essenzialmente illimitata. (Tuttavia, lo spazio di ricerca effettivo massimo per la chiave derivata può essere limitato dalla struttura della funzione pseudocasuale sottostante. Vedere l'Appendice B.1 per ulteriori discussioni.) PBKDF2 è raccomandato per le nuove applicazioni.

PBKDF2 (P, S, c, dkLen)

Opzioni:

PRF - funzione pseudocasuale sottostante (hLen denota la lunghezza in ottetti dell'output della funzione pseudocasuale)

Input:

P - password, una stringa di ottetti
S - salt, una stringa di ottetti
c - conteggio delle iterazioni, un intero positivo
dkLen - lunghezza prevista in ottetti della chiave derivata, un intero positivo, al massimo (2^32 - 1) * hLen

Output:

DK - chiave derivata, una stringa di dkLen ottetti

Passaggi:

Se dkLen > (2^32 - 1) * hLen, fornire in output "derived key too long" e fermarsi.
Sia l il numero di blocchi di hLen-ottetti nella chiave derivata, arrotondato per eccesso, e sia r il numero di ottetti nell'ultimo blocco:
```
l = CEIL (dkLen / hLen)
r = dkLen - (l - 1) * hLen
```
Qui, CEIL (x) è la funzione "ceiling", ovvero, il più piccolo intero maggiore o uguale a x.
Per ogni blocco della chiave derivata applicare la funzione F definita di seguito alla password P, al salt S, al conteggio delle iterazioni c e all'indice del blocco per calcolare il blocco:
```
T_1 = F (P, S, c, 1) ,
T_2 = F (P, S, c, 2) ,
...
T_l = F (P, S, c, l) ,
```
dove la funzione F è definita come la somma OR esclusivo delle prime c iterate della funzione pseudocasuale sottostante PRF applicata alla password P e alla concatenazione del salt S e dell'indice del blocco i:
```
F (P, S, c, i) = U_1 \xor U_2 \xor ... \xor U_c
```
dove
```
U_1 = PRF (P, S || INT (i)) ,
U_2 = PRF (P, U_1) ,
...
U_c = PRF (P, U_{c-1}) .
```
Qui, INT (i) è una codifica a quattro ottetti dell'intero i, ottetto più significativo per primo.
Concatenare i blocchi ed estrarre i primi dkLen ottetti per produrre una chiave derivata DK:
```
DK = T_1 || T_2 ||  ...  || T_l<0..r-1>
```
Fornire in output la chiave derivata DK.

Nota: La costruzione della funzione F segue un approccio "belt-and-suspenders". Le iterate U_i sono calcolate ricorsivamente per rimuovere un grado di parallelismo da un avversario; sono combinate con OR esclusivo per ridurre le preoccupazioni sulla degenerazione della ricorsione in un piccolo insieme di valori.

5.2 PBKDF2​

5.2 PBKDF2