Botan::SHA_3 Class Reference

#include <sha3.h>

Inheritance diagram for Botan::SHA_3:

Public Member Functions
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[])
std::vector< uint8_t >	final_stdvec ()
size_t	hash_block_size () const override
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)
std::string	provider () const override
	SHA_3 (size_t output_bits)
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 size_t	absorb (size_t bitrate, secure_vector< uint64_t > &S, size_t S_pos, const uint8_t input[], size_t length)
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 void	expand (size_t bitrate, secure_vector< uint64_t > &S, uint8_t output[], size_t output_length)
static void	finish (size_t bitrate, secure_vector< uint64_t > &S, size_t S_pos, uint8_t init_pad, uint8_t fini_pad)
static void	permute (uint64_t A[25])
static std::vector< std::string >	providers (std::string_view algo_spec)

Detailed Description

SHA-3

Definition at line 20 of file sha3.h.

Constructor & Destructor Documentation

SHA_3()

Botan::SHA_3::SHA_3 ( size_t  output_bits )

explicit

Parameters

output_bits

the size of the hash output; must be one of 224, 256, 384, or 512

Definition at line 131 of file sha3.cpp.

                               :
   m_output_bits(output_bits),
   m_bitrate(1600 - 2*output_bits),
   m_S(25),
   m_S_pos(0)
   {
   // We only support the parameters for SHA-3 in this constructor
 
   if(output_bits != 224 && output_bits != 256 &&
      output_bits != 384 && output_bits != 512)
      {
      throw Invalid_Argument(fmt("SHA_3: Invalid output length {}", output_bits));
      }
   }

References Botan::fmt().

Member Function Documentation

absorb()

size_t Botan::SHA_3::absorb ( size_t  bitrate, secure_vector< uint64_t > &  S, size_t  S_pos, const uint8_t  input[], size_t  length  )

static

Absorb data into the provided state

Parameters

bitrate	the bitrate to absorb into the sponge
S	the sponge state
S_pos	where to begin absorbing into S
input	the input data
length	size of input in bytes

Definition at line 48 of file sha3.cpp.

   {
   while(length > 0)
      {
      size_t to_take = std::min(length, bitrate / 8 - S_pos);
 
      length -= to_take;
 
      while(to_take && S_pos % 8)
         {
         S[S_pos / 8] ^= static_cast<uint64_t>(input[0]) << (8 * (S_pos % 8));
 
         ++S_pos;
         ++input;
         --to_take;
         }
 
      while(to_take && to_take % 8 == 0)
         {
         S[S_pos / 8] ^= load_le<uint64_t>(input, 0);
         S_pos += 8;
         input += 8;
         to_take -= 8;
         }
 
      while(to_take)
         {
         S[S_pos / 8] ^= static_cast<uint64_t>(input[0]) << (8 * (S_pos % 8));
 
         ++S_pos;
         ++input;
         --to_take;
         }
 
      if(S_pos == bitrate / 8)
         {
         SHA_3::permute(S.data());
         S_pos = 0;
         }
      }
 
   return S_pos;
   }

References Botan::load_le< uint64_t >(), and permute().

clear()

void Botan::SHA_3::clear ( )

overridevirtual

Reset the state.

Implements Botan::HashFunction.

Definition at line 173 of file sha3.cpp.

   {
   zeroise(m_S);
   m_S_pos = 0;
   }

References Botan::zeroise().

clone()

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

inlineinherited

Returns

new object representing the same algorithm as *this

Definition at line 92 of file hash.h.

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

copy_state()

std::unique_ptr< HashFunction > Botan::SHA_3::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 163 of file sha3.cpp.

   {
   return std::make_unique<SHA_3>(*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 102 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_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::EME::create(), Botan::EMSA::create(), Botan::BlockCipher::create(), Botan::HashFunction::create(), Botan::KDF::create(), Botan::MessageAuthenticationCode::create(), Botan::PBKDF::create(), Botan::PasswordHashFamily::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 320 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().

expand()

void Botan::SHA_3::expand ( size_t  bitrate, secure_vector< uint64_t > &  S, uint8_t  output[], size_t  output_length  )

static

Expand from provided state

Parameters

bitrate	sponge parameter
S	the state
output	the output buffer
output_length	the size of output in bytes

Definition at line 107 of file sha3.cpp.

   {
   BOTAN_ARG_CHECK(bitrate % 64 == 0, "SHA-3 bitrate must be multiple of 64");
 
   const size_t byterate = bitrate / 8;
 
   while(output_length > 0)
      {
      const size_t copying = std::min(byterate, output_length);
 
      copy_out_vec_le(output, copying, S);
 
      output += copying;
      output_length -= copying;
 
      if(output_length > 0)
         {
         SHA_3::permute(S.data());
         }
      }
   }

References BOTAN_ARG_CHECK, Botan::copy_out_vec_le(), output_length(), and permute().

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

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

References T.

final() [2/4]

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

inlineinherited

Definition at line 96 of file buf_comp.h.

         {
         BOTAN_ASSERT_NOMSG(out.size() >= output_length());
         final_result(out.data());
         }

References BOTAN_ASSERT_NOMSG.

final() [3/4]

template<concepts::resizable_byte_buffer T>

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

inlineinherited

Definition at line 103 of file buf_comp.h.

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

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

{ final_result(out); }

Referenced by Botan::ed25519_gen_keypair(), Botan::ed25519_sign(), Botan::ed25519_verify(), Botan::mgf1_mask(), Botan::pbkdf2(), Botan::Dilithium::Polynomial::poly_challenge(), Botan::Kyber_Modern_Symmetric_Primitives::PRF(), and Botan::sm2_compute_za().

final_stdvec()

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

inlineinherited

Definition at line 91 of file buf_comp.h.

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

finish()

void Botan::SHA_3::finish ( size_t  bitrate, secure_vector< uint64_t > &  S, size_t  S_pos, uint8_t  init_pad, uint8_t  fini_pad  )

static

Add final padding and permute. The padding is assumed to be init_pad || 00... || fini_pad

Parameters

bitrate	the bitrate to absorb into the sponge
S	the sponge state
S_pos	where to begin absorbing into S
init_pad	the leading pad bits
fini_pad	the final pad bits

Definition at line 95 of file sha3.cpp.

   {
   BOTAN_ARG_CHECK(bitrate % 64 == 0, "SHA-3 bitrate must be multiple of 64");
 
   S[S_pos / 8] ^= static_cast<uint64_t>(init_pad) << (8 * (S_pos % 8));
   S[(bitrate / 64) - 1] ^= static_cast<uint64_t>(fini_pad) << 56;
   SHA_3::permute(S.data());
   }

References BOTAN_ARG_CHECK, and permute().

hash_block_size()

size_t Botan::SHA_3::hash_block_size ( ) const

inlineoverridevirtual

Returns

hash block size as defined for this algorithm

Reimplemented from Botan::HashFunction.

Definition at line 30 of file sha3.h.

{ return m_bitrate / 8; }

name()

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

overridevirtual

Returns

the hash function name

Implements Botan::HashFunction.

Definition at line 146 of file sha3.cpp.

   {
   return fmt("SHA-3({})", m_output_bits);
   }

References Botan::fmt().

new_object()

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

overridevirtual

Returns

new object representing the same algorithm as *this

Implements Botan::HashFunction.

Definition at line 168 of file sha3.cpp.

   {
   return std::make_unique<SHA_3>(m_output_bits);
   }

output_length()

size_t Botan::SHA_3::output_length ( ) const

inlineoverridevirtual

Returns

length of the output of this function in bytes

Implements Botan::Buffered_Computation.

Definition at line 31 of file sha3.h.

{ return m_output_bits / 8; }

Referenced by expand().

permute()

void Botan::SHA_3::permute ( uint64_t  A[25] )

static

The bare Keccak-1600 permutation

Definition at line 18 of file sha3.cpp.

   {
#if defined(BOTAN_HAS_SHA3_BMI2)
   if(CPUID::has_bmi2())
      {
      return permute_bmi2(A);
      }
#endif
 
   static const uint64_t RC[24] = {
      0x0000000000000001, 0x0000000000008082, 0x800000000000808A,
      0x8000000080008000, 0x000000000000808B, 0x0000000080000001,
      0x8000000080008081, 0x8000000000008009, 0x000000000000008A,
      0x0000000000000088, 0x0000000080008009, 0x000000008000000A,
      0x000000008000808B, 0x800000000000008B, 0x8000000000008089,
      0x8000000000008003, 0x8000000000008002, 0x8000000000000080,
      0x000000000000800A, 0x800000008000000A, 0x8000000080008081,
      0x8000000000008080, 0x0000000080000001, 0x8000000080008008
   };
 
   uint64_t T[25];
 
   for(size_t i = 0; i != 24; i += 2)
      {
      SHA3_round(T, A, RC[i+0]);
      SHA3_round(A, T, RC[i+1]);
      }
   }

References Botan::SHA3_round(), and T.

Referenced by absorb(), expand(), and finish().

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

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

References update.

Referenced by Botan::Dilithium_Symmetric_Primitives::CRH(), and Botan::Dilithium_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 143 of file buf_comp.h.

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

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

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

References update.

provider()

std::string Botan::SHA_3::provider ( ) const

overridevirtual

Returns

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

Reimplemented from Botan::HashFunction.

Definition at line 151 of file sha3.cpp.

   {
#if defined(BOTAN_HAS_SHA3_BMI2)
   if(CPUID::has_bmi2())
      {
      return "bmi2";
      }
#endif
 
   return "base";
   }

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

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

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::mgf1_mask(), Botan::pbkdf2(), Botan::Dilithium::Polynomial::poly_challenge(), Botan::Kyber_Modern_Symmetric_Primitives::PRF(), 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.data(), in.size());
         }

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 59 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 68 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 12 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 26 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 33 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 40 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 47 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/hash/sha3/sha3.h
• src/lib/hash/sha3/sha3.cpp
• src/lib/hash/sha3/sha3_bmi2/sha3_bmi2.cpp