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
orHKDF
. 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.
Variable cost algorithms
Argon2id
- class cryptography.hazmat.primitives.kdf.argon2.Argon2id(*, salt, length, iterations, lanes, memory_cost, ad=None, secret=None)[source]
Added in version 44.0.0.
Argon2id is a KDF designed for password storage. It is designed to be resistant to hardware attacks and is described in RFC 9106.
This class conforms to the
KeyDerivationFunction
interface.>>> import os >>> from cryptography.hazmat.primitives.kdf.argon2 import Argon2id >>> salt = os.urandom(16) >>> # derive >>> kdf = Argon2id( ... salt=salt, ... length=32, ... iterations=1, ... lanes=4, ... memory_cost=64 * 1024, ... ad=None, ... secret=None, ... ) >>> key = kdf.derive(b"my great password") >>> # verify >>> kdf = Argon2id( ... salt=salt, ... length=32, ... iterations=1, ... lanes=4, ... memory_cost=64 * 1024, ... ad=None, ... secret=None, ... ) >>> kdf.verify(b"my great password", key)
All arguments to the constructor are keyword-only.
- Parameters:
salt (bytes) – A salt should be unique (and randomly generated) per password and is recommended to be 16 bytes or longer
length (int) – The desired length of the derived key in bytes.
iterations (int) – Also known as passes, this is used to tune the running time independently of the memory size.
lanes (int) – The number of lanes (parallel threads) to use. Also known as parallelism.
memory_cost (int) – The amount of memory to use in kibibytes. 1 kibibyte (KiB) is 1024 bytes. This must be at minimum
8 * lanes
.ad (bytes) – Optional associated data.
secret (bytes) – Optional secret data; used for keyed hashing.
RFC 9106 has recommendations for parameter choice.
- Raises:
cryptography.exceptions.UnsupportedAlgorithm – If Argon2id is not supported by the OpenSSL version
cryptography
is using.
- derive(key_material)
- Parameters:
key_material (bytes-like) – The input key material.
- Return bytes:
the derived key.
- Raises:
TypeError – This exception is raised if
key_material
is notbytes
.cryptography.exceptions.AlreadyFinalized – This is raised when
derive()
orverify()
is called more than once.
This generates and returns a new key from the supplied password.
- verify(key_material, expected_key)
- Parameters:
- Raises:
cryptography.exceptions.InvalidKey – This is raised when the derived key does not match the expected key.
cryptography.exceptions.AlreadyFinalized – This is raised when
derive()
orverify()
is called more than once.
This checks whether deriving a new key from the supplied
key_material
generates the same key as theexpected_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.
PBKDF2
- class cryptography.hazmat.primitives.kdf.pbkdf2.PBKDF2HMAC(algorithm, length, salt, iterations)[source]
Added 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 >>> # Salts should be randomly generated >>> salt = os.urandom(16) >>> # derive >>> kdf = PBKDF2HMAC( ... algorithm=hashes.SHA256(), ... length=32, ... salt=salt, ... iterations=480000, ... ) >>> key = kdf.derive(b"my great password") >>> # verify >>> kdf = PBKDF2HMAC( ... algorithm=hashes.SHA256(), ... length=32, ... salt=salt, ... iterations=480000, ... ) >>> kdf.verify(b"my great password", key)
- Parameters:
algorithm – An instance of
HashAlgorithm
.length (int) – The desired length of the derived key in bytes. Maximum is (232 - 1) *
algorithm.digest_size
.salt (bytes) – A salt. Secure values [1] are 128-bits (16 bytes) or longer and randomly generated.
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. A more detailed description can be consulted for additional information.
- Raises:
TypeError – This exception is raised if
salt
is notbytes
.
- derive(key_material)[source]
- Parameters:
key_material (bytes-like) – The input key material. For PBKDF2 this should be a password.
- Return bytes:
the derived key.
- Raises:
cryptography.exceptions.AlreadyFinalized – This is raised when
derive()
orverify()
is called more than once.TypeError – This exception is raised if
key_material
is notbytes
.
This generates and returns a new key from the supplied password.
- verify(key_material, expected_key)[source]
- Parameters:
- Raises:
cryptography.exceptions.InvalidKey – This is raised when the derived key does not match the expected key.
cryptography.exceptions.AlreadyFinalized – This is raised when
derive()
orverify()
is called more than once.
This checks whether deriving a new key from the supplied
key_material
generates the same key as theexpected_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.
Scrypt
- class cryptography.hazmat.primitives.kdf.scrypt.Scrypt(salt, length, n, r, p)[source]
Added in version 1.6.
Scrypt is a KDF designed for password storage by Colin Percival to be resistant against hardware-assisted attackers by having a tunable memory cost. It is described in RFC 7914.
This class conforms to the
KeyDerivationFunction
interface.>>> import os >>> from cryptography.hazmat.primitives.kdf.scrypt import Scrypt >>> salt = os.urandom(16) >>> # derive >>> kdf = Scrypt( ... salt=salt, ... length=32, ... n=2**14, ... r=8, ... p=1, ... ) >>> key = kdf.derive(b"my great password") >>> # verify >>> kdf = Scrypt( ... salt=salt, ... length=32, ... n=2**14, ... r=8, ... p=1, ... ) >>> kdf.verify(b"my great password", key)
- Parameters:
The computational and memory cost of Scrypt can be adjusted by manipulating the 3 parameters:
n
,r
, andp
. In general, the memory cost of Scrypt is affected by the values of bothn
andr
, whilen
also determines the number of iterations performed.p
increases the computational cost without affecting memory usage. A more in-depth explanation of the 3 parameters can be found here.RFC 7914 recommends values of
r=8
andp=1
while scalingn
to a number appropriate for your system. The scrypt paper suggests a minimum value ofn=2**14
for interactive logins (t < 100ms), orn=2**20
for more sensitive files (t < 5s).- Raises:
cryptography.exceptions.UnsupportedAlgorithm – If Scrypt is not supported by the OpenSSL version
cryptography
is using.TypeError – This exception is raised if
salt
is notbytes
.ValueError – This exception is raised if
n
is less than 2, ifn
is not a power of 2, ifr
is less than 1 or ifp
is less than 1.
- derive(key_material)
- Parameters:
key_material (bytes-like) – The input key material.
- Return bytes:
the derived key.
- Raises:
TypeError – This exception is raised if
key_material
is notbytes
.cryptography.exceptions.AlreadyFinalized – This is raised when
derive()
orverify()
is called more than once.
This generates and returns a new key from the supplied password.
- verify(key_material, expected_key)
- Parameters:
- Raises:
cryptography.exceptions.InvalidKey – This is raised when the derived key does not match the expected key.
cryptography.exceptions.AlreadyFinalized – This is raised when
derive()
orverify()
is called more than once.
This checks whether deriving a new key from the supplied
key_material
generates the same key as theexpected_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.
Fixed cost algorithms
ConcatKDF
- class cryptography.hazmat.primitives.kdf.concatkdf.ConcatKDFHash(algorithm, length, otherinfo)[source]
Added in version 1.0.
ConcatKDFHash (Concatenation Key Derivation Function) is defined by the NIST Special Publication NIST SP 800-56Ar3 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 >>> otherinfo = b"concatkdf-example" >>> ckdf = ConcatKDFHash( ... algorithm=hashes.SHA256(), ... length=32, ... otherinfo=otherinfo, ... ) >>> key = ckdf.derive(b"input key") >>> ckdf = ConcatKDFHash( ... algorithm=hashes.SHA256(), ... length=32, ... otherinfo=otherinfo, ... ) >>> ckdf.verify(b"input key", key)
- Parameters:
algorithm – An instance of
HashAlgorithm
.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.
- Raises:
TypeError – This exception is raised if
otherinfo
is notbytes
.
- derive(key_material)[source]
- Parameters:
key_material (bytes-like) – The input key material.
- Return bytes:
The derived key.
- Raises:
TypeError – This exception is raised if
key_material
is notbytes
.cryptography.exceptions.AlreadyFinalized – This is raised when
derive()
orverify()
is called more than once.
Derives a new key from the input key material.
- verify(key_material, expected_key)[source]
- Parameters:
- Raises:
cryptography.exceptions.InvalidKey – This is raised when the derived key does not match the expected key.
cryptography.exceptions.AlreadyFinalized – This is raised when
derive()
orverify()
is called more than once.
This checks whether deriving a new key from the supplied
key_material
generates the same key as theexpected_key
, and raises an exception if they do not match.
- class cryptography.hazmat.primitives.kdf.concatkdf.ConcatKDFHMAC(algorithm, length, salt, otherinfo)[source]
Added 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 >>> salt = os.urandom(16) >>> otherinfo = b"concatkdf-example" >>> ckdf = ConcatKDFHMAC( ... algorithm=hashes.SHA256(), ... length=32, ... salt=salt, ... otherinfo=otherinfo, ... ) >>> key = ckdf.derive(b"input key") >>> ckdf = ConcatKDFHMAC( ... algorithm=hashes.SHA256(), ... length=32, ... salt=salt, ... otherinfo=otherinfo, ... ) >>> ckdf.verify(b"input key", key)
- Parameters:
algorithm – An instance of
HashAlgorithm
.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 ofalgorithm.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.
- Raises:
TypeError – This exception is raised if
salt
orotherinfo
is notbytes
.
- 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 notbytes
.cryptography.exceptions.AlreadyFinalized – This is raised when
derive()
orverify()
is called more than once.
Derives a new key from the input key material.
- verify(key_material, expected_key)[source]
- Parameters:
- Raises:
cryptography.exceptions.InvalidKey – This is raised when the derived key does not match the expected key.
cryptography.exceptions.AlreadyFinalized – This is raised when
derive()
orverify()
is called more than once.
This checks whether deriving a new key from the supplied
key_material
generates the same key as theexpected_key
, and raises an exception if they do not match.
HKDF
- class cryptography.hazmat.primitives.kdf.hkdf.HKDF(algorithm, length, salt, info)[source]
Added 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 >>> salt = os.urandom(16) >>> info = b"hkdf-example" >>> hkdf = HKDF( ... algorithm=hashes.SHA256(), ... length=32, ... salt=salt, ... info=info, ... ) >>> key = hkdf.derive(b"input key") >>> hkdf = HKDF( ... algorithm=hashes.SHA256(), ... length=32, ... salt=salt, ... info=info, ... ) >>> hkdf.verify(b"input key", key)
- Parameters:
algorithm – An instance of
HashAlgorithm
.length (int) – The desired length of the derived key in bytes. 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 ofalgorithm.digest_size // 8
null bytes will be used. See understanding HKDF for additional detail about the salt and info parameters.info (bytes) – Application specific context information. If
None
is explicitly passed an empty byte string will be used.
- Raises:
TypeError – This exception is raised if
salt
orinfo
is notbytes
.
- derive(key_material)[source]
- Parameters:
key_material (bytes-like) – The input key material.
- Return bytes:
The derived key.
- Raises:
TypeError – This exception is raised if
key_material
is notbytes
.cryptography.exceptions.AlreadyFinalized – This is raised when
derive()
orverify()
is called more than once.
Derives a new key from the input key material by performing both the extract and expand operations.
- verify(key_material, expected_key)[source]
- Parameters:
- Raises:
cryptography.exceptions.InvalidKey – This is raised when the derived key does not match the expected key.
cryptography.exceptions.AlreadyFinalized – This is raised when
derive()
orverify()
is called more than once.
This checks whether deriving a new key from the supplied
key_material
generates the same key as theexpected_key
, and raises an exception if they do not match.
- class cryptography.hazmat.primitives.kdf.hkdf.HKDFExpand(algorithm, length, info)[source]
Added 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 >>> info = b"hkdf-example" >>> key_material = os.urandom(16) >>> hkdf = HKDFExpand( ... algorithm=hashes.SHA256(), ... length=32, ... info=info, ... ) >>> key = hkdf.derive(key_material) >>> hkdf = HKDFExpand( ... algorithm=hashes.SHA256(), ... length=32, ... info=info, ... ) >>> hkdf.verify(key_material, key)
- Parameters:
algorithm – An instance of
HashAlgorithm
.length (int) – The desired length of the derived key in bytes. 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.
- Raises:
TypeError – This exception is raised if
info
is notbytes
.
- 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 notbytes
.cryptography.exceptions.AlreadyFinalized – This is raised when
derive()
orverify()
is called more than once.
Derives a new key from the input key material by performing both the extract and expand operations.
- verify(key_material, expected_key)[source]
- Parameters:
- Raises:
cryptography.exceptions.InvalidKey – This is raised when the derived key does not match the expected key.
cryptography.exceptions.AlreadyFinalized – This is raised when
derive()
orverify()
is called more than once.TypeError – This is raised if the provided
key_material
is aunicode
object
This checks whether deriving a new key from the supplied
key_material
generates the same key as theexpected_key
, and raises an exception if they do not match.
KBKDF
- class cryptography.hazmat.primitives.kdf.kbkdf.KBKDFHMAC(algorithm, mode, length, rlen, llen, location, label, context, fixed)[source]
Added in version 1.4.
KBKDF (Key Based Key Derivation Function) is defined by the NIST SP 800-108 document, to be used to derive additional keys from a key that has been established through an automated key-establishment scheme.
Warning
KBKDFHMAC should not be used for password storage.
>>> import os >>> from cryptography.hazmat.primitives import hashes >>> from cryptography.hazmat.primitives.kdf.kbkdf import ( ... CounterLocation, KBKDFHMAC, Mode ... ) >>> label = b"KBKDF HMAC Label" >>> context = b"KBKDF HMAC Context" >>> kdf = KBKDFHMAC( ... algorithm=hashes.SHA256(), ... mode=Mode.CounterMode, ... length=32, ... rlen=4, ... llen=4, ... location=CounterLocation.BeforeFixed, ... label=label, ... context=context, ... fixed=None, ... ) >>> key = kdf.derive(b"input key") >>> kdf = KBKDFHMAC( ... algorithm=hashes.SHA256(), ... mode=Mode.CounterMode, ... length=32, ... rlen=4, ... llen=4, ... location=CounterLocation.BeforeFixed, ... label=label, ... context=context, ... fixed=None, ... ) >>> kdf.verify(b"input key", key)
- Parameters:
algorithm – An instance of
HashAlgorithm
.mode – The desired mode of the PRF. A value from the
Mode
enum.length (int) – The desired length of the derived key in bytes.
rlen (int) – An integer that indicates the length of the binary representation of the counter in bytes.
llen (int) – An integer that indicates the binary representation of the
length
in bytes.location – The desired location of the counter. A value from the
CounterLocation
enum.label (bytes) – Application specific label information. If
None
is explicitly passed an empty byte string will be used.context (bytes) – Application specific context information. If
None
is explicitly passed an empty byte string will be used.fixed (bytes) – Instead of specifying
label
andcontext
you may supply your own fixed data. Iffixed
is specified,label
andcontext
is ignored.break_location (int) – A keyword-only argument. An integer that indicates the bytes offset where counter bytes are to be located. Required when
location
isMiddleFixed
.
- Raises:
TypeError – This exception is raised if
label
orcontext
is notbytes
. Also raised ifrlen
,llen
, orbreak_location
is notint
.ValueError – This exception is raised if
rlen
orllen
is greater than 4 or less than 1. This exception is also raised if you specify alabel
orcontext
andfixed
. This exception is also raised if you specifybreak_location
andlocation
is notMiddleFixed
.
- derive(key_material)[source]
- Parameters:
key_material (bytes-like) – The input key material.
- Return bytes:
The derived key.
- Raises:
TypeError – This exception is raised if
key_material
is notbytes
.cryptography.exceptions.AlreadyFinalized – This is raised when
derive()
orverify()
is called more than once.
Derives a new key from the input key material.
- verify(key_material, expected_key)[source]
- Parameters:
- Raises:
cryptography.exceptions.InvalidKey – This is raised when the derived key does not match the expected key.
cryptography.exceptions.AlreadyFinalized – This is raised when
derive()
orverify()
is called more than once.
This checks whether deriving a new key from the supplied
key_material
generates the same key as theexpected_key
, and raises an exception if they do not match.
- class cryptography.hazmat.primitives.kdf.kbkdf.KBKDFCMAC(algorithm, mode, length, rlen, llen, location, label, context, fixed)[source]
Added in version 35.0.0.
KBKDF (Key Based Key Derivation Function) is defined by the NIST SP 800-108 document, to be used to derive additional keys from a key that has been established through an automated key-establishment scheme.
Warning
KBKDFCMAC should not be used for password storage.
>>> from cryptography.hazmat.primitives.ciphers import algorithms >>> from cryptography.hazmat.primitives.kdf.kbkdf import ( ... CounterLocation, KBKDFCMAC, Mode ... ) >>> label = b"KBKDF CMAC Label" >>> context = b"KBKDF CMAC Context" >>> kdf = KBKDFCMAC( ... algorithm=algorithms.AES, ... mode=Mode.CounterMode, ... length=32, ... rlen=4, ... llen=4, ... location=CounterLocation.BeforeFixed, ... label=label, ... context=context, ... fixed=None, ... ) >>> key = kdf.derive(b"32 bytes long input key material") >>> kdf = KBKDFCMAC( ... algorithm=algorithms.AES, ... mode=Mode.CounterMode, ... length=32, ... rlen=4, ... llen=4, ... location=CounterLocation.BeforeFixed, ... label=label, ... context=context, ... fixed=None, ... ) >>> kdf.verify(b"32 bytes long input key material", key)
- Parameters:
algorithm – A class implementing a block cipher algorithm being a subclass of
CipherAlgorithm
andBlockCipherAlgorithm
.mode – The desired mode of the PRF. A value from the
Mode
enum.length (int) – The desired length of the derived key in bytes.
rlen (int) – An integer that indicates the length of the binary representation of the counter in bytes.
llen (int) – An integer that indicates the binary representation of the
length
in bytes.location – The desired location of the counter. A value from the
CounterLocation
enum.label (bytes) – Application specific label information. If
None
is explicitly passed an empty byte string will be used.context (bytes) – Application specific context information. If
None
is explicitly passed an empty byte string will be used.fixed (bytes) – Instead of specifying
label
andcontext
you may supply your own fixed data. Iffixed
is specified,label
andcontext
is ignored.break_location (int) – A keyword-only argument. An integer that indicates the bytes offset where counter bytes are to be located. Required when
location
isMiddleFixed
.
- Raises:
cryptography.exceptions.UnsupportedAlgorithm – This is raised if
algorithm
is not a subclass ofCipherAlgorithm
andBlockCipherAlgorithm
.TypeError – This exception is raised if
label
orcontext
is notbytes
,rlen
,llen
, orbreak_location
is notint
,mode
is notMode
orlocation
is notCounterLocation
.ValueError – This exception is raised if
rlen
orllen
is greater than 4 or less than 1. This exception is also raised if you specify alabel
orcontext
andfixed
. This exception is also raised if you specifybreak_location
andlocation
is notMiddleFixed
.
- derive(key_material)[source]
- Parameters:
key_material (bytes-like) – The input key material.
- Return bytes:
The derived key.
- Raises:
TypeError – This exception is raised if
key_material
is notbytes
.ValueError – This exception is raised if
key_material
is not a valid key foralgorithm
passed toKBKDFCMAC
constructor.cryptography.exceptions.AlreadyFinalized – This is raised when
derive()
orverify()
is called more than once.
Derives a new key from the input key material.
- verify(key_material, expected_key)[source]
- Parameters:
- Raises:
cryptography.exceptions.InvalidKey – This is raised when the derived key does not match the expected key.
- Raises:
Exceptions raised by
derive()
.
This checks whether deriving a new key from the supplied
key_material
generates the same key as theexpected_key
, and raises an exception if they do not match.
- class cryptography.hazmat.primitives.kdf.kbkdf.Mode[source]
An enumeration for the key based key derivative modes.
- CounterMode
The output of the PRF is computed with a counter as the iteration variable.
- class cryptography.hazmat.primitives.kdf.kbkdf.CounterLocation[source]
An enumeration for the key based key derivative counter location.
- BeforeFixed
The counter iteration variable will be concatenated before the fixed input data.
- AfterFixed
The counter iteration variable will be concatenated after the fixed input data.
- MiddleFixed
Added in version 38.0.0.
The counter iteration variable will be concatenated in the middle of the fixed input data.
X963KDF
- class cryptography.hazmat.primitives.kdf.x963kdf.X963KDF(algorithm, length, otherinfo)[source]
Added in version 1.1.
X963KDF (ANSI X9.63 Key Derivation Function) is defined by ANSI in the ANSI X9.63:2001 document, to be used to derive keys for use after a Key Exchange negotiation operation.
SECG in SEC 1 v2.0 recommends that
ConcatKDFHash
be used for new projects. This KDF should only be used for backwards compatibility with pre-existing protocols.Warning
X963KDF should not be used for password storage.
>>> import os >>> from cryptography.hazmat.primitives import hashes >>> from cryptography.hazmat.primitives.kdf.x963kdf import X963KDF >>> sharedinfo = b"ANSI X9.63 Example" >>> xkdf = X963KDF( ... algorithm=hashes.SHA256(), ... length=32, ... sharedinfo=sharedinfo, ... ) >>> key = xkdf.derive(b"input key") >>> xkdf = X963KDF( ... algorithm=hashes.SHA256(), ... length=32, ... sharedinfo=sharedinfo, ... ) >>> xkdf.verify(b"input key", key)
- Parameters:
algorithm – An instance of
HashAlgorithm
.length (int) – The desired length of the derived key in bytes. Maximum is
hashlen * (2^32 -1)
.sharedinfo (bytes) – Application specific context information. If
None
is explicitly passed an empty byte string will be used.
- Raises:
TypeError – This exception is raised if
sharedinfo
is notbytes
.
- derive(key_material)[source]
- Parameters:
key_material (bytes-like) – The input key material.
- Return bytes:
The derived key.
- Raises:
TypeError – This exception is raised if
key_material
is notbytes
.cryptography.exceptions.AlreadyFinalized – This is raised when
derive()
orverify()
is called more than once.
Derives a new key from the input key material.
- verify(key_material, expected_key)[source]
- Parameters:
- Raises:
cryptography.exceptions.InvalidKey – This is raised when the derived key does not match the expected key.
cryptography.exceptions.AlreadyFinalized – This is raised when
derive()
orverify()
is called more than once.
This checks whether deriving a new key from the supplied
key_material
generates the same key as theexpected_key
, and raises an exception if they do not match.
Interface
- class cryptography.hazmat.primitives.kdf.KeyDerivationFunction[source]
Added 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()
orverify()
is called more than once.
This generates and returns a new key from the supplied key material.
- verify(key_material, expected_key)[source]
- Parameters:
- Raises:
cryptography.exceptions.InvalidKey – This is raised when the derived key does not match the expected key.
cryptography.exceptions.AlreadyFinalized – This is raised when
derive()
orverify()
is called more than once.
This checks whether deriving a new key from the supplied
key_material
generates the same key as theexpected_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.