Botan::RawHashFunction Class Reference

#include <raw_hash.h>

Inheritance diagram for Botan::RawHashFunction:

Public Member Functions
void	add_data (std::span< const uint8_t > input) override
void	clear () override
HashFunction *	clone () const
std::unique_ptr< 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[])
void	final_result (std::span< uint8_t > out) override
std::vector< uint8_t >	final_stdvec ()
virtual size_t	hash_block_size () const
std::string	name () const override
std::unique_ptr< 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
	RawHashFunction (std::string_view name, size_t output_length)
	RawHashFunction (std::unique_ptr< HashFunction > hash)
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

This is not an actual hash function; it simply emits as the "hash" the value it is given as input. This is useful when implementing certain protocols where the hash is provided externally somehow to the unit which is generating the signature.

This is exposed as the "Raw" padding scheme for signatures.

Definition at line 23 of file raw_hash.h.

Constructor & Destructor Documentation

RawHashFunction() [1/2]

Botan::RawHashFunction::RawHashFunction ( std::unique_ptr< HashFunction > hash )

inline

Definition at line 25 of file raw_hash.h.

: RawHashFunction(hash->name(), hash->output_length()) {}

RawHashFunction() [2/2]

Botan::RawHashFunction::RawHashFunction ( std::string_view name, size_t output_length )

inline

Definition at line 27 of file raw_hash.h.

: m_name(name), m_output_length(output_length) {}

Member Function Documentation

add_data()

void Botan::RawHashFunction::add_data ( std::span< const uint8_t > input )

overridevirtual

Add more data to the computation

Parameters

input

is an input buffer

Implements Botan::Buffered_Computation.

Definition at line 13 of file raw_hash.cpp.

                                                           {
   m_bits += std::make_pair(input.data(), input.size());
}

clear()

void Botan::RawHashFunction::clear ( )

overridevirtual

Reset the state.

Implements Botan::HashFunction.

Definition at line 28 of file raw_hash.cpp.

                            {
   m_bits.clear();
}

clone()

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

inlineinherited

Returns

new object representing the same algorithm as *this

Definition at line 87 of file hash.h.

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

copy_state()

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

overridevirtual

Return a new hash object with the same state as *this. This allows computing the hash of several messages with a common prefix more efficiently than would otherwise be possible.

This function should be called clone but that was already used for the case of returning an uninitialized object.

Returns

new hash object

Implements Botan::HashFunction.

Definition at line 32 of file raw_hash.cpp.

                                                              {
   return std::make_unique<RawHashFunction>(*this);
}

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 107 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_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(), Botan::HashFunction::create(), Botan::make_commoncrypto_hash(), and Botan::HashFunction::provider().

Referenced by botan_hash_init(), Botan::BlockCipher::create(), Botan::EME::create(), Botan::EMSA::create(), Botan::HashFunction::create(), Botan::KDF::create(), Botan::MessageAuthenticationCode::create(), Botan::PasswordHashFamily::create(), Botan::PBKDF::create(), Botan::HashFunction::create_or_throw(), Botan::Certificate_Store_In_Memory::find_cert_by_pubkey_sha1(), Botan::Certificate_Store_In_Memory::find_cert_by_raw_subject_dn_sha256(), and Botan::X942_PRF::kdf().

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 298 of file hash.cpp.

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

References Botan::HashFunction::create(), and Botan::HashFunction::provider().

Referenced by botan_pubkey_fingerprint(), botan_pubkey_sm2_compute_za(), Botan::OCSP::CertID::CertID(), Botan::create_hex_fingerprint(), Botan::Sodium::crypto_hash_sha256(), Botan::Sodium::crypto_hash_sha512(), Botan::Bcrypt_PBKDF::derive_key(), Botan::EMSA_PKCS1v15_Raw::EMSA_PKCS1v15_Raw(), Botan::expand_message_xmd(), Botan::TLS::Handshake_Hash::final(), Botan::generate_dsa_primes(), Botan::OCSP::CertID::is_id_for(), Botan::TLS::make_hello_random(), Botan::Roughtime::nonce_from_blind(), 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(), 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 of your choice.

Returns

a contiguous container holding the result

Definition at line 78 of file buf_comp.h.

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

References T.

final() [2/4]

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

inlineinherited

Definition at line 86 of file buf_comp.h.

                                       {
         BOTAN_ARG_CHECK(out.size() >= output_length(), "provided output buffer has insufficient capacity");
         final_result(out);
      }

References BOTAN_ARG_CHECK.

final() [3/4]

template<concepts::resizable_byte_buffer T>

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

inlineinherited

Definition at line 92 of file buf_comp.h.

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

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. Must be of length output_length()

Definition at line 70 of file buf_comp.h.

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

Referenced by Botan::ed25519_gen_keypair(), Botan::ed25519_sign(), Botan::ed25519_verify(), Botan::PseudorandomKeyGeneration::gen(), Botan::TPM2::Verification_Operation::is_valid_signature(), Botan::mgf1_mask(), Botan::pbkdf2(), Botan::Sphincs_Hash_Functions_Sha2::PRF_msg(), Botan::Sphincs_Hash_Functions_Shake::PRF_msg(), and Botan::TPM2::Signature_Operation::sign().

final_result()

void Botan::RawHashFunction::final_result ( std::span< uint8_t > out )

overridevirtual

Write the final output to out

Parameters

out	is an output buffer of output_length()

Implements Botan::Buffered_Computation.

Definition at line 17 of file raw_hash.cpp.

                                                       {
   if(m_output_length > 0 && m_bits.size() != m_output_length) {
      m_bits.clear();
      throw Invalid_Argument("Raw padding was configured to use a " + std::to_string(m_output_length) +
                             " byte hash but instead was used for a " + std::to_string(m_bits.size()) + " byte hash");
   }
 
   copy_mem(out.data(), m_bits.data(), m_bits.size());
   m_bits.clear();
}

References Botan::copy_mem().

final_stdvec()

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

inlineinherited

Definition at line 84 of file buf_comp.h.

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

References final.

hash_block_size()

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

inlinevirtualinherited

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 66 of file hash.h.

{ return 0; }

name()

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

inlineoverridevirtual

Returns

the hash function name

Implements Botan::HashFunction.

Definition at line 41 of file raw_hash.h.

{ return m_name; }

new_object()

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

overridevirtual

Returns

new object representing the same algorithm as *this

Implements Botan::HashFunction.

Definition at line 36 of file raw_hash.cpp.

                                                              {
   return std::make_unique<RawHashFunction>(m_name, m_output_length);
}

output_length()

size_t Botan::RawHashFunction::output_length ( ) const

overridevirtual

Returns

length of the output of this function in bytes

Implements Botan::Buffered_Computation.

Definition at line 40 of file raw_hash.cpp.

                                            {
   if(m_output_length > 0) {
      return m_output_length;
   }
   return m_bits.size();
}

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 105 of file buf_comp.h.

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

References final, and update.

Referenced by Botan::Kyber_Symmetric_Primitives::H(), Botan::Kyber_Symmetric_Primitives::H(), and Botan::Kyber_Symmetric_Primitives::H().

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 129 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 117 of file buf_comp.h.

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

References final, and update.

provider()

virtual std::string Botan::HashFunction::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::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, and Botan::SHAKE_256.

Definition at line 49 of file hash.h.

{ return "base"; }

Referenced by Botan::HashFunction::create(), and Botan::HashFunction::create_or_throw().

providers()

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

staticinherited

Returns

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

Parameters

algo_spec

algorithm name

Definition at line 305 of file hash.cpp.

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

References Botan::probe_providers_of().

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::ed25519_gen_keypair(), Botan::ed25519_sign(), Botan::ed25519_verify(), Botan::PseudorandomKeyGeneration::gen(), Botan::LMOTS_Public_Key::LMOTS_Public_Key(), Botan::mgf1_mask(), Botan::pbkdf2(), Botan::Sphincs_Hash_Functions_Sha2::PRF_msg(), Botan::Sphincs_Hash_Functions_Shake::PRF_msg(), and Botan::Sphincs_Hash_Functions_Shake::Sphincs_Hash_Functions_Shake().

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 )

inlineinherited

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 56 of file buf_comp.h.

{ add_data({cast_char_ptr_to_uint8(str.data()), str.size()}); }

References Botan::cast_char_ptr_to_uint8().

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 62 of file buf_comp.h.

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

update_be() [1/3]

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

inherited

Definition at line 13 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::mgf1_mask(), and Botan::pbkdf2().

update_be() [2/3]

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

inherited

Definition at line 19 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

Definition at line 25 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

Definition at line 31 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

Definition at line 37 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

Definition at line 43 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/pk_pad/raw_hash/raw_hash.h
• src/lib/pk_pad/raw_hash/raw_hash.cpp