Danger

This is a “Hazardous Materials” module. You should ONLY use it if you’re 100% absolutely sure that you know what you’re doing because this module is full of land mines, dragons, and dinosaurs with laser guns.

Key derivation functions

Key derivation functions derive bytes suitable for cryptographic operations from passwords or other data sources using a pseudo-random function (PRF). Different KDFs are suitable for different tasks such as:

  • Cryptographic key derivation

    Deriving a key suitable for use as input to an encryption algorithm. Typically this means taking a password and running it through an algorithm such as PBKDF2HMAC or HKDF. This process is typically known as key stretching.

  • Password storage

    When storing passwords you want to use an algorithm that is computationally intensive. Legitimate users will only need to compute it once (for example, taking the user’s password, running it through the KDF, then comparing it to the stored value), while attackers will need to do it billions of times. Ideal password storage KDFs will be demanding on both computational and memory resources.

class cryptography.hazmat.primitives.kdf.pbkdf2.PBKDF2HMAC(algorithm, length, salt, iterations, backend)[source]

New in version 0.2.

PBKDF2 (Password Based Key Derivation Function 2) is typically used for deriving a cryptographic key from a password. It may also be used for key storage, but an alternate key storage KDF such as scrypt is generally considered a better solution.

This class conforms to the KeyDerivationFunction interface.

>>> import os
>>> from cryptography.hazmat.primitives import hashes
>>> from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
>>> from cryptography.hazmat.backends import default_backend
>>> backend = default_backend()
>>> salt = os.urandom(16)
>>> # derive
>>> kdf = PBKDF2HMAC(
...     algorithm=hashes.SHA256(),
...     length=32,
...     salt=salt,
...     iterations=100000,
...     backend=backend
... )
>>> key = kdf.derive(b"my great password")
>>> # verify
>>> kdf = PBKDF2HMAC(
...     algorithm=hashes.SHA256(),
...     length=32,
...     salt=salt,
...     iterations=100000,
...     backend=backend
... )
>>> kdf.verify(b"my great password", key)
Parameters:
  • algorithm – An instance of a HashAlgorithm provider.
  • length (int) – The desired length of the derived key. Maximum is (232 - 1) * algorithm.digest_size.
  • salt (bytes) – A salt. NIST SP 800-132 recommends 128-bits or longer.
  • iterations (int) – The number of iterations to perform of the hash function. This can be used to control the length of time the operation takes. Higher numbers help mitigate brute force attacks against derived keys. See OWASP’s Password Storage Cheat Sheet for more detailed recommendations if you intend to use this for password storage.
  • backend – A PBKDF2HMACBackend provider.
Raises:
derive(key_material)[source]
Parameters:

key_material (bytes) – The input key material. For PBKDF2 this should be a password.

Return bytes:

the derived key.

Raises:

This generates and returns a new key from the supplied password.

verify(key_material, expected_key)[source]
Parameters:
  • key_material (bytes) – The input key material. This is the same as key_material in derive().
  • expected_key (bytes) – The expected result of deriving a new key, this is the same as the return value of derive().
Raises:

This checks whether deriving a new key from the supplied key_material generates the same key as the expected_key, and raises an exception if they do not match. This can be used for checking whether the password a user provides matches the stored derived key.

class cryptography.hazmat.primitives.kdf.hkdf.HKDF(algorithm, length, salt, info, backend)[source]

New in version 0.2.

HKDF (HMAC-based Extract-and-Expand Key Derivation Function) is suitable for deriving keys of a fixed size used for other cryptographic operations.

Warning

HKDF should not be used for password storage.

>>> import os
>>> from cryptography.hazmat.primitives import hashes
>>> from cryptography.hazmat.primitives.kdf.hkdf import HKDF
>>> from cryptography.hazmat.backends import default_backend
>>> backend = default_backend()
>>> salt = os.urandom(16)
>>> info = b"hkdf-example"
>>> hkdf = HKDF(
...     algorithm=hashes.SHA256(),
...     length=32,
...     salt=salt,
...     info=info,
...     backend=backend
... )
>>> key = hkdf.derive(b"input key")
>>> hkdf = HKDF(
...     algorithm=hashes.SHA256(),
...     length=32,
...     salt=salt,
...     info=info,
...     backend=backend
... )
>>> hkdf.verify(b"input key", key)
Parameters:
  • algorithm – An instance of a HashAlgorithm provider.
  • length (int) – The desired length of the derived key. Maximum is 255 * (algorithm.digest_size // 8).
  • salt (bytes) – A salt. Randomizes the KDF’s output. Optional, but highly recommended. Ideally as many bits of entropy as the security level of the hash: often that means cryptographically random and as long as the hash output. Worse (shorter, less entropy) salt values can still meaningfully contribute to security. May be reused. Does not have to be secret, but may cause stronger security guarantees if secret; see RFC 5869 and the HKDF paper for more details. If None is explicitly passed a default salt of algorithm.digest_size // 8 null bytes will be used.
  • info (bytes) – Application specific context information. If None is explicitly passed an empty byte string will be used.
  • backend – A HMACBackend provider.
Raises:
derive(key_material)[source]
Parameters:key_material (bytes) – The input key material.
Return bytes:The derived key.
Raises TypeError:
 This exception is raised if key_material is not bytes.

Derives a new key from the input key material by performing both the extract and expand operations.

verify(key_material, expected_key)[source]
Parameters:
  • key_material (bytes) – The input key material. This is the same as key_material in derive().
  • expected_key (bytes) – The expected result of deriving a new key, this is the same as the return value of derive().
Raises:

This checks whether deriving a new key from the supplied key_material generates the same key as the expected_key, and raises an exception if they do not match.

class cryptography.hazmat.primitives.kdf.hkdf.HKDFExpand(algorithm, length, info, backend)[source]

New in version 0.5.

HKDF consists of two stages, extract and expand. This class exposes an expand only version of HKDF that is suitable when the key material is already cryptographically strong.

Warning

HKDFExpand should only be used if the key material is cryptographically strong. You should use HKDF if you are unsure.

>>> import os
>>> from cryptography.hazmat.primitives import hashes
>>> from cryptography.hazmat.primitives.kdf.hkdf import HKDFExpand
>>> from cryptography.hazmat.backends import default_backend
>>> backend = default_backend()
>>> info = b"hkdf-example"
>>> key_material = os.urandom(16)
>>> hkdf = HKDFExpand(
...     algorithm=hashes.SHA256(),
...     length=32,
...     info=info,
...     backend=backend
... )
>>> key = hkdf.derive(key_material)
>>> hkdf = HKDFExpand(
...     algorithm=hashes.SHA256(),
...     length=32,
...     info=info,
...     backend=backend
... )
>>> hkdf.verify(key_material, key)
Parameters:
  • algorithm – An instance of a HashAlgorithm provider.
  • length (int) – The desired length of the derived key. Maximum is 255 * (algorithm.digest_size // 8).
  • info (bytes) – Application specific context information. If None is explicitly passed an empty byte string will be used.
  • backend – A HMACBackend provider.
Raises:
derive(key_material)[source]
Parameters:

key_material (bytes) – The input key material.

Return bytes:

The derived key.

Raises:
  • TypeError – This is raised if the provided key_material is a unicode object
  • TypeError – This exception is raised if key_material is not bytes.

Derives a new key from the input key material by performing both the extract and expand operations.

verify(key_material, expected_key)[source]
Parameters:
  • key_material (bytes) – The input key material. This is the same as key_material in derive().
  • expected_key (bytes) – The expected result of deriving a new key, this is the same as the return value of derive().
Raises:

This checks whether deriving a new key from the supplied key_material generates the same key as the expected_key, and raises an exception if they do not match.

class cryptography.hazmat.primitives.kdf.concatkdf.ConcatKDFHash(algorithm, length, otherinfo, backend)[source]

New in version 1.0.

ConcatKDFHash (Concatenation Key Derivation Function) is defined by the NIST Special Publication NIST SP 800-56Ar2 document, to be used to derive keys for use after a Key Exchange negotiation operation.

Warning

ConcatKDFHash should not be used for password storage.

>>> import os
>>> from cryptography.hazmat.primitives import hashes
>>> from cryptography.hazmat.primitives.kdf.concatkdf import ConcatKDFHash
>>> from cryptography.hazmat.backends import default_backend
>>> backend = default_backend()
>>> otherinfo = b"concatkdf-example"
>>> ckdf = ConcatKDFHash(
...     algorithm=hashes.SHA256(),
...     length=256,
...     otherinfo=otherinfo,
...     backend=backend
... )
>>> key = ckdf.derive(b"input key")
>>> ckdf = ConcatKDFHash(
...     algorithm=hashes.SHA256(),
...     length=256,
...     otherinfo=otherinfo,
...     backend=backend
... )
>>> ckdf.verify(b"input key", key)
Parameters:
  • algorithm – An instance of a HashAlgorithm provider
  • length (int) – The desired length of the derived key in bytes. Maximum is hashlen * (2^32 -1).
  • otherinfo (bytes) – Application specific context information. If None is explicitly passed an empty byte string will be used.
  • backend – A HashBackend provider.
Raises:
derive(key_material)[source]
Parameters:key_material (bytes) – The input key material.
Return bytes:The derived key.
Raises TypeError:
 This exception is raised if key_material is not bytes.

Derives a new key from the input key material.

verify(key_material, expected_key)[source]
Parameters:
  • key_material (bytes) – The input key material. This is the same as key_material in derive().
  • expected_key (bytes) – The expected result of deriving a new key, this is the same as the return value of derive().
Raises:

This checks whether deriving a new key from the supplied key_material generates the same key as the expected_key, and raises an exception if they do not match.

class cryptography.hazmat.primitives.kdf.concatkdf.ConcatKDFHMAC(algorithm, length, salt, otherinfo, backend)[source]

New in version 1.0.

Similar to ConcatKFDHash but uses an HMAC function instead.

Warning

ConcatKDFHMAC should not be used for password storage.

>>> import os
>>> from cryptography.hazmat.primitives import hashes
>>> from cryptography.hazmat.primitives.kdf.concatkdf import ConcatKDFHMAC
>>> from cryptography.hazmat.backends import default_backend
>>> backend = default_backend()
>>> salt = os.urandom(16)
>>> otherinfo = b"concatkdf-example"
>>> ckdf = ConcatKDFHMAC(
...     algorithm=hashes.SHA256(),
...     length=256,
...     salt=salt,
...     otherinfo=otherinfo,
...     backend=backend
... )
>>> key = ckdf.derive(b"input key")
>>> ckdf = ConcatKDFHMAC(
...     algorithm=hashes.SHA256(),
...     length=256,
...     salt=salt,
...     otherinfo=otherinfo,
...     backend=backend
... )
>>> ckdf.verify(b"input key", key)
Parameters:
  • algorithm – An instance of a HashAlgorithm provider
  • length (int) – The desired length of the derived key in bytes. Maximum is hashlen * (2^32 -1).
  • salt (bytes) – A salt. Randomizes the KDF’s output. Optional, but highly recommended. Ideally as many bits of entropy as the security level of the hash: often that means cryptographically random and as long as the hash output. Does not have to be secret, but may cause stronger security guarantees if secret; If None is explicitly passed a default salt of algorithm.block_size null bytes will be used.
  • otherinfo (bytes) – Application specific context information. If None is explicitly passed an empty byte string will be used.
  • backend – A HMACBackend provider.
Raises:
derive(key_material)[source]
Parameters:key_material (bytes) – The input key material.
Return bytes:The derived key.
Raises TypeError:
 This exception is raised if key_material is not bytes.

Derives a new key from the input key material.

verify(key_material, expected_key)[source]
Parameters:
  • key_material (bytes) – The input key material. This is the same as key_material in derive().
  • expected_key (bytes) – The expected result of deriving a new key, this is the same as the return value of derive().
Raises:

This checks whether deriving a new key from the supplied key_material generates the same key as the expected_key, and raises an exception if they do not match.

Interface

class cryptography.hazmat.primitives.kdf.KeyDerivationFunction[source]

New in version 0.2.

derive(key_material)[source]
Parameters:key_material (bytes) – The input key material. Depending on what key derivation function you are using this could be either random bytes, or a user supplied password.
Returns:The new key.
Raises cryptography.exceptions.AlreadyFinalized:
 This is raised when derive() or verify() is called more than once.

This generates and returns a new key from the supplied key material.

verify(key_material, expected_key)[source]
Parameters:
  • key_material (bytes) – The input key material. This is the same as key_material in derive().
  • expected_key (bytes) – The expected result of deriving a new key, this is the same as the return value of derive().
Raises:

This checks whether deriving a new key from the supplied key_material generates the same key as the expected_key, and raises an exception if they do not match. This can be used for something like checking whether a user’s password attempt matches the stored derived key.