#include <gost_28147.h>

Inheritance diagram for Botan::GOST_28147_89:

Public Types
enum

Public Member Functions
size_t	block_size () const override

void	clear () override

BlockCipher *	clone () const override

void	decrypt (const uint8_t in[], uint8_t out[]) const

void	decrypt (uint8_t block[]) const

template<typename Alloc >
void	decrypt (std::vector< uint8_t, Alloc > &block) const

template<typename Alloc , typename Alloc2 >
void	decrypt (const std::vector< uint8_t, Alloc > &in, std::vector< uint8_t, Alloc2 > &out) const

void	decrypt_n (const uint8_t in[], uint8_t out[], size_t blocks) const override

void	encrypt (const uint8_t in[], uint8_t out[]) const

void	encrypt (uint8_t block[]) const

template<typename Alloc >
void	encrypt (std::vector< uint8_t, Alloc > &block) const

template<typename Alloc , typename Alloc2 >
void	encrypt (const std::vector< uint8_t, Alloc > &in, std::vector< uint8_t, Alloc2 > &out) const

void	encrypt_n (const uint8_t in[], uint8_t out[], size_t blocks) const override

	GOST_28147_89 (const GOST_28147_89_Params &params)

Key_Length_Specification	key_spec () const override

size_t	maximum_keylength () const

size_t	minimum_keylength () const

std::string	name () const override

size_t	parallel_bytes () const

virtual size_t	parallelism () const

virtual std::string	provider () const

void	set_key (const SymmetricKey &key)

template<typename Alloc >
void	set_key (const std::vector< uint8_t, Alloc > &key)

void	set_key (const uint8_t key[], size_t length)

bool	valid_keylength (size_t length) const

Static Public Member Functions
static std::unique_ptr< BlockCipher >	create (const std::string &algo_spec, const std::string &provider="")

static std::unique_ptr< BlockCipher >	create_or_throw (const std::string &algo_spec, const std::string &provider="")

static std::vector< std::string >	providers (const std::string &algo_spec)

Detailed Description

GOST 28147-89

Definition at line 52 of file gost_28147.h.

Member Enumeration Documentation

◆ anonymous enum

anonymous enum

inherited

Definition at line 186 of file block_cipher.h.

186 { BLOCK_SIZE = BS };

Botan::Block_Cipher_Fixed_Params< 8, 32 >::BLOCK_SIZE

Definition: block_cipher.h:186

Constructor & Destructor Documentation

◆ GOST_28147_89()

Botan::GOST_28147_89::GOST_28147_89 ( const GOST_28147_89_Params & params )

explicit

Parameters

params the sbox parameters to use

Definition at line 53 of file gost_28147.cpp.

References Botan::rotate_left(), and Botan::GOST_28147_89_Params::sbox_entry().

                                                               : m_SBOX(1024)
    {
    // Convert the parallel 4x4 sboxes into larger word-based sboxes
    for(size_t i = 0; i != 4; ++i)
       for(size_t j = 0; j != 256; ++j)
          {
          const uint32_t T = (param.sbox_entry(2*i  , j % 16)) |
                           (param.sbox_entry(2*i+1, j / 16) << 4);
          m_SBOX[256*i+j] = rotate_left(T, (11+8*i) % 32);
          }
    }

Member Function Documentation

◆ block_size()

size_t Botan::Block_Cipher_Fixed_Params< BS, KMIN, 0 , 1 >::block_size ( ) const

inlineoverridevirtualinherited

Returns: block size of this algorithm

Implements Botan::BlockCipher.

Definition at line 187 of file block_cipher.h.

187 { return BS; }

◆ clear()

void Botan::GOST_28147_89::clear ( )

overridevirtual

Reset the state.

Implements Botan::SymmetricAlgorithm.

Definition at line 171 of file gost_28147.cpp.

References Botan::zap().

Referenced by Botan::GOST_34_11::clear().

    {
    zap(m_EK);
    }

◆ clone()

BlockCipher* Botan::GOST_28147_89::clone ( ) const

inlineoverridevirtual

Returns: new object representing the same algorithm as *this

Implements Botan::BlockCipher.

Definition at line 61 of file gost_28147.h.

61 { return new GOST_28147_89(m_SBOX); }

Botan::GOST_28147_89::GOST_28147_89

GOST_28147_89(const GOST_28147_89_Params &params)

Definition: gost_28147.cpp:53

◆ create()

std::unique_ptr< BlockCipher > Botan::BlockCipher::create	(	const std::string &	algo_spec,
		const std::string &	provider = `""`
	)

staticinherited

Create an instance based on a name If provider is empty then best available is chosen.

Parameters

algo_spec	algorithm name
provider	provider implementation to choose

Returns: a null pointer if the algo/provider combination cannot be found

Definition at line 88 of file block_cipher.cpp.

References Botan::BlockCipher::block_size(), BOTAN_UNUSED, Botan::HashFunction::create(), Botan::StreamCipher::create(), hash, and Botan::make_openssl_block_cipher().

Referenced by botan_block_cipher_init(), Botan::MessageAuthenticationCode::create(), Botan::StreamCipher::create(), Botan::BlockCipher::create_or_throw(), Botan::get_aead(), Botan::get_block_cipher(), and Botan::get_cipher_mode().

    {
 #if defined(BOTAN_HAS_OPENSSL)
    if(provider.empty() || provider == "openssl")
       {
       if(auto bc = make_openssl_block_cipher(algo))
          return bc;
 
       if(!provider.empty())
          return nullptr;
       }
 #endif
 
    // TODO: CommonCrypto
    // TODO: CryptoAPI
    // TODO: /dev/crypto
 
    // Only base providers from here on out
    if(provider.empty() == false && provider != "base")
       return nullptr;
 
 #if defined(BOTAN_HAS_AES)
    if(algo == "AES-128")
       {
       return std::unique_ptr<BlockCipher>(new AES_128);
       }
 
    if(algo == "AES-192")
       {
       return std::unique_ptr<BlockCipher>(new AES_192);
       }
 
    if(algo == "AES-256")
       {
       return std::unique_ptr<BlockCipher>(new AES_256);
       }
 #endif
 
 #if defined(BOTAN_HAS_SERPENT)
    if(algo == "Serpent")
       {
       return std::unique_ptr<BlockCipher>(new Serpent);
       }
 #endif
 
 #if defined(BOTAN_HAS_TWOFISH)
    if(algo == "Twofish")
       {
       return std::unique_ptr<BlockCipher>(new Twofish);
       }
 #endif
 
 #if defined(BOTAN_HAS_THREEFISH_512)
    if(algo == "Threefish-512")
       {
       return std::unique_ptr<BlockCipher>(new Threefish_512);
       }
 #endif
 
 #if defined(BOTAN_HAS_BLOWFISH)
    if(algo == "Blowfish")
       {
       return std::unique_ptr<BlockCipher>(new Blowfish);
       }
 #endif
 
 #if defined(BOTAN_HAS_CAMELLIA)
    if(algo == "Camellia-128")
       {
       return std::unique_ptr<BlockCipher>(new Camellia_128);
       }
 
    if(algo == "Camellia-192")
       {
       return std::unique_ptr<BlockCipher>(new Camellia_192);
       }
 
    if(algo == "Camellia-256")
       {
       return std::unique_ptr<BlockCipher>(new Camellia_256);
       }
 #endif
 
 #if defined(BOTAN_HAS_DES)
    if(algo == "DES")
       {
       return std::unique_ptr<BlockCipher>(new DES);
       }
 
    if(algo == "DESX")
       {
       return std::unique_ptr<BlockCipher>(new DESX);
       }
 
    if(algo == "TripleDES" || algo == "3DES" || algo == "DES-EDE")
       {
       return std::unique_ptr<BlockCipher>(new TripleDES);
       }
 #endif
 
 #if defined(BOTAN_HAS_NOEKEON)
    if(algo == "Noekeon")
       {
       return std::unique_ptr<BlockCipher>(new Noekeon);
       }
 #endif
 
 #if defined(BOTAN_HAS_CAST)
    if(algo == "CAST-128" || algo == "CAST5")
       {
       return std::unique_ptr<BlockCipher>(new CAST_128);
       }
 
    if(algo == "CAST-256")
       {
       return std::unique_ptr<BlockCipher>(new CAST_256);
       }
 #endif
 
 #if defined(BOTAN_HAS_IDEA)
    if(algo == "IDEA")
       {
       return std::unique_ptr<BlockCipher>(new IDEA);
       }
 #endif
 
 #if defined(BOTAN_HAS_KASUMI)
    if(algo == "KASUMI")
       {
       return std::unique_ptr<BlockCipher>(new KASUMI);
       }
 #endif
 
 #if defined(BOTAN_HAS_MISTY1)
    if(algo == "MISTY1")
       {
       return std::unique_ptr<BlockCipher>(new MISTY1);
       }
 #endif
 
 #if defined(BOTAN_HAS_SEED)
    if(algo == "SEED")
       {
       return std::unique_ptr<BlockCipher>(new SEED);
       }
 #endif
 
 #if defined(BOTAN_HAS_XTEA)
    if(algo == "XTEA")
       {
       return std::unique_ptr<BlockCipher>(new XTEA);
       }
 #endif
 
    const SCAN_Name req(algo);
 
 #if defined(BOTAN_HAS_GOST_28147_89)
    if(req.algo_name() == "GOST-28147-89")
       {
       return std::unique_ptr<BlockCipher>(new GOST_28147_89(req.arg(0, "R3411_94_TestParam")));
       }
 #endif
 
 #if defined(BOTAN_HAS_CASCADE)
    if(req.algo_name() == "Cascade" && req.arg_count() == 2)
       {
       std::unique_ptr<BlockCipher> c1(BlockCipher::create(req.arg(0)));
       std::unique_ptr<BlockCipher> c2(BlockCipher::create(req.arg(1)));
 
       if(c1 && c2)
          return std::unique_ptr<BlockCipher>(new Cascade_Cipher(c1.release(), c2.release()));
       }
 #endif
 
 #if defined(BOTAN_HAS_LION)
    if(req.algo_name() == "Lion" && req.arg_count_between(2, 3))
       {
       std::unique_ptr<HashFunction> hash(HashFunction::create(req.arg(0)));
       std::unique_ptr<StreamCipher> stream(StreamCipher::create(req.arg(1)));
 
       if(hash && stream)
          {
          const size_t block_size = req.arg_as_integer(2, 1024);
          return std::unique_ptr<BlockCipher>(new Lion(hash.release(), stream.release(), block_size));
          }
       }
 #endif
 
    BOTAN_UNUSED(req);
    BOTAN_UNUSED(provider);
 
    return nullptr;
    }

◆ create_or_throw()

std::unique_ptr< BlockCipher > Botan::BlockCipher::create_or_throw	(	const std::string &	algo_spec,
		const std::string &	provider = `""`
	)

staticinherited

Create an instance based on a name, or throw if the algo/provider combination cannot be found. If provider is empty then best available is chosen.

Definition at line 285 of file block_cipher.cpp.

References Botan::BlockCipher::create().

Referenced by Botan::make_block_cipher(), Botan::rfc3394_keyunwrap(), Botan::rfc3394_keywrap(), and Botan::TLS::TLS_CBC_HMAC_AEAD_Mode::TLS_CBC_HMAC_AEAD_Mode().

    {
    if(auto bc = BlockCipher::create(algo, provider))
       {
       return bc;
       }
    throw Lookup_Error("Block cipher", algo, provider);
    }

◆ decrypt() [1/4]

void Botan::BlockCipher::decrypt	(	const uint8_t	in[],
		uint8_t	out[]
	)		const

inlineinherited

Decrypt a block.

Parameters

in	The ciphertext block to be decypted as a byte array. Must be of length block_size().
out	The byte array designated to hold the decrypted block. Must be of length block_size().

Definition at line 90 of file block_cipher.h.

Referenced by Botan::DESX::decrypt_n(), Botan::XTS_Decryption::finish(), Botan::TLS::TLS_CBC_HMAC_AEAD_Encryption::finish(), and Botan::CTS_Decryption::finish().

91 { decrypt_n(in, out, 1); }

Botan::BlockCipher::decrypt_n

virtual void decrypt_n(const uint8_t in[], uint8_t out[], size_t blocks) const =0

◆ decrypt() [2/4]

void Botan::BlockCipher::decrypt ( uint8_t block[] ) const

inlineinherited

Decrypt a block.

Parameters

block the ciphertext block to be decrypted Must be of length block_size(). Will hold the result when the function has finished.

Definition at line 107 of file block_cipher.h.

107 { decrypt_n(block, block, 1); }

Botan::BlockCipher::decrypt_n

virtual void decrypt_n(const uint8_t in[], uint8_t out[], size_t blocks) const =0

◆ decrypt() [3/4]

template<typename Alloc >

void Botan::BlockCipher::decrypt ( std::vector< uint8_t, Alloc > & block ) const

inlineinherited

Decrypt one or more blocks

Parameters

block the input/output buffer (multiple of block_size())

Definition at line 124 of file block_cipher.h.

          {
          return decrypt_n(block.data(), block.data(), block.size() / block_size());
          }

◆ decrypt() [4/4]

template<typename Alloc , typename Alloc2 >

void Botan::BlockCipher::decrypt	(	const std::vector< uint8_t, Alloc > &	in,
		std::vector< uint8_t, Alloc2 > &	out
	)		const

inlineinherited

Decrypt one or more blocks

Parameters

in	the input buffer (multiple of block_size())
out	the output buffer (same size as in)

Definition at line 147 of file block_cipher.h.

          {
          return decrypt_n(in.data(), out.data(), in.size() / block_size());
          }

◆ decrypt_n()

void Botan::GOST_28147_89::decrypt_n	(	const uint8_t	in[],
		uint8_t	out[],
		size_t	blocks
	)		const

overridevirtual

Decrypt one or more blocks

Parameters

in	the input buffer (multiple of block_size())
out	the output buffer (same size as in)
blocks	the number of blocks to process

Implements Botan::BlockCipher.

Definition at line 135 of file gost_28147.cpp.

References Botan::Block_Cipher_Fixed_Params< 8, 32 >::BLOCK_SIZE, GOST_2ROUND, Botan::load_le< uint32_t >(), and Botan::store_le().

    {
    for(size_t i = 0; i != blocks; ++i)
       {
       uint32_t N1 = load_le<uint32_t>(in, 0);
       uint32_t N2 = load_le<uint32_t>(in, 1);
 
       GOST_2ROUND(N1, N2, 0, 1);
       GOST_2ROUND(N1, N2, 2, 3);
       GOST_2ROUND(N1, N2, 4, 5);
       GOST_2ROUND(N1, N2, 6, 7);
 
       for(size_t j = 0; j != 3; ++j)
          {
          GOST_2ROUND(N1, N2, 7, 6);
          GOST_2ROUND(N1, N2, 5, 4);
          GOST_2ROUND(N1, N2, 3, 2);
          GOST_2ROUND(N1, N2, 1, 0);
          }
 
       store_le(out, N2, N1);
       in += BLOCK_SIZE;
       out += BLOCK_SIZE;
       }
    }

◆ encrypt() [1/4]

void Botan::BlockCipher::encrypt	(	const uint8_t	in[],
		uint8_t	out[]
	)		const

inlineinherited

Encrypt a block.

Parameters

in	The plaintext block to be encrypted as a byte array. Must be of length block_size().
out	The byte array designated to hold the encrypted block. Must be of length block_size().

Definition at line 80 of file block_cipher.h.

Referenced by Botan::aont_package(), Botan::aont_unpackage(), Botan::GOST_34_11::clear(), Botan::DESX::encrypt_n(), Botan::XTS_Encryption::finish(), Botan::CTS_Encryption::finish(), Botan::CFB_Encryption::process(), Botan::CBC_Encryption::process(), Botan::CFB_Decryption::process(), Botan::TLS::TLS_CBC_HMAC_AEAD_Encryption::set_associated_data(), and Botan::CFB_Mode::valid_nonce_length().

81 { encrypt_n(in, out, 1); }

Botan::BlockCipher::encrypt_n

virtual void encrypt_n(const uint8_t in[], uint8_t out[], size_t blocks) const =0

◆ encrypt() [2/4]

void Botan::BlockCipher::encrypt ( uint8_t block[] ) const

inlineinherited

Encrypt a block.

Parameters

block the plaintext block to be encrypted Must be of length block_size(). Will hold the result when the function has finished.

Definition at line 99 of file block_cipher.h.

99 { encrypt_n(block, block, 1); }

Botan::BlockCipher::encrypt_n

virtual void encrypt_n(const uint8_t in[], uint8_t out[], size_t blocks) const =0

◆ encrypt() [3/4]

template<typename Alloc >

void Botan::BlockCipher::encrypt ( std::vector< uint8_t, Alloc > & block ) const

inlineinherited

Encrypt one or more blocks

Parameters

block the input/output buffer (multiple of block_size())

Definition at line 114 of file block_cipher.h.

          {
          return encrypt_n(block.data(), block.data(), block.size() / block_size());
          }

◆ encrypt() [4/4]

template<typename Alloc , typename Alloc2 >

void Botan::BlockCipher::encrypt	(	const std::vector< uint8_t, Alloc > &	in,
		std::vector< uint8_t, Alloc2 > &	out
	)		const

inlineinherited

Encrypt one or more blocks

Parameters

in	the input buffer (multiple of block_size())
out	the output buffer (same size as in)

Definition at line 135 of file block_cipher.h.

          {
          return encrypt_n(in.data(), out.data(), in.size() / block_size());
          }

◆ encrypt_n()

void Botan::GOST_28147_89::encrypt_n	(	const uint8_t	in[],
		uint8_t	out[],
		size_t	blocks
	)		const

overridevirtual

Encrypt one or more blocks

Parameters

in	the input buffer (multiple of block_size())
out	the output buffer (same size as in)
blocks	the number of blocks to process

Implements Botan::BlockCipher.

Definition at line 105 of file gost_28147.cpp.

References Botan::Block_Cipher_Fixed_Params< 8, 32 >::BLOCK_SIZE, GOST_2ROUND, Botan::load_le< uint32_t >(), and Botan::store_le().

    {
    for(size_t i = 0; i != blocks; ++i)
       {
       uint32_t N1 = load_le<uint32_t>(in, 0);
       uint32_t N2 = load_le<uint32_t>(in, 1);
 
       for(size_t j = 0; j != 3; ++j)
          {
          GOST_2ROUND(N1, N2, 0, 1);
          GOST_2ROUND(N1, N2, 2, 3);
          GOST_2ROUND(N1, N2, 4, 5);
          GOST_2ROUND(N1, N2, 6, 7);
          }
 
       GOST_2ROUND(N1, N2, 7, 6);
       GOST_2ROUND(N1, N2, 5, 4);
       GOST_2ROUND(N1, N2, 3, 2);
       GOST_2ROUND(N1, N2, 1, 0);
 
       store_le(out, N2, N1);
 
       in += BLOCK_SIZE;
       out += BLOCK_SIZE;
       }
    }

◆ key_spec()

Key_Length_Specification Botan::Block_Cipher_Fixed_Params< BS, KMIN, 0 , 1 >::key_spec ( ) const

inlineoverridevirtualinherited

Returns: object describing limits on key size

Implements Botan::SymmetricAlgorithm.

Definition at line 189 of file block_cipher.h.

          {
          return Key_Length_Specification(KMIN, KMAX, KMOD);
          }

◆ maximum_keylength()

size_t Botan::SymmetricAlgorithm::maximum_keylength ( ) const

inlineinherited

Returns: minimum allowed key length

Definition at line 39 of file sym_algo.h.

          {
          return key_spec().maximum_keylength();
          }

◆ minimum_keylength()

size_t Botan::SymmetricAlgorithm::minimum_keylength ( ) const

inlineinherited

Returns: maximum allowed key length

Definition at line 47 of file sym_algo.h.

          {
          return key_spec().minimum_keylength();
          }

◆ name()

std::string Botan::GOST_28147_89::name ( ) const

overridevirtual

Returns: the algorithm name

Implements Botan::SymmetricAlgorithm.

Definition at line 65 of file gost_28147.cpp.

    {
    /*
    'Guess' the right name for the sbox on the basis of the values.
    This would need to be updated if support for other sbox parameters
    is added. Preferably, we would just store the string value in the
    constructor, but can't break binary compat.
    */
    std::string sbox_name = "";
    if(m_SBOX[0] == 0x00072000)
       sbox_name = "R3411_94_TestParam";
    else if(m_SBOX[0] == 0x0002D000)
       sbox_name = "R3411_CryptoPro";
    else
       throw Internal_Error("GOST-28147 unrecognized sbox value");
 
    return "GOST-28147-89(" + sbox_name + ")";
    }

◆ parallel_bytes()

size_t Botan::BlockCipher::parallel_bytes ( ) const

inlineinherited

Returns: prefererred parallelism of this cipher in bytes

Definition at line 62 of file block_cipher.h.

Referenced by Botan::XTS_Mode::update_granularity(), and Botan::CBC_Mode::update_granularity().

          {
          return parallelism() * block_size() * BOTAN_BLOCK_CIPHER_PAR_MULT;
          }

◆ parallelism()

virtual size_t Botan::BlockCipher::parallelism ( ) const

inlinevirtualinherited

Returns: native parallelism of this cipher in blocks

Reimplemented in Botan::Serpent.

Definition at line 57 of file block_cipher.h.

57 { return 1; }

◆ provider()

virtual std::string Botan::BlockCipher::provider ( ) const

inlinevirtualinherited

Returns: provider information about this implementation. Default is "base", might also return "sse2", "avx2", "openssl", or some other arbitrary string.

Reimplemented in Botan::AES_256, Botan::AES_192, Botan::Threefish_512, Botan::AES_128, Botan::IDEA, Botan::Serpent, and Botan::Noekeon.

Definition at line 71 of file block_cipher.h.

71 { return "base"; }

◆ providers()

std::vector< std::string > Botan::BlockCipher::providers ( const std::string & algo_spec )

staticinherited

Returns: list of available providers for this algorithm, empty if not available

Parameters

algo_spec algorithm name

Definition at line 295 of file block_cipher.cpp.

Referenced by Botan::TLS::Ciphersuite::by_id(), and Botan::get_block_cipher_providers().

    {
    return probe_providers_of<BlockCipher>(algo, { "base", "openssl" });
    }

◆ set_key() [1/3]

void Botan::SymmetricAlgorithm::set_key ( const SymmetricKey & key )

inlineinherited

Set the symmetric key of this object.

Parameters

key	the SymmetricKey to be set.

Definition at line 66 of file sym_algo.h.

References Botan::OctetString::begin(), and Botan::OctetString::length().

Referenced by Botan::aont_package(), Botan::aont_unpackage(), botan_block_cipher_set_key(), botan_mac_set_key(), Botan::GOST_34_11::clear(), Botan::DESX::decrypt_n(), Botan::TLS::TLS_CBC_HMAC_AEAD_Mode::key_spec(), Botan::pbkdf2(), and Botan::TLS_PRF::TLS_PRF().

          {
          set_key(key.begin(), key.length());
          }

◆ set_key() [2/3]

template<typename Alloc >

void Botan::SymmetricAlgorithm::set_key ( const std::vector< uint8_t, Alloc > & key )

inlineinherited

Definition at line 72 of file sym_algo.h.

          {
          set_key(key.data(), key.size());
          }

◆ set_key() [3/3]

void Botan::SymmetricAlgorithm::set_key	(	const uint8_t	key[],
		size_t	length
	)

inlineinherited

Set the symmetric key of this object.

Parameters

key	the to be set as a byte array.
length	in bytes of key param

Definition at line 82 of file sym_algo.h.

          {
          if(!valid_keylength(length))
             throw Invalid_Key_Length(name(), length);
          key_schedule(key, length);
          }

◆ valid_keylength()

bool Botan::SymmetricAlgorithm::valid_keylength ( size_t length ) const

inlineinherited

Check whether a given key length is valid for this algorithm.

Parameters

length the key length to be checked.

Returns: true if the key length is valid.

Definition at line 57 of file sym_algo.h.

Referenced by Botan::aont_package(), and Botan::aont_unpackage().

          {
          return key_spec().valid_keylength(length);
          }

The documentation for this class was generated from the following files:

src/lib/block/gost_28147/gost_28147.h
src/lib/block/gost_28147/gost_28147.cpp

Public Types

Public Member Functions

Static Public Member Functions

Detailed Description

Member Enumeration Documentation

◆ anonymous enum

Constructor & Destructor Documentation

◆ GOST_28147_89()

Member Function Documentation

◆ block_size()

◆ clear()

◆ clone()

◆ create()

◆ create_or_throw()

◆ decrypt() [1/4]

◆ decrypt() [2/4]

◆ decrypt() [3/4]

◆ decrypt() [4/4]

◆ decrypt_n()

◆ encrypt() [1/4]

◆ encrypt() [2/4]

◆ encrypt() [3/4]

◆ encrypt() [4/4]

◆ encrypt_n()

◆ key_spec()

◆ maximum_keylength()

◆ minimum_keylength()

◆ name()

◆ parallel_bytes()

◆ parallelism()

◆ provider()

◆ providers()

◆ set_key() [1/3]

◆ set_key() [2/3]

◆ set_key() [3/3]

◆ valid_keylength()