Botan::MDx_HashFunction Class Reference

#include <mdx_hash.h>

Inheritance diagram for Botan::MDx_HashFunction:

Public Member Functions
virtual HashFunction *	clone () const =0
virtual std::unique_ptr< HashFunction >	copy_state () const =0
void	final (uint8_t out[])
secure_vector< uint8_t >	final ()
template<typename Alloc >
void	final (std::vector< uint8_t, Alloc > &out)
std::vector< uint8_t >	final_stdvec ()
size_t	hash_block_size () const override final
	MDx_HashFunction (size_t block_length, bool big_byte_endian, bool big_bit_endian, size_t counter_size=8)
virtual std::string	name () const =0
virtual size_t	output_length () const =0
secure_vector< uint8_t >	process (const uint8_t in[], size_t length)
secure_vector< uint8_t >	process (const secure_vector< uint8_t > &in)
secure_vector< uint8_t >	process (const std::vector< uint8_t > &in)
secure_vector< uint8_t >	process (const std::string &in)
virtual std::string	provider () const
void	update (const uint8_t in[], size_t length)
void	update (const secure_vector< uint8_t > &in)
void	update (const std::vector< uint8_t > &in)
void	update (const std::string &str)
void	update (uint8_t in)
template<typename T >
void	update_be (const T in)

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

Protected Member Functions
void	add_data (const uint8_t input[], size_t length) override final
void	clear () override
virtual void	compress_n (const uint8_t blocks[], size_t block_n)=0
virtual void	copy_out (uint8_t buffer[])=0
void	final_result (uint8_t output[]) override final
virtual void	write_count (uint8_t out[])

Detailed Description

MDx Hash Function Base Class

Definition at line 18 of file mdx_hash.h.

Constructor & Destructor Documentation

MDx_HashFunction()

Botan::MDx_HashFunction::MDx_HashFunction	(	size_t	block_length,
		bool	big_byte_endian,
		bool	big_bit_endian,
		size_t	counter_size = 8
	)

Parameters

block_length	is the number of bytes per block
big_byte_endian	specifies if the hash uses big-endian bytes
big_bit_endian	specifies if the hash uses big-endian bits
counter_size	specifies the size of the counter var in bytes

Definition at line 17 of file mdx_hash.cpp.

                                                    :
   m_buffer(block_len),
   m_count(0),
   m_position(0),
   BIG_BYTE_ENDIAN(byte_end),
   BIG_BIT_ENDIAN(bit_end),
   COUNT_SIZE(cnt_size)
   {
   }

Member Function Documentation

add_data()

void Botan::MDx_HashFunction::add_data ( const uint8_t  input[], size_t  length  )

finaloverrideprotectedvirtual

Add more data to the computation

Parameters

input	is an input buffer
length	is the length of input in bytes

Implements Botan::Buffered_Computation.

Definition at line 42 of file mdx_hash.cpp.

References Botan::buffer_insert(), and compress_n().

   {
   m_count += length;

   if(m_position)
      {
      buffer_insert(m_buffer, m_position, input, length);

      if(m_position + length >= m_buffer.size())
         {
         compress_n(m_buffer.data(), 1);
         input += (m_buffer.size() - m_position);
         length -= (m_buffer.size() - m_position);
         m_position = 0;
         }
      }

   const size_t full_blocks = length / m_buffer.size();
   const size_t remaining   = length % m_buffer.size();

   if(full_blocks)
      compress_n(input, full_blocks);

   buffer_insert(m_buffer, m_position, input + full_blocks * m_buffer.size(), remaining);
   m_position += remaining;
   }

clear()

void Botan::MDx_HashFunction::clear ( )

overrideprotectedvirtual

Reset the state.

Implements Botan::HashFunction.

Reimplemented in Botan::SHA_512_256, Botan::SHA_256, Botan::SHA_512, Botan::SM3, Botan::Tiger, Botan::SHA_224, Botan::RIPEMD_160, Botan::SHA_160, Botan::SHA_384, and Botan::Whirlpool.

Definition at line 33 of file mdx_hash.cpp.

References Botan::zeroise().

Referenced by Botan::MD4::clear(), Botan::MD5::clear(), Botan::RIPEMD_160::clear(), Botan::SHA_384::clear(), Botan::SHA_160::clear(), Botan::Whirlpool::clear(), Botan::SHA_224::clear(), Botan::Tiger::clear(), Botan::SM3::clear(), Botan::SHA_512::clear(), Botan::SHA_256::clear(), Botan::SHA_512_256::clear(), and final_result().

   {
   zeroise(m_buffer);
   m_count = m_position = 0;
   }

clone()

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

pure virtualinherited

Returns

new object representing the same algorithm as *this

Implemented in Botan::SHA_512_256, Botan::SHAKE_256, Botan::SHA_256, Botan::SHA_512, Botan::Comb4P, Botan::Skein_512, Botan::Keccak_1600, Botan::SHA_3, Botan::SHAKE_128, Botan::Blake2b, Botan::SM3, Botan::GOST_34_11, Botan::CRC24, Botan::Parallel, Botan::SHA_224, Botan::Streebog, Botan::Tiger, Botan::Adler32, Botan::CRC32, Botan::MD4, Botan::MD5, Botan::RIPEMD_160, Botan::SHA_160, Botan::SHA_384, and Botan::Whirlpool.

compress_n()

virtual void Botan::MDx_HashFunction::compress_n ( const uint8_t  blocks[], size_t  block_n  )

protectedpure virtual

Run the hash's compression function over a set of blocks

Parameters

blocks	the input
block_n	the number of blocks

Referenced by add_data(), and final_result().

copy_out()

virtual void Botan::MDx_HashFunction::copy_out ( uint8_t  buffer[] )

protectedpure virtual

Copy the output to the buffer

Parameters

buffer

to put the output into

Referenced by final_result().

copy_state()

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

pure virtualinherited

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

Implemented in Botan::SHA_512_256, Botan::SHAKE_256, Botan::SHA_256, Botan::SHA_512, Botan::Comb4P, Botan::Skein_512, Botan::Blake2b, Botan::Keccak_1600, Botan::SHA_3, Botan::SHAKE_128, Botan::SM3, Botan::Streebog, Botan::Tiger, Botan::GOST_34_11, Botan::CRC24, Botan::Parallel, Botan::SHA_224, Botan::Adler32, Botan::CRC32, Botan::MD4, Botan::MD5, Botan::RIPEMD_160, Botan::SHA_160, Botan::SHA_384, and Botan::Whirlpool.

create()

std::unique_ptr< HashFunction > Botan::HashFunction::create ( const std::string &  algo_spec, const std::string &  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 106 of file hash.cpp.

References Botan::SCAN_Name::algo_name(), Botan::SCAN_Name::arg(), Botan::SCAN_Name::arg_as_integer(), Botan::SCAN_Name::arg_count(), hash, Botan::make_bearssl_hash(), Botan::make_openssl_hash(), and Botan::HashFunction::provider().

Referenced by botan_hash_init(), botan_pubkey_fingerprint(), Botan::BlockCipher::create(), Botan::PBKDF::create(), Botan::KDF::create(), Botan::MessageAuthenticationCode::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(), Botan::get_eme(), Botan::get_emsa(), Botan::OCSP::CertID::is_id_for(), Botan::X942_PRF::kdf(), and Botan::X509_Certificate::raw_subject_dn_sha256().

   {
#if defined(BOTAN_HAS_OPENSSL)
   if(provider.empty() || provider == "openssl")
      {
      if(auto hash = make_openssl_hash(algo_spec))
         return hash;

      if(!provider.empty())
         return nullptr;
      }
#endif

#if defined(BOTAN_HAS_BEARSSL)
   if(provider.empty() || provider == "bearssl")
      {
      if(auto hash = make_bearssl_hash(algo_spec))
         return hash;

      if(!provider.empty())
         return nullptr;
      }
#endif

   // TODO: CommonCrypto hashes

   if(provider.empty() == false && provider != "base")
      return nullptr; // unknown provider

#if defined(BOTAN_HAS_SHA1)
   if(algo_spec == "SHA-160" ||
      algo_spec == "SHA-1" ||
      algo_spec == "SHA1")
      {
      return std::unique_ptr<HashFunction>(new SHA_160);
      }
#endif

#if defined(BOTAN_HAS_SHA2_32)
   if(algo_spec == "SHA-224")
      {
      return std::unique_ptr<HashFunction>(new SHA_224);
      }

   if(algo_spec == "SHA-256")
      {
      return std::unique_ptr<HashFunction>(new SHA_256);
      }
#endif

#if defined(BOTAN_HAS_SHA2_64)
   if(algo_spec == "SHA-384")
      {
      return std::unique_ptr<HashFunction>(new SHA_384);
      }

   if(algo_spec == "SHA-512")
      {
      return std::unique_ptr<HashFunction>(new SHA_512);
      }

   if(algo_spec == "SHA-512-256")
      {
      return std::unique_ptr<HashFunction>(new SHA_512_256);
      }
#endif

#if defined(BOTAN_HAS_RIPEMD_160)
   if(algo_spec == "RIPEMD-160")
      {
      return std::unique_ptr<HashFunction>(new RIPEMD_160);
      }
#endif

#if defined(BOTAN_HAS_WHIRLPOOL)
   if(algo_spec == "Whirlpool")
      {
      return std::unique_ptr<HashFunction>(new Whirlpool);
      }
#endif

#if defined(BOTAN_HAS_MD5)
   if(algo_spec == "MD5")
      {
      return std::unique_ptr<HashFunction>(new MD5);
      }
#endif

#if defined(BOTAN_HAS_MD4)
   if(algo_spec == "MD4")
      {
      return std::unique_ptr<HashFunction>(new MD4);
      }
#endif

#if defined(BOTAN_HAS_GOST_34_11)
   if(algo_spec == "GOST-R-34.11-94" || algo_spec == "GOST-34.11")
      {
      return std::unique_ptr<HashFunction>(new GOST_34_11);
      }
#endif

#if defined(BOTAN_HAS_ADLER32)
   if(algo_spec == "Adler32")
      {
      return std::unique_ptr<HashFunction>(new Adler32);
      }
#endif

#if defined(BOTAN_HAS_CRC24)
   if(algo_spec == "CRC24")
      {
      return std::unique_ptr<HashFunction>(new CRC24);
      }
#endif

#if defined(BOTAN_HAS_CRC32)
   if(algo_spec == "CRC32")
      {
      return std::unique_ptr<HashFunction>(new CRC32);
      }
#endif

   const SCAN_Name req(algo_spec);

#if defined(BOTAN_HAS_TIGER)
   if(req.algo_name() == "Tiger")
      {
      return std::unique_ptr<HashFunction>(
         new Tiger(req.arg_as_integer(0, 24),
                   req.arg_as_integer(1, 3)));
      }
#endif

#if defined(BOTAN_HAS_SKEIN_512)
   if(req.algo_name() == "Skein-512")
      {
      return std::unique_ptr<HashFunction>(
         new Skein_512(req.arg_as_integer(0, 512), req.arg(1, "")));
      }
#endif

#if defined(BOTAN_HAS_BLAKE2B)
   if(req.algo_name() == "Blake2b")
      {
      return std::unique_ptr<HashFunction>(
         new Blake2b(req.arg_as_integer(0, 512)));
   }
#endif

#if defined(BOTAN_HAS_KECCAK)
   if(req.algo_name() == "Keccak-1600")
      {
      return std::unique_ptr<HashFunction>(
         new Keccak_1600(req.arg_as_integer(0, 512)));
      }
#endif

#if defined(BOTAN_HAS_SHA3)
   if(req.algo_name() == "SHA-3")
      {
      return std::unique_ptr<HashFunction>(
         new SHA_3(req.arg_as_integer(0, 512)));
      }
#endif

#if defined(BOTAN_HAS_SHAKE)
   if(req.algo_name() == "SHAKE-128")
      {
      return std::unique_ptr<HashFunction>(new SHAKE_128(req.arg_as_integer(0, 128)));
      }
   if(req.algo_name() == "SHAKE-256")
      {
      return std::unique_ptr<HashFunction>(new SHAKE_256(req.arg_as_integer(0, 256)));
      }
#endif

#if defined(BOTAN_HAS_STREEBOG)
   if(algo_spec == "Streebog-256")
      {
      return std::unique_ptr<HashFunction>(new Streebog_256);
      }
   if(algo_spec == "Streebog-512")
      {
      return std::unique_ptr<HashFunction>(new Streebog_512);
      }
#endif

#if defined(BOTAN_HAS_SM3)
   if(algo_spec == "SM3")
      {
      return std::unique_ptr<HashFunction>(new SM3);
      }
#endif

#if defined(BOTAN_HAS_WHIRLPOOL)
   if(req.algo_name() == "Whirlpool")
      {
      return std::unique_ptr<HashFunction>(new Whirlpool);
      }
#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::unique_ptr<HashFunction>(new Parallel(hashes));
      }
#endif

#if defined(BOTAN_HAS_COMB4P)
   if(req.algo_name() == "Comb4P" && req.arg_count() == 2)
      {
      std::unique_ptr<HashFunction> h1(HashFunction::create(req.arg(0)));
      std::unique_ptr<HashFunction> h2(HashFunction::create(req.arg(1)));

      if(h1 && h2)
         return std::unique_ptr<HashFunction>(new Comb4P(h1.release(), h2.release()));
      }
#endif


   return nullptr;
   }

create_or_throw()

std::unique_ptr< HashFunction > Botan::HashFunction::create_or_throw ( const std::string &  algo_spec, const std::string &  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 345 of file hash.cpp.

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

Referenced by botan_pubkey_sm2_compute_za(), Botan::OCSP::CertID::CertID(), Botan::create_hex_fingerprint(), Botan::X509::create_self_signed_cert(), Botan::EMSA_PKCS1v15_Raw::EMSA_PKCS1v15_Raw(), Botan::TLS::Handshake_Hash::final(), Botan::generate_dsa_primes(), Botan::TLS::make_hello_random(), Botan::newhope_shareda(), Botan::newhope_sharedb(), Botan::X509_Certificate::raw_issuer_dn_sha256(), Botan::RTSS_Share::split(), and Botan::Cert_Extension::Subject_Key_ID::Subject_Key_ID().

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

final() [1/3]

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

Referenced by botan_mac_final(), Botan::ed25519_gen_keypair(), Botan::ed25519_sign(), Botan::ed25519_verify(), Botan::TLS::TLS_CBC_HMAC_AEAD_Encryption::finish(), Botan::TLS::TLS_CBC_HMAC_AEAD_Decryption::finish(), and Botan::pbkdf2().

{ final_result(out); }

final() [2/3]

secure_vector<uint8_t> Botan::Buffered_Computation::final ( )

inlineinherited

Complete the computation and retrieve the final result.

Returns

secure_vector holding the result

Definition at line 96 of file buf_comp.h.

         {
         secure_vector<uint8_t> output(output_length());
         final_result(output.data());
         return output;
         }

final() [3/3]

template<typename Alloc >

void Botan::Buffered_Computation::final ( std::vector< uint8_t, Alloc > &  out )

inlineinherited

Definition at line 111 of file buf_comp.h.

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

final_result()

void Botan::MDx_HashFunction::final_result ( uint8_t  out[] )

finaloverrideprotectedvirtual

Write the final output to out

Parameters

out	is an output buffer of output_length()

Implements Botan::Buffered_Computation.

Definition at line 72 of file mdx_hash.cpp.

References clear(), compress_n(), copy_out(), write_count(), and Botan::zeroise().

   {
   m_buffer[m_position] = (BIG_BIT_ENDIAN ? 0x80 : 0x01);
   for(size_t i = m_position+1; i != m_buffer.size(); ++i)
      m_buffer[i] = 0;

   if(m_position >= m_buffer.size() - COUNT_SIZE)
      {
      compress_n(m_buffer.data(), 1);
      zeroise(m_buffer);
      }

   write_count(&m_buffer[m_buffer.size() - COUNT_SIZE]);

   compress_n(m_buffer.data(), 1);
   copy_out(output);
   clear();
   }

final_stdvec()

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

inlineinherited

Definition at line 103 of file buf_comp.h.

         {
         std::vector<uint8_t> output(output_length());
         final_result(output.data());
         return output;
         }

hash_block_size()

size_t Botan::MDx_HashFunction::hash_block_size ( ) const

inlinefinaloverridevirtual

Returns

hash block size as defined for this algorithm

Reimplemented from Botan::HashFunction.

Definition at line 32 of file mdx_hash.h.

Referenced by write_count().

{ return m_buffer.size(); }

name()

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

pure virtualinherited

Returns

the hash function name

Implemented in Botan::SHAKE_256, Botan::SHA_512_256, Botan::SHA_256, Botan::SHA_512, Botan::Comb4P, Botan::Skein_512, Botan::Keccak_1600, Botan::SHA_3, Botan::SHAKE_128, Botan::Blake2b, Botan::SM3, Botan::Streebog, Botan::Parallel, Botan::CRC24, Botan::GOST_34_11, Botan::SHA_224, Botan::Adler32, Botan::CRC32, Botan::MD4, Botan::MD5, Botan::RIPEMD_160, Botan::SHA_160, Botan::SHA_384, Botan::Tiger, and Botan::Whirlpool.

output_length()

virtual size_t Botan::Buffered_Computation::output_length ( ) const

pure virtualinherited

Returns

length of the output of this function in bytes

Implemented in Botan::SHA_512_256, Botan::SHAKE_256, Botan::SHA_256, Botan::SHA_512, Botan::Skein_512, Botan::Keccak_1600, Botan::SHA_3, Botan::SHAKE_128, Botan::Comb4P, Botan::GMAC, Botan::Blake2b, Botan::Poly1305, Botan::Parallel, Botan::SM3, Botan::HMAC, Botan::SipHash, Botan::CBC_MAC, Botan::ANSI_X919_MAC, Botan::CRC24, Botan::GOST_34_11, Botan::SHA_224, Botan::CMAC, Botan::Adler32, Botan::CRC32, Botan::MD4, Botan::MD5, Botan::RIPEMD_160, Botan::SHA_160, Botan::SHA_384, Botan::Streebog, Botan::Tiger, and Botan::Whirlpool.

Referenced by botan_mac_output_length(), Botan::pbkdf2(), Botan::TLS::TLS_CBC_HMAC_AEAD_Mode::TLS_CBC_HMAC_AEAD_Mode(), and write_count().

process() [1/4]

secure_vector<uint8_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 124 of file buf_comp.h.

         {
         add_data(in, length);
         return final();
         }

process() [2/4]

secure_vector<uint8_t> Botan::Buffered_Computation::process ( const secure_vector< uint8_t > &  in )

inlineinherited

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

Parameters

in	the input to process

Returns

the result of the call to final()

Definition at line 136 of file buf_comp.h.

         {
         add_data(in.data(), in.size());
         return final();
         }

process() [3/4]

secure_vector<uint8_t> Botan::Buffered_Computation::process ( const std::vector< uint8_t > &  in )

inlineinherited

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

Parameters

in	the input to process

Returns

the result of the call to final()

Definition at line 148 of file buf_comp.h.

         {
         add_data(in.data(), in.size());
         return final();
         }

process() [4/4]

secure_vector<uint8_t> Botan::Buffered_Computation::process ( const std::string &  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 160 of file buf_comp.h.

         {
         update(in);
         return final();
         }

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.

Definition at line 58 of file hash.h.

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

{ return "base"; }

providers()

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

staticinherited

Returns

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

Parameters

algo_spec

algorithm name

Definition at line 355 of file hash.cpp.

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

update() [1/5]

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

Referenced by botan_mac_update(), Botan::ed25519_gen_keypair(), Botan::ed25519_sign(), Botan::ed25519_verify(), Botan::TLS::TLS_CBC_HMAC_AEAD_Encryption::finish(), Botan::TLS::TLS_CBC_HMAC_AEAD_Decryption::finish(), and Botan::pbkdf2().

{ add_data(in, length); }

update() [2/5]

void Botan::Buffered_Computation::update ( const secure_vector< uint8_t > &  in )

inlineinherited

Add new input to process.

Parameters

in	the input to process as a secure_vector

Definition at line 40 of file buf_comp.h.

         {
         add_data(in.data(), in.size());
         }

update() [3/5]

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

inlineinherited

Add new input to process.

Parameters

in	the input to process as a std::vector

Definition at line 49 of file buf_comp.h.

         {
         add_data(in.data(), in.size());
         }

update() [4/5]

void Botan::Buffered_Computation::update ( const std::string &  str )

inlineinherited

Add new input to process.

Parameters

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

Definition at line 72 of file buf_comp.h.

References Botan::cast_char_ptr_to_uint8().

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

update() [5/5]

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

inlineinherited

Process a single byte.

Parameters

in	the byte to process

Definition at line 81 of file buf_comp.h.

{ add_data(&in, 1); }

update_be()

template<typename T >

void Botan::Buffered_Computation::update_be ( const T  in )

inlineinherited

Add an integer in big-endian order

Parameters

in

the value

Definition at line 58 of file buf_comp.h.

References Botan::get_byte(), and T.

Referenced by Botan::pbkdf2().

         {
         for(size_t i = 0; i != sizeof(T); ++i)
            {
            uint8_t b = get_byte(i, in);
            add_data(&b, 1);
            }
         }

write_count()

void Botan::MDx_HashFunction::write_count ( uint8_t  out[] )

protectedvirtual

Write the count, if used, to this spot

Parameters

out	where to write the counter to

Definition at line 94 of file mdx_hash.cpp.

References hash_block_size(), Botan::Buffered_Computation::output_length(), Botan::store_be(), and Botan::store_le().

Referenced by final_result().

   {
   if(COUNT_SIZE < 8)
      throw Invalid_State("MDx_HashFunction::write_count: COUNT_SIZE < 8");
   if(COUNT_SIZE >= output_length() || COUNT_SIZE >= hash_block_size())
      throw Invalid_Argument("MDx_HashFunction: COUNT_SIZE is too big");

   const uint64_t bit_count = m_count * 8;

   if(BIG_BYTE_ENDIAN)
      store_be(bit_count, out + COUNT_SIZE - 8);
   else
      store_le(bit_count, out + COUNT_SIZE - 8);
   }

---

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

• src/lib/hash/mdx_hash/mdx_hash.h
• src/lib/hash/mdx_hash/mdx_hash.cpp