Botan::PK_KEM_Encryptor Class Reference

#include <pubkey.h>

Public Member Functions
size_t	encapsulated_key_length () const
KEM_Encapsulation	encrypt (RandomNumberGenerator &rng, size_t desired_shared_key_len=32, std::span< const uint8_t > salt={})
void	encrypt (secure_vector< uint8_t > &out_encapsulated_key, secure_vector< uint8_t > &out_shared_key, RandomNumberGenerator &rng, size_t desired_shared_key_len=32, std::span< const uint8_t > salt={})
void	encrypt (secure_vector< uint8_t > &out_encapsulated_key, secure_vector< uint8_t > &out_shared_key, size_t desired_shared_key_len, RandomNumberGenerator &rng, const uint8_t salt[], size_t salt_len)
void	encrypt (secure_vector< uint8_t > &out_encapsulated_key, secure_vector< uint8_t > &out_shared_key, size_t desired_shared_key_len, RandomNumberGenerator &rng, std::span< const uint8_t > salt={})
void	encrypt (std::span< uint8_t > out_encapsulated_key, std::span< uint8_t > out_shared_key, RandomNumberGenerator &rng, size_t desired_shared_key_len=32, std::span< const uint8_t > salt={})
PK_KEM_Encryptor &	operator= (const PK_KEM_Encryptor &)=delete
PK_KEM_Encryptor &	operator= (PK_KEM_Encryptor &&) noexcept
	PK_KEM_Encryptor (const PK_KEM_Encryptor &)=delete
	PK_KEM_Encryptor (const Public_Key &key, RandomNumberGenerator &rng, std::string_view kem_param="", std::string_view provider="")
BOTAN_FUTURE_EXPLICIT	PK_KEM_Encryptor (const Public_Key &key, std::string_view kem_param="", std::string_view provider="")
	PK_KEM_Encryptor (PK_KEM_Encryptor &&) noexcept
size_t	shared_key_length (size_t desired_shared_key_len) const
	~PK_KEM_Encryptor ()

Detailed Description

Public Key Key Encapsulation Mechanism Encryption.

Definition at line 607 of file pubkey.h.

Constructor & Destructor Documentation

PK_KEM_Encryptor() [1/4]

Botan::PK_KEM_Encryptor::PK_KEM_Encryptor	(	const Public_Key &	key,
		std::string_view	kem_param = "",
		std::string_view	provider = "" )

Construct an instance.

Parameters

key	the key to encrypt to
kem_param	additional KEM parameters
provider	the provider to use

Definition at line 146 of file pubkey.cpp.

                                                                                                       {
   m_op = key.create_kem_encryption_op(param, provider);
   if(!m_op) {
      throw Invalid_Argument(fmt("Key type {} does not support KEM encryption", key.algo_name()));
   }
}

References Botan::Asymmetric_Key::algo_name(), Botan::Public_Key::create_kem_encryption_op(), and Botan::fmt().

Referenced by operator=(), operator=(), PK_KEM_Encryptor(), PK_KEM_Encryptor(), PK_KEM_Encryptor(), and shared_key_length().

PK_KEM_Encryptor() [2/4]

Botan::PK_KEM_Encryptor::PK_KEM_Encryptor	(	const Public_Key &	key,
		RandomNumberGenerator &	rng,
		std::string_view	kem_param = "",
		std::string_view	provider = "" )

Construct an instance.

Parameters

key	the key to encrypt to
Random Number Generators	the RNG to use
kem_param	additional KEM parameters
provider	the provider to use

Definition at line 153 of file pubkey.cpp.

                                                            :
      PK_KEM_Encryptor(key, kem_param, provider) {
   BOTAN_UNUSED(rng);
}

References BOTAN_UNUSED, and PK_KEM_Encryptor().

~PK_KEM_Encryptor()

Botan::PK_KEM_Encryptor::~PK_KEM_Encryptor ( )

default

PK_KEM_Encryptor() [3/4]

Botan::PK_KEM_Encryptor::PK_KEM_Encryptor ( const PK_KEM_Encryptor & )

delete

References PK_KEM_Encryptor().

PK_KEM_Encryptor() [4/4]

Botan::PK_KEM_Encryptor::PK_KEM_Encryptor ( PK_KEM_Encryptor && )

defaultnoexcept

References PK_KEM_Encryptor().

Member Function Documentation

encapsulated_key_length()

size_t Botan::PK_KEM_Encryptor::encapsulated_key_length

(

)

const

Return the length in bytes of encapsulated keys returned by this KEM

Definition at line 170 of file pubkey.cpp.

                                                       {
   return m_op->encapsulated_key_length();
}

Referenced by encrypt(), and operator=().

encrypt() [1/5]

KEM_Encapsulation Botan::PK_KEM_Encryptor::encrypt ( RandomNumberGenerator & rng, size_t desired_shared_key_len = 32, std::span< const uint8_t > salt = {} )

inline

Generate a shared key for data encryption.

Parameters

Random Number Generators	the RNG to use
desired_shared_key_len	desired size of the shared key in bytes for the KDF (ignored if no KDF is used)
salt	a salt value used in the KDF (ignored if no KDF is used)

Returns

a struct with both the shared secret and its encapsulation

Definition at line 672 of file pubkey.h.

                                                            {}) {
         std::vector<uint8_t> encapsulated_shared_key(encapsulated_key_length());
         secure_vector<uint8_t> shared_key(shared_key_length(desired_shared_key_len));
 
         encrypt(std::span{encapsulated_shared_key}, std::span{shared_key}, rng, desired_shared_key_len, salt);
         return KEM_Encapsulation(std::move(encapsulated_shared_key), std::move(shared_key));
      }

References encrypt().

Referenced by Botan::FrodoKEM_PrivateKey::check_key(), Botan::Kyber_PrivateKey::check_key(), encrypt(), encrypt(), encrypt(), and Botan::TLS::Callbacks::tls_kem_encapsulate().

encrypt() [2/5]

void Botan::PK_KEM_Encryptor::encrypt ( secure_vector< uint8_t > & out_encapsulated_key, secure_vector< uint8_t > & out_shared_key, RandomNumberGenerator & rng, size_t desired_shared_key_len = 32, std::span< const uint8_t > salt = {} )

inline

Generate a shared key for data encryption.

Parameters

out_encapsulated_key	the generated encapsulated key
out_shared_key	the generated shared key
Random Number Generators	the RNG to use
desired_shared_key_len	desired size of the shared key in bytes (ignored if no KDF is used)
salt	a salt value used in the KDF (ignored if no KDF is used)

Definition at line 692 of file pubkey.h.

                                               {}) {
         out_encapsulated_key.resize(encapsulated_key_length());
         out_shared_key.resize(shared_key_length(desired_shared_key_len));
         encrypt(std::span{out_encapsulated_key}, std::span{out_shared_key}, rng, desired_shared_key_len, salt);
      }

encrypt() [3/5]

void Botan::PK_KEM_Encryptor::encrypt ( secure_vector< uint8_t > & out_encapsulated_key, secure_vector< uint8_t > & out_shared_key, size_t desired_shared_key_len, RandomNumberGenerator & rng, const uint8_t salt[], size_t salt_len )

inline

Definition at line 719 of file pubkey.h.

                                    {
         this->encrypt(out_encapsulated_key, out_shared_key, rng, desired_shared_key_len, {salt, salt_len});
      }

References encrypt().

encrypt() [4/5]

void Botan::PK_KEM_Encryptor::encrypt ( secure_vector< uint8_t > & out_encapsulated_key, secure_vector< uint8_t > & out_shared_key, size_t desired_shared_key_len, RandomNumberGenerator & rng, std::span< const uint8_t > salt = {} )

inline

Definition at line 729 of file pubkey.h.

                                               {}) {
         out_encapsulated_key.resize(encapsulated_key_length());
         out_shared_key.resize(shared_key_length(desired_shared_key_len));
         encrypt(out_encapsulated_key, out_shared_key, rng, desired_shared_key_len, salt);
      }

References encrypt().

encrypt() [5/5]

void Botan::PK_KEM_Encryptor::encrypt	(	std::span< uint8_t >	out_encapsulated_key,
		std::span< uint8_t >	out_shared_key,
		RandomNumberGenerator &	rng,
		size_t	desired_shared_key_len = 32,
		std::span< const uint8_t >	salt = {} )

Generate a shared key for data encryption.

Parameters

out_encapsulated_key	the generated encapsulated key
out_shared_key	the generated shared key
Random Number Generators	the RNG to use
desired_shared_key_len	desired size of the shared key in bytes (ignored if no KDF is used)
salt	a salt value used in the KDF (ignored if no KDF is used)

Definition at line 174 of file pubkey.cpp.

                                                            {
   BOTAN_ARG_CHECK(out_encapsulated_key.size() == encapsulated_key_length(), "not enough space for encapsulated key");
   BOTAN_ARG_CHECK(out_shared_key.size() == shared_key_length(desired_shared_key_len),
                   "not enough space for shared key");
   m_op->kem_encrypt(out_encapsulated_key, out_shared_key, rng, desired_shared_key_len, salt);
}

References BOTAN_ARG_CHECK, encapsulated_key_length(), and shared_key_length().

operator=() [1/2]

PK_KEM_Encryptor & Botan::PK_KEM_Encryptor::operator= ( const PK_KEM_Encryptor & )

delete

References PK_KEM_Encryptor().

operator=() [2/2]

PK_KEM_Encryptor & Botan::PK_KEM_Encryptor::operator= ( PK_KEM_Encryptor && )

defaultnoexcept

References encapsulated_key_length(), PK_KEM_Encryptor(), and shared_key_length().

shared_key_length()

size_t Botan::PK_KEM_Encryptor::shared_key_length

(

size_t

desired_shared_key_len

)

const

Return the length of the shared key returned by this KEM

If this KEM was used with a KDF, then it will always return exactly the desired key length, because the output of the KEM will be hashed by the KDF.

However if the KEM was used with "Raw" kdf, to request the algorithmic output of the KEM directly, then the desired key length will be ignored and a bytestring that depends on the algorithm is returned

Parameters

desired_shared_key_len

is the requested length

Definition at line 166 of file pubkey.cpp.

                                                                              {
   return m_op->shared_key_length(desired_shared_key_len);
}

References PK_KEM_Encryptor(), and shared_key_length().

Referenced by encrypt(), operator=(), and shared_key_length().

---

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

• src/lib/pubkey/pubkey.h
• src/lib/pubkey/pubkey.cpp