#include <sp800_56c_one_step.h>

Inheritance diagram for Botan::SP800_56A_One_Step_KMAC_Abstract:

Public Member Functions
KDF *	clone () const

template<concepts::resizable_byte_buffer T = secure_vector<uint8_t>>
T	derive_key (size_t key_len, const uint8_t secret[], size_t secret_len, const uint8_t salt[], size_t salt_len, const uint8_t label[]=nullptr, size_t label_len=0) const

template<concepts::resizable_byte_buffer T = secure_vector<uint8_t>>
T	derive_key (size_t key_len, const uint8_t secret[], size_t secret_len, std::string_view salt="", std::string_view label="") const

template<concepts::resizable_byte_buffer T = secure_vector<uint8_t>>
T	derive_key (size_t key_len, std::span< const uint8_t > secret, const uint8_t salt[], size_t salt_len, std::string_view label="") const

template<concepts::resizable_byte_buffer T = secure_vector<uint8_t>>
T	derive_key (size_t key_len, std::span< const uint8_t > secret, std::span< const uint8_t > salt, std::span< const uint8_t > label) const

template<concepts::resizable_byte_buffer T = secure_vector<uint8_t>>
T	derive_key (size_t key_len, std::span< const uint8_t > secret, std::string_view salt="", std::string_view label="") const

template<size_t key_len>
std::array< uint8_t, key_len >	derive_key (std::span< const uint8_t > secret, std::span< const uint8_t > salt={}, std::span< const uint8_t > label={})

template<size_t key_len>
std::array< uint8_t, key_len >	derive_key (std::span< const uint8_t > secret, std::span< const uint8_t > salt={}, std::string_view label="")

template<size_t key_len>
std::array< uint8_t, key_len >	derive_key (std::span< const uint8_t > secret, std::string_view salt="", std::string_view label="")

void	derive_key (std::span< uint8_t > key, std::span< const uint8_t > secret, std::span< const uint8_t > salt, std::span< const uint8_t > label) const

void	kdf (uint8_t key[], size_t key_len, const uint8_t secret[], size_t secret_len, const uint8_t salt[], size_t salt_len, const uint8_t label[], size_t label_len) const

virtual std::string	name () const =0

virtual std::unique_ptr< KDF >	new_object () const =0

Static Public Member Functions
static std::unique_ptr< KDF >	create (std::string_view algo_spec, std::string_view provider="")

static std::unique_ptr< KDF >	create_or_throw (std::string_view algo_spec, std::string_view provider="")

static std::vector< std::string >	providers (std::string_view algo_spec)

Protected Member Functions
virtual std::unique_ptr< MessageAuthenticationCode >	create_kmac_instance (size_t output_byte_len) const =0

virtual size_t	default_salt_length () const =0
	See SP800-56C Section 4.1 - Implementation-Dependent Parameters 3.

Detailed Description

NIST SP800-56Cr2 One-Step KDF using KMAC (Abstract class)

Definition at line 93 of file sp800_56c_one_step.h.

Member Function Documentation

◆ clone()

KDF * Botan::KDF::clone ( ) const

inlineinherited

Returns: new object representing the same algorithm as *this

Definition at line 250 of file kdf.h.

250{ return this->new_object().release(); }

Botan::KDF::new_object

virtual std::unique_ptr< KDF > new_object() const =0

◆ create()

std::unique_ptr< KDF > Botan::KDF::create	(	std::string_view	algo_spec,
		std::string_view	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 71 of file kdf.cpp.

                                                                                {
   const SCAN_Name req(algo_spec);
 
#if defined(BOTAN_HAS_HKDF)
   if(req.algo_name() == "HKDF" && req.arg_count() == 1) {
      if(provider.empty() || provider == "base") {
         return kdf_create_mac_or_hash<HKDF>(req.arg(0));
      }
   }
 
   if(req.algo_name() == "HKDF-Extract" && req.arg_count() == 1) {
      if(provider.empty() || provider == "base") {
         return kdf_create_mac_or_hash<HKDF_Extract>(req.arg(0));
      }
   }
 
   if(req.algo_name() == "HKDF-Expand" && req.arg_count() == 1) {
      if(provider.empty() || provider == "base") {
         return kdf_create_mac_or_hash<HKDF_Expand>(req.arg(0));
      }
   }
#endif
 
#if defined(BOTAN_HAS_KDF2)
   if(req.algo_name() == "KDF2" && req.arg_count() == 1) {
      if(provider.empty() || provider == "base") {
         if(auto hash = HashFunction::create(req.arg(0))) {
            return std::make_unique<KDF2>(std::move(hash));
         }
      }
   }
#endif
 
#if defined(BOTAN_HAS_KDF1_18033)
   if(req.algo_name() == "KDF1-18033" && req.arg_count() == 1) {
      if(provider.empty() || provider == "base") {
         if(auto hash = HashFunction::create(req.arg(0))) {
            return std::make_unique<KDF1_18033>(std::move(hash));
         }
      }
   }
#endif
 
#if defined(BOTAN_HAS_KDF1)
   if(req.algo_name() == "KDF1" && req.arg_count() == 1) {
      if(provider.empty() || provider == "base") {
         if(auto hash = HashFunction::create(req.arg(0))) {
            return std::make_unique<KDF1>(std::move(hash));
         }
      }
   }
#endif
 
#if defined(BOTAN_HAS_TLS_V12_PRF)
   if(req.algo_name() == "TLS-12-PRF" && req.arg_count() == 1) {
      if(provider.empty() || provider == "base") {
         return kdf_create_mac_or_hash<TLS_12_PRF>(req.arg(0));
      }
   }
#endif
 
#if defined(BOTAN_HAS_X942_PRF)
   if(req.algo_name() == "X9.42-PRF" && req.arg_count() == 1) {
      if(provider.empty() || provider == "base") {
         return std::make_unique<X942_PRF>(req.arg(0));
      }
   }
#endif
 
#if defined(BOTAN_HAS_SP800_108)
   if(req.algo_name() == "SP800-108-Counter" && req.arg_count_between(1, 3)) {
      if(provider.empty() || provider == "base") {
         return kdf_create_mac_or_hash<SP800_108_Counter>(
            req.arg(0), req.arg_as_integer(1, 32), req.arg_as_integer(2, 32));
      }
   }
 
   if(req.algo_name() == "SP800-108-Feedback" && req.arg_count_between(1, 3)) {
      if(provider.empty() || provider == "base") {
         return kdf_create_mac_or_hash<SP800_108_Feedback>(
            req.arg(0), req.arg_as_integer(1, 32), req.arg_as_integer(2, 32));
      }
   }
 
   if(req.algo_name() == "SP800-108-Pipeline" && req.arg_count_between(1, 3)) {
      if(provider.empty() || provider == "base") {
         return kdf_create_mac_or_hash<SP800_108_Pipeline>(
            req.arg(0), req.arg_as_integer(1, 32), req.arg_as_integer(2, 32));
      }
   }
#endif
 
#if defined(BOTAN_HAS_SP800_56A)
   if(req.algo_name() == "SP800-56A" && req.arg_count() == 1) {
      if(auto hash = HashFunction::create(req.arg(0))) {
         return std::make_unique<SP800_56C_One_Step_Hash>(std::move(hash));
      }
      if(req.arg(0) == "KMAC-128") {
         return std::make_unique<SP800_56C_One_Step_KMAC128>();
      }
      if(req.arg(0) == "KMAC-256") {
         return std::make_unique<SP800_56C_One_Step_KMAC256>();
      }
      if(auto mac = MessageAuthenticationCode::create(req.arg(0))) {
         return std::make_unique<SP800_56C_One_Step_HMAC>(std::move(mac));
      }
   }
#endif
 
#if defined(BOTAN_HAS_SP800_56C)
   if(req.algo_name() == "SP800-56C" && req.arg_count() == 1) {
      std::unique_ptr<KDF> exp(kdf_create_mac_or_hash<SP800_108_Feedback>(req.arg(0), 32, 32));
      if(exp) {
         if(auto mac = MessageAuthenticationCode::create(req.arg(0))) {
            return std::make_unique<SP800_56C_Two_Step>(std::move(mac), std::move(exp));
         }
 
         if(auto mac = MessageAuthenticationCode::create(fmt("HMAC({})", req.arg(0)))) {
            return std::make_unique<SP800_56C_Two_Step>(std::move(mac), std::move(exp));
         }
      }
   }
#endif
 
   BOTAN_UNUSED(req);
   BOTAN_UNUSED(provider);
 
   return nullptr;
}

References Botan::SCAN_Name::algo_name(), Botan::SCAN_Name::arg(), Botan::SCAN_Name::arg_as_integer(), Botan::SCAN_Name::arg_count(), Botan::SCAN_Name::arg_count_between(), BOTAN_UNUSED, Botan::HashFunction::create(), Botan::MessageAuthenticationCode::create(), and Botan::fmt().

Referenced by Botan::KDF::create_or_throw(), and Botan::get_kdf().

◆ create_kmac_instance()

virtual std::unique_ptr< MessageAuthenticationCode > Botan::SP800_56A_One_Step_KMAC_Abstract::create_kmac_instance ( size_t output_byte_len ) const

protectedpure virtual

◆ create_or_throw()

std::unique_ptr< KDF > Botan::KDF::create_or_throw	(	std::string_view	algo_spec,
		std::string_view	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 202 of file kdf.cpp.

                                                                                    {
   if(auto kdf = KDF::create(algo, provider)) {
      return kdf;
   }
   throw Lookup_Error("KDF", algo, provider);
}

References Botan::KDF::create(), and Botan::KDF::kdf().

Referenced by botan_kdf(), Botan::ECIES_KA_Operation::derive_secret(), Botan::PK_Ops::KEM_Decryption_with_KDF::KEM_Decryption_with_KDF(), Botan::PK_Ops::KEM_Encryption_with_KDF::KEM_Encryption_with_KDF(), Botan::PK_Ops::Key_Agreement_with_KDF::Key_Agreement_with_KDF(), and Botan::TLS::Handshake_State::protocol_specific_prf().

◆ default_salt_length()

virtual size_t Botan::SP800_56A_One_Step_KMAC_Abstract::default_salt_length ( ) const

protectedpure virtual

See SP800-56C Section 4.1 - Implementation-Dependent Parameters 3.

◆ derive_key() [1/9]

template<concepts::resizable_byte_buffer T = secure_vector<uint8_t>>

T Botan::KDF::derive_key	(	size_t	key_len,
		const uint8_t	secret[],
		size_t	secret_len,
		const uint8_t	salt[],
		size_t	salt_len,
		const uint8_t	label[] = nullptr,
		size_t	label_len = 0 ) const

inlineinherited

Derive a key

Parameters

key_len	the desired output length in bytes
secret	the secret input
secret_len	size of secret in bytes
salt	a diversifier
salt_len	size of salt in bytes
label	purpose for the derived keying material
label_len	size of label in bytes

Returns: the derived key

Definition at line 91 of file kdf.h.

                                               {
         return derive_key<T>(key_len, {secret, secret_len}, {salt, salt_len}, {label, label_len});
      }

Referenced by Botan::hkdf_expand_label().

◆ derive_key() [2/9]

template<concepts::resizable_byte_buffer T = secure_vector<uint8_t>>

T Botan::KDF::derive_key	(	size_t	key_len,
		const uint8_t	secret[],
		size_t	secret_len,
		std::string_view	salt = "",
		std::string_view	label = "" ) const

inlineinherited

Derive a key

Parameters

key_len	the desired output length in bytes
secret	the secret input
secret_len	size of secret in bytes
salt	a diversifier
label	purpose for the derived keying material

Returns: the derived key

Definition at line 182 of file kdf.h.

                                                    {
         return derive_key<T>(key_len,
                              {secret, secret_len},
                              {cast_char_ptr_to_uint8(salt.data()), salt.length()},
                              {cast_char_ptr_to_uint8(label.data()), label.length()});
      }

References Botan::cast_char_ptr_to_uint8().

◆ derive_key() [3/9]

template<concepts::resizable_byte_buffer T = secure_vector<uint8_t>>

T Botan::KDF::derive_key	(	size_t	key_len,
		std::span< const uint8_t >	secret,
		const uint8_t	salt[],
		size_t	salt_len,
		std::string_view	label = "" ) const

inlineinherited

Derive a key

Parameters

key_len	the desired output length in bytes
secret	the secret input
salt	a diversifier
salt_len	size of salt in bytes
label	purpose for the derived keying material

Returns: the derived key

Definition at line 163 of file kdf.h.

                                                    {
         return derive_key<T>(key_len, secret, {salt, salt_len}, {cast_char_ptr_to_uint8(label.data()), label.size()});
      }

References Botan::cast_char_ptr_to_uint8().

◆ derive_key() [4/9]

template<concepts::resizable_byte_buffer T = secure_vector<uint8_t>>

T Botan::KDF::derive_key	(	size_t	key_len,
		std::span< const uint8_t >	secret,
		std::span< const uint8_t >	salt,
		std::span< const uint8_t >	label ) const

inlineinherited

Derive a key

Parameters

key_len	the desired output length in bytes
secret	the secret input
salt	a diversifier
label	purpose for the derived keying material

Returns: the derived key

Definition at line 143 of file kdf.h.

                                                       {
         T key(key_len);
         perform_kdf(key, secret, salt, label);
         return key;
      }

References T.

◆ derive_key() [5/9]

template<concepts::resizable_byte_buffer T = secure_vector<uint8_t>>

T Botan::KDF::derive_key	(	size_t	key_len,
		std::span< const uint8_t >	secret,
		std::string_view	salt = "",
		std::string_view	label = "" ) const

inlineinherited

Derive a key

Parameters

key_len	the desired output length in bytes
secret	the secret input
salt	a diversifier
label	purpose for the derived keying material

Returns: the derived key

Definition at line 110 of file kdf.h.

                                                    {
         return derive_key<T>(key_len,
                              secret,
                              {cast_char_ptr_to_uint8(salt.data()), salt.length()},
                              {cast_char_ptr_to_uint8(label.data()), label.length()});
      }

References Botan::cast_char_ptr_to_uint8().

◆ derive_key() [6/9]

template<size_t key_len>

std::array< uint8_t, key_len > Botan::KDF::derive_key	(	std::span< const uint8_t >	secret,
		std::span< const uint8_t >	salt = {},
		std::span< const uint8_t >	label = {} )

inlineinherited

Derive a key

Template Parameters

key_len the desired output length in bytes

Parameters

secret	the secret input
salt	a diversifier
label	purpose for the derived keying material

Returns: the derived key

Definition at line 202 of file kdf.h.

                                                                            {},
                                              std::span<const uint8_t> label = {}) {
         std::array<uint8_t, key_len> key;
         perform_kdf(key, secret, salt, label);
         return key;
      }

◆ derive_key() [7/9]

template<size_t key_len>

std::array< uint8_t, key_len > Botan::KDF::derive_key	(	std::span< const uint8_t >	secret,
		std::span< const uint8_t >	salt = {},
		std::string_view	label = "" )

inlineinherited

Derive a key

Template Parameters

key_len the desired output length in bytes

Parameters

secret	the secret input
salt	a diversifier
label	purpose for the derived keying material

Returns: the derived key

Definition at line 219 of file kdf.h.

                                                                            {},
                                              std::string_view label = "") {
         return derive_key<key_len>(secret, salt, {cast_char_ptr_to_uint8(label.data()), label.size()});
      }

◆ derive_key() [8/9]

template<size_t key_len>

std::array< uint8_t, key_len > Botan::KDF::derive_key	(	std::span< const uint8_t >	secret,
		std::string_view	salt = "",
		std::string_view	label = "" )

inlineinherited

Derive a key

Template Parameters

key_len the desired output length in bytes

Parameters

secret	the secret input
salt	a diversifier
label	purpose for the derived keying material

Returns: the derived key

Definition at line 234 of file kdf.h.

                                                                         {
         return derive_key<key_len>(secret,
                                    {cast_char_ptr_to_uint8(salt.data()), salt.size()},
                                    {cast_char_ptr_to_uint8(label.data()), label.size()});
      }

References Botan::cast_char_ptr_to_uint8().

◆ derive_key() [9/9]

void Botan::KDF::derive_key	(	std::span< uint8_t >	key,
		std::span< const uint8_t >	secret,
		std::span< const uint8_t >	salt,
		std::span< const uint8_t >	label ) const

inlineinherited

Derive a key

Parameters

key	the output buffer for the to-be-derived key
secret	the secret input
salt	a diversifier
label	purpose for the derived keying material

Definition at line 127 of file kdf.h.

                                                          {
         perform_kdf(key, secret, salt, label);
      }

◆ kdf()

void Botan::KDF::kdf	(	uint8_t	key[],
		size_t	key_len,
		const uint8_t	secret[],
		size_t	secret_len,
		const uint8_t	salt[],
		size_t	salt_len,
		const uint8_t	label[],
		size_t	label_len ) const

inlineinherited

Derive a key

Parameters

key	buffer holding the derived key, must be of length key_len
key_len	the desired output length in bytes
secret	the secret input
secret_len	size of secret in bytes
salt	a diversifier
salt_len	size of salt in bytes
label	purpose for the derived keying material
label_len	size of label in bytes

Definition at line 67 of file kdf.h.

                                       {
         derive_key({key, key_len}, {secret, secret_len}, {salt, salt_len}, {label, label_len});
      }

Referenced by Botan::KDF::create_or_throw().

◆ name()

virtual std::string Botan::KDF::name ( ) const

pure virtualinherited

Returns: KDF name

Implemented in Botan::HKDF, Botan::HKDF_Expand, Botan::HKDF_Extract, Botan::KDF1, Botan::KDF1_18033, Botan::KDF2, Botan::SP800_108_Counter, Botan::SP800_108_Feedback, Botan::SP800_108_Pipeline, Botan::SP800_56C_One_Step_Hash, Botan::SP800_56C_One_Step_HMAC, Botan::SP800_56C_One_Step_KMAC128, Botan::SP800_56C_One_Step_KMAC256, Botan::SP800_56C_Two_Step, Botan::TLS_12_PRF, and Botan::X942_PRF.

◆ new_object()

virtual std::unique_ptr< KDF > Botan::KDF::new_object ( ) const

pure virtualinherited

Returns: new object representing the same algorithm as *this

Implemented in Botan::HKDF, Botan::HKDF_Expand, Botan::HKDF_Extract, Botan::KDF1, Botan::KDF1_18033, Botan::KDF2, Botan::SP800_108_Counter, Botan::SP800_108_Feedback, Botan::SP800_108_Pipeline, Botan::SP800_56C_One_Step_Hash, Botan::SP800_56C_One_Step_HMAC, Botan::SP800_56C_One_Step_KMAC128, Botan::SP800_56C_One_Step_KMAC256, Botan::SP800_56C_Two_Step, Botan::TLS_12_PRF, and Botan::X942_PRF.

◆ providers()

std::vector< std::string > Botan::KDF::providers ( std::string_view algo_spec )

staticinherited

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

Definition at line 209 of file kdf.cpp.

                                                            {
   return probe_providers_of<KDF>(algo_spec);
}

References Botan::probe_providers_of().

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

src/lib/kdf/sp800_56a/sp800_56c_one_step.h
src/lib/kdf/sp800_56a/sp800_56c_one_step.cpp

Public Member Functions

Static Public Member Functions

Protected Member Functions

Detailed Description

Member Function Documentation

◆ clone()

◆ create()

◆ create_kmac_instance()

◆ create_or_throw()

◆ default_salt_length()

◆ derive_key() [1/9]

◆ derive_key() [2/9]

◆ derive_key() [3/9]

◆ derive_key() [4/9]

◆ derive_key() [5/9]

◆ derive_key() [6/9]

◆ derive_key() [7/9]

◆ derive_key() [8/9]

◆ derive_key() [9/9]

◆ kdf()

◆ name()

◆ new_object()

◆ providers()