PBKDF2

Posted On 02.21.2022

PBKDF2 is a key derivation function, used in the process of deriving encryption keys.

The main idea of PBKDF2 is repeatedly applying the input and the salt to a hash function like HMAC to produce a key, which can be used later on in subsequence operations.

Passwords managers like 1Password and Bitwarden use this function (in a combination of a much more complex scheme) with your Master Password to generate a symmetric key for encrypting and decrypting data in your vault.

The PBKDF2 function takes several input parameters and produces the derived key as output:

$Output = PBKDF2 (PRFn, Password, Salt, N, KeyLen)$

where:

$P R F n$ is a pseudorandom function that produces an output length $h L e n$ bits, for example, keyed HMAC.
$P a s s w o r d$ is the input password
$S a l t$ is a securely generated random bytes, minium 64 bits but 128 bits is recommended
$N$ is the number of iterations of HMAC derivation. For example, in Bitwarden, it’s 100,001 iterations
$K e y L e n$ is the expected key length for the output, for example, 32 bytes (256 bits)

The iterations count is directly proportional to the time it takes for key derivation. The slower key derivation, the slower login time but the password is more secure against cracking attacks.

The $O u t p u t$ is the concatenation of many $h L e n$ bit blocks:
$Output = T_{1} + T_{2} + \dots + T_{KeyLen / hLen}$

Each block $T_{i}$ is computed as:

$T_{i} = F (Password, Salt, N, i)$

The function $F$ is the XOR of $C o u n t$ iterations of chained $P R F n$ . Chained mean, the later iterations will use the computed result of the previous iteration as an input:

$F (Password, Salt, N, i) = U_{1} \oplus U_{2} \oplus \dots \oplus U_{N}$

Where each $U$ is:

$U_{1} = PRFn (Password, Salt + Int32BigEndian (i))$

$U_{2} = PRFn (Password, U_{1})$

$\dots$

$U_{N} = PRFn (Password, U_{N - 1})$

The $O u t p u t$ is extracted as the first $K e y L e n$ bits of the final hash.

It’s important to note that PBKDF2 is not resistant to GPU attacks for ASIC attacks (attacks using specialized hardware). For new systems, it’s recommended to use a more secure algorithm like Bcrypt, Scrypt, or Argon2 instead.

What’s next?