💾 Archived View for tris.fyi › pydoc › cryptography.hazmat.backends.interfaces captured on 2022-01-08 at 13:58:06. Gemini links have been rewritten to link to archived content

View Raw

More Information

➡️ Next capture (2022-07-16)

-=-=-=-=-=-=-

Back to module index

Go to module by name

cryptography.hazmat.backends

cryptography.hazmat

cryptography

cryptography.hazmat.backends.interfaces

This module has no docstring.

Classes

CMACBackend

cmac_algorithm_supported(self, algorithm)


          Returns True if the block cipher is supported for CMAC by this backend
        
create_cmac_ctx(self, algorithm)


          Create a context for calculating a message authentication code.
        

CipherBackend

cipher_supported(self, cipher, mode)


          Return True if the given cipher and mode are supported.
        
create_symmetric_decryption_ctx(self, cipher, mode)


          Get a CipherContext that can be used for decryption.
        
create_symmetric_encryption_ctx(self, cipher, mode)


          Get a CipherContext that can be used for encryption.
        

DERSerializationBackend

load_der_parameters(self, data)


          Load encryption parameters from DER encoded data.
        
load_der_private_key(self, data, password)


          Loads a private key from DER encoded data. Uses the provided password
          if the data is encrypted.
        
load_der_public_key(self, data)


          Loads a public key from DER encoded data.
        

DHBackend

dh_parameters_supported(self, p, g, q=None)


          Returns whether the backend supports DH with these parameter values.
        
dh_x942_serialization_supported(self)


          Returns True if the backend supports the serialization of DH objects
          with subgroup order (q).
        
generate_dh_parameters(self, generator, key_size)


          Generate a DHParameters instance with a modulus of key_size bits.
          Using the given generator. Often 2 or 5.
        
generate_dh_private_key(self, parameters)


          Generate a DHPrivateKey instance with parameters as a DHParameters
          object.
        
generate_dh_private_key_and_parameters(self, generator, key_size)


          Generate a DHPrivateKey instance using key size only.
          Using the given generator. Often 2 or 5.
        
load_dh_parameter_numbers(self, numbers)


          Load DHParameters from DHParameterNumbers.
        
load_dh_private_numbers(self, numbers)


          Load a DHPrivateKey from DHPrivateNumbers
        
load_dh_public_numbers(self, numbers)


          Load a DHPublicKey from DHPublicNumbers.
        

DSABackend

dsa_hash_supported(self, algorithm)


          Return True if the hash algorithm is supported by the backend for DSA.
        
dsa_parameters_supported(self, p, q, g)


          Return True if the parameters are supported by the backend for DSA.
        
generate_dsa_parameters(self, key_size)


          Generate a DSAParameters instance with a modulus of key_size bits.
        
generate_dsa_private_key(self, parameters)


          Generate a DSAPrivateKey instance with parameters as a DSAParameters
          object.
        
generate_dsa_private_key_and_parameters(self, key_size)


          Generate a DSAPrivateKey instance using key size only.
        
load_dsa_parameter_numbers(self, numbers)


          Returns a DSAParameters provider.
        
load_dsa_private_numbers(self, numbers)


          Returns a DSAPrivateKey provider.
        
load_dsa_public_numbers(self, numbers)


          Returns a DSAPublicKey provider.
        

EllipticCurveBackend

derive_elliptic_curve_private_key(self, private_value, curve)


          Compute the private key given the private value and curve.
        
elliptic_curve_exchange_algorithm_supported(self, algorithm, curve)


          Returns whether the exchange algorithm is supported by this backend.
        
elliptic_curve_signature_algorithm_supported(self, signature_algorithm, curve)


          Returns True if the backend supports the named elliptic curve with the
          specified signature algorithm.
        
elliptic_curve_supported(self, curve)


          Returns True if the backend supports the named elliptic curve.
        
generate_elliptic_curve_private_key(self, curve)


          Return an object conforming to the EllipticCurvePrivateKey interface.
        
load_elliptic_curve_private_numbers(self, numbers)


          Return an EllipticCurvePrivateKey provider using the given numbers.
        
load_elliptic_curve_public_numbers(self, numbers)


          Return an EllipticCurvePublicKey provider using the given numbers.
        

HMACBackend

create_hmac_ctx(self, key, algorithm)


          Create a context for calculating a message authentication code.
        
hmac_supported(self, algorithm)


          Return True if the hash algorithm is supported for HMAC by this
          backend.
        

HashBackend

create_hash_ctx(self, algorithm)


          Create a HashContext for calculating a message digest.
        
hash_supported(self, algorithm)


          Return True if the hash algorithm is supported by this backend.
        

PBKDF2HMACBackend

derive_pbkdf2_hmac(self, algorithm, length, salt, iterations, key_material)


          Return length bytes derived from provided PBKDF2 parameters.
        
pbkdf2_hmac_supported(self, algorithm)


          Return True if the hash algorithm is supported for PBKDF2 by this
          backend.
        

PEMSerializationBackend

load_pem_parameters(self, data)


          Load encryption parameters from PEM encoded data.
        
load_pem_private_key(self, data, password)


          Loads a private key from PEM encoded data, using the provided password
          if the data is encrypted.
        
load_pem_public_key(self, data)


          Loads a public key from PEM encoded data.
        

RSABackend

generate_rsa_parameters_supported(self, public_exponent, key_size)


          Returns True if the backend supports the given parameters for key
          generation.
        
generate_rsa_private_key(self, public_exponent, key_size)


          Generate an RSAPrivateKey instance with public_exponent and a modulus
          of key_size bits.
        
load_rsa_private_numbers(self, numbers)


          Returns an RSAPrivateKey provider.
        
load_rsa_public_numbers(self, numbers)


          Returns an RSAPublicKey provider.
        
rsa_padding_supported(self, padding)


          Returns True if the backend supports the given padding options.
        

ScryptBackend

derive_scrypt(self, key_material, salt, length, n, r, p)


          Return bytes derived from provided Scrypt parameters.
        

X509Backend

create_x509_certificate(self, builder, private_key, algorithm)


          Create and sign an X.509 certificate from a CertificateBuilder object.
        
create_x509_crl(self, builder, private_key, algorithm)


          Create and sign an X.509 CertificateRevocationList from a
          CertificateRevocationListBuilder object.
        
create_x509_csr(self, builder, private_key, algorithm)


          Create and sign an X.509 CSR from a CSR builder object.
        
create_x509_revoked_certificate(self, builder)


          Create a RevokedCertificate object from a RevokedCertificateBuilder
          object.
        
load_der_x509_certificate(self, data)


          Load an X.509 certificate from DER encoded data.
        
load_der_x509_csr(self, data)


          Load an X.509 CSR from DER encoded data.
        
load_pem_x509_certificate(self, data)


          Load an X.509 certificate from PEM encoded data.
        
load_pem_x509_csr(self, data)


          Load an X.509 CSR from PEM encoded data.
        
x509_name_bytes(self, name)


          Compute the DER encoded bytes of an X509 Name object.
        

Modules

abc