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="")
	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 587 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 144 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().

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
rng	the RNG to use
kem_param	additional KEM parameters
provider	the provider to use

Definition at line 151 of file pubkey.cpp.

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

References BOTAN_UNUSED.

~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

PK_KEM_Encryptor() [4/4]

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

defaultnoexcept

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 168 of file pubkey.cpp.

                                                       {
   return m_op->encapsulated_key_length();
}

Referenced by encrypt().

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

rng	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 650 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));
      }

Referenced by Botan::Kyber_PrivateKey::check_key(), 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
rng	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 670 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 697 of file pubkey.h.

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

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 707 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);
      }

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
rng	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 172 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

operator=() [2/2]

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

defaultnoexcept

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 164 of file pubkey.cpp.

                                                                              {
   return m_op->shared_key_length(desired_shared_key_len);
}

References shared_key_length().

Referenced by encrypt(), 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