FM / kdf

/opt/imh-python/lib/python3.9/site-packages/cryptography/hazmat/primitives/kdf/

/opt/imh-python/lib/python3.9/site-packages/cryptography/hazmat/primitives/kdf

Name	Size	Mode	Actions
__pycache__/	-	0755	rm
concatkdf.py	3769	0644	edit dl rm
hkdf.py	3031	0644	edit dl rm
kbkdf.py	7666	0644	edit dl rm
pbkdf2.py	2032	0644	edit dl rm
scrypt.py	2228	0644	edit dl rm
x963kdf.py	2001	0644	edit dl rm
__init__.py	715	0644	edit dl rm

Edit: /opt/imh-python/lib/python3.9/site-packages/cryptography/hazmat/primitives/kdf/pbkdf2.py (2032B)

# This file is dual licensed under the terms of the Apache License, Version
# 2.0, and the BSD License. See the LICENSE file in the root of this repository
# for complete details.

import typing

from cryptography import utils
from cryptography.exceptions import (
    AlreadyFinalized,
    InvalidKey,
    UnsupportedAlgorithm,
    _Reasons,
)
from cryptography.hazmat.primitives import constant_time, hashes
from cryptography.hazmat.primitives.kdf import KeyDerivationFunction

class PBKDF2HMAC(KeyDerivationFunction):
    def __init__(
        self,
        algorithm: hashes.HashAlgorithm,
        length: int,
        salt: bytes,
        iterations: int,
        backend: typing.Any = None,
    ):
        from cryptography.hazmat.backends.openssl.backend import (
            backend as ossl,
        )

if not ossl.pbkdf2_hmac_supported(algorithm):
            raise UnsupportedAlgorithm(
                "{} is not supported for PBKDF2 by this backend.".format(
                    algorithm.name
                ),
                _Reasons.UNSUPPORTED_HASH,
            )
        self._used = False
        self._algorithm = algorithm
        self._length = length
        utils._check_bytes("salt", salt)
        self._salt = salt
        self._iterations = iterations

def derive(self, key_material: bytes) -> bytes:
        if self._used:
            raise AlreadyFinalized("PBKDF2 instances can only be used once.")
        self._used = True

utils._check_byteslike("key_material", key_material)
        from cryptography.hazmat.backends.openssl.backend import backend

return backend.derive_pbkdf2_hmac(
            self._algorithm,
            self._length,
            self._salt,
            self._iterations,
            key_material,
        )

def verify(self, key_material: bytes, expected_key: bytes) -> None:
        derived_key = self.derive(key_material)
        if not constant_time.bytes_eq(derived_key, expected_key):
            raise InvalidKey("Keys do not match.")

cmd: