Botan::TPM2::HashFunction Class Reference

#include <tpm2_hash.h>

Inheritance diagram for Botan::TPM2::HashFunction:

Public Member Functions
void	clear () override
HashFunction *	clone () const
std::unique_ptr< Botan::HashFunction >	copy_state () const override
template<concepts::resizable_byte_buffer T = secure_vector<uint8_t>>
T	final ()
void	final (std::span< uint8_t > out)
template<concepts::resizable_byte_buffer T>
void	final (T &out)
void	final (uint8_t out[])
std::vector< uint8_t >	final_stdvec ()
std::pair< unique_esys_ptr< TPM2B_DIGEST >, unique_esys_ptr< TPMT_TK_HASHCHECK > >	final_with_ticket ()
virtual size_t	hash_block_size () const
	HashFunction (std::shared_ptr< Context > ctx, std::string_view algorithm, TPMI_RH_HIERARCHY hierarchy=ESYS_TR_RH_NULL, SessionBundle sessions={})
std::string	name () const override
std::unique_ptr< Botan::HashFunction >	new_object () const override
size_t	output_length () const override
template<concepts::resizable_byte_buffer T = secure_vector<uint8_t>>
T	process (const uint8_t in[], size_t length)
template<concepts::resizable_byte_buffer T = secure_vector<uint8_t>>
T	process (std::span< const uint8_t > in)
template<concepts::resizable_byte_buffer T = secure_vector<uint8_t>>
T	process (std::string_view in)
virtual std::string	provider () const
size_t	security_level () const override
TPMI_ALG_HASH	type () const
void	update (const uint8_t in[], size_t length)
void	update (std::span< const uint8_t > in)
void	update (std::string_view str)
void	update (uint8_t in)
void	update_be (uint16_t val)
void	update_be (uint32_t val)
void	update_be (uint64_t val)
void	update_le (uint16_t val)
void	update_le (uint32_t val)
void	update_le (uint64_t val)

Static Public Member Functions
static std::unique_ptr< HashFunction >	create (std::string_view algo_spec, std::string_view provider="")
static std::unique_ptr< HashFunction >	create_or_throw (std::string_view algo_spec, std::string_view provider="")
static std::vector< std::string >	providers (std::string_view algo_spec)

Detailed Description

Exposes the hashing capability of a TPM 2.0 device as a Botan::HashFunction. Typically this is used to obtain a TPMT_TK_HASHCHECK ticket after the hash operation has been completed. Otherwise, the HashFunction behaves like any other Botan::HashFunction.

Definition at line 29 of file tpm2_hash.h.

Constructor & Destructor Documentation

HashFunction()

Botan::TPM2::HashFunction::HashFunction	(	std::shared_ptr< Context >	ctx,
		std::string_view	algorithm,
		TPMI_RH_HIERARCHY	hierarchy = ESYS_TR_RH_NULL,
		SessionBundle	sessions = {} )

Definition at line 20 of file tpm2_hash.cpp.

                                                   :
      m_hash_type(get_tpm2_hash_type(algorithm)),
      m_hierarchy(hierarchy),
      m_handle(std::move(ctx)),
      m_sessions(std::move(sessions)) {
   // When creating a new hash object we assume that the call will use it to
   // hash data and therefore setup the hash object immediately.
   lazy_setup();
}

References Botan::TPM2::get_tpm2_hash_type().

Member Function Documentation

clear()

void Botan::TPM2::HashFunction::clear ( )

overridevirtual

Reset the state.

Implements Botan::HashFunction.

Definition at line 66 of file tpm2_hash.cpp.

                         {
   m_handle._reset();
}

clone()

HashFunction * Botan::HashFunction::clone ( ) const

inlineinherited

Create a new uninitialized object of the same type

Returns

new object representing the same algorithm as *this

Definition at line 100 of file hash.h.

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

References new_object().

copy_state()

std::unique_ptr< Botan::HashFunction > Botan::TPM2::HashFunction::copy_state ( ) const

overridevirtual

Exceptions

Not_Implemented

as copying state is not supported within the TPM

Implements Botan::HashFunction.

Definition at line 70 of file tpm2_hash.cpp.

                                                                {
   throw Not_Implemented("TPM 2.0 hash functions do not support copy_state");
}

create()

std::unique_ptr< HashFunction > Botan::HashFunction::create ( std::string_view algo_spec, std::string_view provider = "" )

staticinherited

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

Definition at line 111 of file hash.cpp.

                                                                                                  {
#if defined(BOTAN_HAS_COMMONCRYPTO)
   if(provider.empty() || provider == "commoncrypto") {
      if(auto hash = make_commoncrypto_hash(algo_spec))
         return hash;
 
      if(!provider.empty())
         return nullptr;
   }
#endif
 
   if(provider.empty() == false && provider != "base") {
      return nullptr;  // unknown provider
   }
 
#if defined(BOTAN_HAS_SHA1)
   if(algo_spec == "SHA-1") {
      return std::make_unique<SHA_1>();
   }
#endif
 
#if defined(BOTAN_HAS_SHA2_32)
   if(algo_spec == "SHA-224") {
      return std::make_unique<SHA_224>();
   }
 
   if(algo_spec == "SHA-256") {
      return std::make_unique<SHA_256>();
   }
#endif
 
#if defined(BOTAN_HAS_SHA2_64)
   if(algo_spec == "SHA-384") {
      return std::make_unique<SHA_384>();
   }
 
   if(algo_spec == "SHA-512") {
      return std::make_unique<SHA_512>();
   }
 
   if(algo_spec == "SHA-512-256") {
      return std::make_unique<SHA_512_256>();
   }
#endif
 
#if defined(BOTAN_HAS_RIPEMD_160)
   if(algo_spec == "RIPEMD-160") {
      return std::make_unique<RIPEMD_160>();
   }
#endif
 
#if defined(BOTAN_HAS_WHIRLPOOL)
   if(algo_spec == "Whirlpool") {
      return std::make_unique<Whirlpool>();
   }
#endif
 
#if defined(BOTAN_HAS_MD5)
   if(algo_spec == "MD5") {
      return std::make_unique<MD5>();
   }
#endif
 
#if defined(BOTAN_HAS_MD4)
   if(algo_spec == "MD4") {
      return std::make_unique<MD4>();
   }
#endif
 
#if defined(BOTAN_HAS_GOST_34_11)
   if(algo_spec == "GOST-R-34.11-94" || algo_spec == "GOST-34.11") {
      return std::make_unique<GOST_34_11>();
   }
#endif
 
#if defined(BOTAN_HAS_ADLER32)
   if(algo_spec == "Adler32") {
      return std::make_unique<Adler32>();
   }
#endif
 
#if defined(BOTAN_HAS_ASCON_HASH256)
   if(algo_spec == "Ascon-Hash256") {
      return std::make_unique<Ascon_Hash256>();
   }
#endif
 
#if defined(BOTAN_HAS_CRC24)
   if(algo_spec == "CRC24") {
      return std::make_unique<CRC24>();
   }
#endif
 
#if defined(BOTAN_HAS_CRC32)
   if(algo_spec == "CRC32") {
      return std::make_unique<CRC32>();
   }
#endif
 
#if defined(BOTAN_HAS_STREEBOG)
   if(algo_spec == "Streebog-256") {
      return std::make_unique<Streebog>(256);
   }
   if(algo_spec == "Streebog-512") {
      return std::make_unique<Streebog>(512);
   }
#endif
 
#if defined(BOTAN_HAS_SM3)
   if(algo_spec == "SM3") {
      return std::make_unique<SM3>();
   }
#endif
 
   const SCAN_Name req(algo_spec);
 
#if defined(BOTAN_HAS_SKEIN_512)
   if(req.algo_name() == "Skein-512") {
      return std::make_unique<Skein_512>(req.arg_as_integer(0, 512), req.arg(1, ""));
   }
#endif
 
#if defined(BOTAN_HAS_BLAKE2B)
   if(req.algo_name() == "Blake2b" || req.algo_name() == "BLAKE2b") {
      return std::make_unique<BLAKE2b>(req.arg_as_integer(0, 512));
   }
#endif
 
#if defined(BOTAN_HAS_BLAKE2S)
   if(req.algo_name() == "Blake2s" || req.algo_name() == "BLAKE2s") {
      return std::make_unique<BLAKE2s>(req.arg_as_integer(0, 256));
   }
#endif
 
#if defined(BOTAN_HAS_KECCAK)
   if(req.algo_name() == "Keccak-1600") {
      return std::make_unique<Keccak_1600>(req.arg_as_integer(0, 512));
   }
#endif
 
#if defined(BOTAN_HAS_SHA3)
   if(req.algo_name() == "SHA-3") {
      return std::make_unique<SHA_3>(req.arg_as_integer(0, 512));
   }
#endif
 
#if defined(BOTAN_HAS_SHAKE)
   if(req.algo_name() == "SHAKE-128" && req.arg_count() == 1) {
      return std::make_unique<SHAKE_128>(req.arg_as_integer(0));
   }
   if(req.algo_name() == "SHAKE-256" && req.arg_count() == 1) {
      return std::make_unique<SHAKE_256>(req.arg_as_integer(0));
   }
#endif
 
#if defined(BOTAN_HAS_PARALLEL_HASH)
   if(req.algo_name() == "Parallel") {
      std::vector<std::unique_ptr<HashFunction>> hashes;
 
      for(size_t i = 0; i != req.arg_count(); ++i) {
         auto h = HashFunction::create(req.arg(i));
         if(!h) {
            return nullptr;
         }
         hashes.push_back(std::move(h));
      }
 
      return std::make_unique<Parallel>(hashes);
   }
#endif
 
#if defined(BOTAN_HAS_TRUNCATED_HASH)
   if(req.algo_name() == "Truncated" && req.arg_count() == 2) {
      auto hash = HashFunction::create(req.arg(0));
      if(!hash) {
         return nullptr;
      }
 
      return std::make_unique<Truncated_Hash>(std::move(hash), req.arg_as_integer(1));
   }
#endif
 
#if defined(BOTAN_HAS_COMB4P)
   if(req.algo_name() == "Comb4P" && req.arg_count() == 2) {
      auto h1 = HashFunction::create(req.arg(0));
      auto h2 = HashFunction::create(req.arg(1));
 
      if(h1 && h2) {
         return std::make_unique<Comb4P>(std::move(h1), std::move(h2));
      }
   }
#endif
 
   return nullptr;
}

References Botan::SCAN_Name::algo_name(), Botan::SCAN_Name::arg(), Botan::SCAN_Name::arg_as_integer(), Botan::SCAN_Name::arg_count(), create(), Botan::make_commoncrypto_hash(), and provider().

Referenced by botan_hash_init(), Botan::BlockCipher::create(), Botan::EncryptionPaddingScheme::create(), create(), Botan::KDF::create(), Botan::MessageAuthenticationCode::create(), Botan::PasswordHashFamily::create(), Botan::PBKDF::create(), Botan::SignaturePaddingScheme::create(), create_or_throw(), and Botan::EC_Group_Data::hash_to_curve_supported().

create_or_throw()

std::unique_ptr< HashFunction > Botan::HashFunction::create_or_throw ( 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 use Throws Lookup_Error if not found.

Definition at line 308 of file hash.cpp.

                                                                                                      {
   if(auto hash = HashFunction::create(algo, provider)) {
      return hash;
   }
   throw Lookup_Error("Hash", algo, provider);
}

References create(), and provider().

Referenced by botan_pubkey_fingerprint(), botan_pubkey_sm2_compute_za(), Botan::OCSP::CertID::CertID(), Botan::TLS::Client_Hello_Internal::Client_Hello_Internal(), Botan::SPAKE2p::SystemParameters::confirmation_size(), Botan::Kyber_90s_Symmetric_Primitives::create_G(), Botan::Kyber_Modern_Symmetric_Primitives::create_G(), Botan::ML_KEM_Symmetric_Primitives::create_G(), Botan::Kyber_90s_Symmetric_Primitives::create_H(), Botan::Kyber_Modern_Symmetric_Primitives::create_H(), Botan::ML_KEM_Symmetric_Primitives::create_H(), Botan::create_hex_fingerprint(), Botan::ML_KEM_Symmetric_Primitives::create_J(), Botan::Kyber_90s_Symmetric_Primitives::create_KDF(), Botan::Kyber_Modern_Symmetric_Primitives::create_KDF(), Botan::Sodium::crypto_hash_sha256(), Botan::Sodium::crypto_hash_sha512(), Botan::TLS::PSKImporter::derive_imported_psk(), Botan::Bcrypt_PBKDF::derive_key(), Botan::ed25519_gen_keypair(), Botan::ed25519_sign(), Botan::ed25519_verify(), Botan::PKCS12::export_to(), Botan::TLS::Handshake_Hash::final(), Botan::X509_Certificate_Cache::find_or_insert(), Botan::generate_dsa_primes(), Botan::h2c_expand_message(), Botan::LMOTS_Params::hash(), Botan::LMS_Params::hash(), Botan::Classic_McEliece_Parameters::hash_func(), Botan::Stateful_Key_Index_Registry::KeyId::KeyId(), Botan::TLS::make_hello_random(), Botan::Roughtime::nonce_from_blind(), Botan::PKCS1v15_Raw_SignaturePaddingScheme::PKCS1v15_Raw_SignaturePaddingScheme(), Botan::TLS::Transcript_Hash_State::set_algorithm(), Botan::RTSS_Share::split(), Botan::srp6_client_agree(), Botan::srp6_generate_verifier(), Botan::SRP6_Server_Session::step1(), Botan::SRP6_Server_Session::step2(), Botan::Cert_Extension::Subject_Key_ID::Subject_Key_ID(), Botan::Cert_Extension::Subject_Key_ID::Subject_Key_ID(), and Botan::PK_Ops::Verification_with_Hash::Verification_with_Hash().

final() [1/4]

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

T Botan::Buffered_Computation::final ( )

inlineinherited

Complete the computation and retrieve the final result as a container.

Returns

a contiguous container holding the result

Definition at line 104 of file buf_comp.h.

                {
         T output(output_length());
         final_result(output);
         return output;
      }

References output_length().

final() [2/4]

void Botan::Buffered_Computation::final ( std::span< uint8_t > out )

inherited

Complete the computation and retrieve the final result

Parameters

out	the buffer to write the result to, must be output_length() bytes

Definition at line 54 of file buf_comp.cpp.

                                                     {
   BOTAN_ARG_CHECK(out.size() >= output_length(), "Output buffer has insufficient capacity");
   // Pass exactly output_length() bytes so that an oversized buffer has the
   // result written to its leading bytes with the remainder left untouched.
   final_result(out.first(output_length()));
}

References BOTAN_ARG_CHECK, and output_length().

final() [3/4]

template<concepts::resizable_byte_buffer T>

void Botan::Buffered_Computation::final ( T & out )

inlineinherited

Complete the computation and retrieve the final result

Parameters

out	a container which is resized to hold the result

Definition at line 127 of file buf_comp.h.

                         {
         out.resize(output_length());
         final_result(out);
      }

References output_length().

final() [4/4]

void Botan::Buffered_Computation::final ( uint8_t out[] )

inlineinherited

Complete the computation and retrieve the final result.

Parameters

out	The byte array to be filled with the result, which must be of length output_length()

Definition at line 97 of file buf_comp.h.

{ final_result({out, output_length()}); }

References output_length().

Referenced by Botan::expand_message_xmd(), final_stdvec(), Botan::PseudorandomKeyGeneration::gen(), Botan::TPM2::Verification_Operation::is_valid_signature(), Botan::mgf1_mask(), Botan::KMAC::operator=(), Botan::pbkdf2(), Botan::Sphincs_Hash_Functions_Sha2::PRF_msg(), process(), process(), process(), Botan::TPM2::Signature_Operation::sign(), and Botan::sm2_compute_za().

final_stdvec()

std::vector< uint8_t > Botan::Buffered_Computation::final_stdvec ( )

inlineinherited

Complete the computation and retrieve the final result

Returns

a std::vector holding the result

Definition at line 114 of file buf_comp.h.

{ return final<std::vector<uint8_t>>(); }

References final().

final_with_ticket()

std::pair< unique_esys_ptr< TPM2B_DIGEST >, unique_esys_ptr< TPMT_TK_HASHCHECK > > Botan::TPM2::HashFunction::final_with_ticket

(

)

Finalize the hash operation and return the digest and the ticket as TSS2 structures.

Returns

A pair of TPM2B_DIGEST and TPMT_TK_HASHCHECK

Definition at line 116 of file tpm2_hash.cpp.

                                                                                                           {
   BOTAN_STATE_CHECK(m_handle.has_transient_handle());
 
   std::pair<unique_esys_ptr<TPM2B_DIGEST>, unique_esys_ptr<TPMT_TK_HASHCHECK>> result;
 
   const auto nodata = init_empty<TPM2B_MAX_BUFFER>();
   check_rc("Esys_SequenceComplete",
            Esys_SequenceComplete(m_handle.context()->esys_context(),
                                  m_handle.transient_handle(),
                                  m_sessions[0],
                                  m_sessions[1],
                                  m_sessions[2],
                                  &nodata,
                                  m_hierarchy,
                                  out_ptr(result.first),
                                  out_ptr(result.second)));
   BOTAN_ASSERT_NONNULL(result.first);
 
   // Esys_SequenceComplete() destroys the underlying transient object
   // so we need to disengage it's RAII wrapper.
   m_handle._disengage();
 
   return result;
}

References BOTAN_ASSERT_NONNULL, BOTAN_STATE_CHECK, Botan::TPM2::check_rc(), Botan::TPM2::init_empty(), and Botan::out_ptr().

hash_block_size()

virtual size_t Botan::HashFunction::hash_block_size ( ) const

inlinevirtualinherited

Return the internal block size of this hash function

Returns

hash block size as defined for this algorithm

Reimplemented in Botan::BLAKE2b, Botan::BLAKE2s, Botan::Comb4P, Botan::GOST_34_11, Botan::Keccak_1600, Botan::MD4, Botan::MD5, Botan::RIPEMD_160, Botan::SHA_1, Botan::SHA_224, Botan::SHA_256, Botan::SHA_384, Botan::SHA_3, Botan::SHA_512, Botan::SHA_512_256, Botan::SHAKE_128, Botan::SHAKE_256, Botan::Skein_512, Botan::SM3, Botan::Streebog, and Botan::Whirlpool.

Definition at line 68 of file hash.h.

{ return 0; }

Referenced by Botan::expand_message_xmd().

name()

std::string Botan::TPM2::HashFunction::name ( ) const

overridevirtual

Return the name of this hash function

Returns

the hash function name

Implements Botan::HashFunction.

Definition at line 33 of file tpm2_hash.cpp.

                                   {
   return get_botan_hash_name(m_hash_type);
}

References Botan::TPM2::get_botan_hash_name().

Referenced by new_object().

new_object()

std::unique_ptr< Botan::HashFunction > Botan::TPM2::HashFunction::new_object ( ) const

overridevirtual

Create a new uninitialized object of the same type

Returns

new object representing the same algorithm as *this

Implements Botan::HashFunction.

Definition at line 74 of file tpm2_hash.cpp.

                                                                {
   return std::make_unique<HashFunction>(m_handle.context(), name(), m_hierarchy, m_sessions);
}

References name().

output_length()

size_t Botan::TPM2::HashFunction::output_length ( ) const

overridevirtual

Return the output length of this function

Returns

length of the output of this function in bytes

Implements Botan::Buffered_Computation.

Definition at line 37 of file tpm2_hash.cpp.

                                         {
   switch(m_hash_type) {
      case TPM2_ALG_SHA1:
         return 20;
      case TPM2_ALG_SHA256:
      case TPM2_ALG_SHA3_256:
      case TPM2_ALG_SM3_256:
         return 32;
      case TPM2_ALG_SHA384:
      case TPM2_ALG_SHA3_384:
         return 48;
      case TPM2_ALG_SHA512:
      case TPM2_ALG_SHA3_512:
         return 64;
      default:
         throw Invalid_State("TPM 2.0 hash object with unexpected hash type");
   }
}

process() [1/3]

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

T Botan::Buffered_Computation::process ( const uint8_t in[], size_t length )

inlineinherited

Update and finalize computation. Does the same as calling update() and final() consecutively.

Parameters

in	the input to process as a byte array
length	the length of the byte array

Returns

the result of the call to final()

Definition at line 140 of file buf_comp.h.

                                                   {
         update(in, length);
         return final<T>();
      }

References final(), and update().

process() [2/3]

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

T Botan::Buffered_Computation::process ( std::span< const uint8_t > in )

inlineinherited

Update and finalize computation. Does the same as calling update() and final() consecutively.

Parameters

in	the input to process as a contiguous container

Returns

the result of the call to final()

Definition at line 164 of file buf_comp.h.

                                           {
         update(in);
         return final<T>();
      }

References final(), and update().

process() [3/3]

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

T Botan::Buffered_Computation::process ( std::string_view in )

inlineinherited

Update and finalize computation. Does the same as calling update() and final() consecutively.

Parameters

in	the input to process as a string

Returns

the result of the call to final()

Definition at line 152 of file buf_comp.h.

                                   {
         update(in);
         return final<T>();
      }

References final(), and update().

provider()

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

inlinevirtualinherited

Return the name of the provider implementing this object

Returns

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

Reimplemented in Botan::Ascon_Hash256, Botan::Keccak_1600, Botan::SHA_1, Botan::SHA_224, Botan::SHA_256, Botan::SHA_384, Botan::SHA_3, Botan::SHA_512, Botan::SHA_512_256, Botan::SHAKE_128, Botan::SHAKE_256, Botan::SM3, Botan::Streebog, and Botan::Whirlpool.

Definition at line 51 of file hash.h.

{ return "base"; }

Referenced by create(), and create_or_throw().

providers()

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

staticinherited

List the providers available for a given hash

Returns

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

Parameters

algo_spec

algorithm name

Definition at line 315 of file hash.cpp.

                                                                     {
   return probe_providers_of<HashFunction>(algo_spec, {"base", "commoncrypto"});
}

References Botan::probe_providers_of().

security_level()

size_t Botan::TPM2::HashFunction::security_level ( ) const

overridevirtual

Return an estimate, in bits, of the security level of this hash function, with respect to collision resistance. For most hashes this is simply half the output length, matching the generic birthday attack. It is lower for hash functions with a known collision attack, and zero for checksums and any hash where finding collisions is trivial.

Reimplemented from Botan::HashFunction.

Definition at line 56 of file tpm2_hash.cpp.

                                          {
   if(m_hash_type == TPM2_ALG_SHA1) {
      // Collision attacks with cost ~2^61 are known (Leurent and Peyrin, 2020)
      return 61;
   } else {
      // Otherwise just call the base class impl
      return HashFunction::security_level();
   }
}

References security_level().

Referenced by security_level().

type()

TPMI_ALG_HASH Botan::TPM2::HashFunction::type ( ) const

inline

Returns

The hash algorithm identifier as TSS2's TPMI_ALG_HASH

Definition at line 46 of file tpm2_hash.h.

{ return m_hash_type; }

update() [1/4]

void Botan::Buffered_Computation::update ( const uint8_t in[], size_t length )

inlineinherited

Add new input to process.

Parameters

in	the input to process as a byte array
length	of param in in bytes

Definition at line 35 of file buf_comp.h.

{ add_data({in, length}); }

Referenced by Botan::expand_message_xmd(), Botan::PseudorandomKeyGeneration::gen(), Botan::LMOTS_Public_Key::LMOTS_Public_Key(), Botan::mgf1_mask(), Botan::pbkdf2(), Botan::Sphincs_Hash_Functions_Sha2::PRF_msg(), process(), process(), process(), and Botan::sm2_compute_za().

update() [2/4]

void Botan::Buffered_Computation::update ( std::span< const uint8_t > in )

inlineinherited

Add new input to process.

Parameters

in	the input to process as a contiguous data range

Definition at line 41 of file buf_comp.h.

{ add_data(in); }

update() [3/4]

void Botan::Buffered_Computation::update ( std::string_view str )

inherited

Add new input to process.

Parameters

str	the input to process as a std::string_view. Will be interpreted as a byte array based on the strings encoding.

Definition at line 14 of file buf_comp.cpp.

                                                    {
   add_data(as_span_of_bytes(str));
}

References Botan::as_span_of_bytes().

update() [4/4]

void Botan::Buffered_Computation::update ( uint8_t in )

inlineinherited

Process a single byte.

Parameters

in	the byte to process

Definition at line 90 of file buf_comp.h.

{ add_data({&in, 1}); }

update_be() [1/3]

void Botan::Buffered_Computation::update_be ( uint16_t val )

inherited

Add new input to process, encoded as a big-endian integer

Parameters

val	the value to process

Definition at line 18 of file buf_comp.cpp.

                                                 {
   uint8_t inb[sizeof(val)];
   store_be(val, inb);
   add_data({inb, sizeof(inb)});
}

References Botan::store_be().

Referenced by Botan::expand_message_xmd(), Botan::mgf1_mask(), and Botan::pbkdf2().

update_be() [2/3]

void Botan::Buffered_Computation::update_be ( uint32_t val )

inherited

Add new input to process, encoded as a big-endian integer

Parameters

val	the value to process

Definition at line 24 of file buf_comp.cpp.

                                                 {
   uint8_t inb[sizeof(val)];
   store_be(val, inb);
   add_data({inb, sizeof(inb)});
}

References Botan::store_be().

update_be() [3/3]

void Botan::Buffered_Computation::update_be ( uint64_t val )

inherited

Add new input to process, encoded as a big-endian integer

Parameters

val	the value to process

Definition at line 30 of file buf_comp.cpp.

                                                 {
   uint8_t inb[sizeof(val)];
   store_be(val, inb);
   add_data({inb, sizeof(inb)});
}

References Botan::store_be().

update_le() [1/3]

void Botan::Buffered_Computation::update_le ( uint16_t val )

inherited

Add new input to process, encoded as a little-endian integer

Parameters

val	the value to process

Definition at line 36 of file buf_comp.cpp.

                                                 {
   uint8_t inb[sizeof(val)];
   store_le(val, inb);
   add_data({inb, sizeof(inb)});
}

References Botan::store_le().

update_le() [2/3]

void Botan::Buffered_Computation::update_le ( uint32_t val )

inherited

Add new input to process, encoded as a little-endian integer

Parameters

val	the value to process

Definition at line 42 of file buf_comp.cpp.

                                                 {
   uint8_t inb[sizeof(val)];
   store_le(val, inb);
   add_data({inb, sizeof(inb)});
}

References Botan::store_le().

update_le() [3/3]

void Botan::Buffered_Computation::update_le ( uint64_t val )

inherited

Add new input to process, encoded as a little-endian integer

Parameters

val	the value to process

Definition at line 48 of file buf_comp.cpp.

                                                 {
   uint8_t inb[sizeof(val)];
   store_le(val, inb);
   add_data({inb, sizeof(inb)});
}

References Botan::store_le().

---

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

• src/lib/prov/tpm2/tpm2_hash.h
• src/lib/prov/tpm2/tpm2_hash.cpp