Botan  2.15.0
Crypto and TLS for C++11
Public Member Functions | Static Public Member Functions | Protected Member Functions | List of all members
Botan::SHA_384 Class Referencefinal

#include <sha2_64.h>

Inheritance diagram for Botan::SHA_384:
Botan::MDx_HashFunction Botan::HashFunction Botan::Buffered_Computation

Public Member Functions

void clear () override
 
HashFunctionclone () const override
 
std::unique_ptr< HashFunctioncopy_state () const override
 
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
 
std::string name () const override
 
size_t output_length () const override
 
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)
 
std::string provider () const override
 
 SHA_384 ()
 
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)
 
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< HashFunctioncreate (const std::string &algo_spec, const std::string &provider="")
 
static std::unique_ptr< HashFunctioncreate_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 final_result (uint8_t output[]) override final
 
virtual void write_count (uint8_t out[])
 

Detailed Description

SHA-384

Definition at line 20 of file sha2_64.h.

Constructor & Destructor Documentation

◆ SHA_384()

Botan::SHA_384::SHA_384 ( )
inline

Definition at line 31 of file sha2_64.h.

Referenced by copy_state().

31  : MDx_HashFunction(128, true, true, 16), m_digest(8)
32  { clear(); }
void clear() override
Definition: sha2_64.cpp:255
MDx_HashFunction(size_t block_length, bool big_byte_endian, bool big_bit_endian, uint8_t counter_size=8)
Definition: mdx_hash.cpp:18

Member Function Documentation

◆ add_data()

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

Add more data to the computation

Parameters
inputis an input buffer
lengthis the length of input in bytes

Implements Botan::Buffered_Computation.

Definition at line 50 of file mdx_hash.cpp.

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

51  {
52  const size_t block_len = static_cast<size_t>(1) << m_block_bits;
53 
54  m_count += length;
55 
56  if(m_position)
57  {
58  buffer_insert(m_buffer, m_position, input, length);
59 
60  if(m_position + length >= block_len)
61  {
62  compress_n(m_buffer.data(), 1);
63  input += (block_len - m_position);
64  length -= (block_len - m_position);
65  m_position = 0;
66  }
67  }
68 
69  // Just in case the compiler can't figure out block_len is a power of 2
70  const size_t full_blocks = length >> m_block_bits;
71  const size_t remaining = length & (block_len - 1);
72 
73  if(full_blocks > 0)
74  {
75  compress_n(input, full_blocks);
76  }
77 
78  buffer_insert(m_buffer, m_position, input + full_blocks * block_len, remaining);
79  m_position += remaining;
80  }
virtual void compress_n(const uint8_t blocks[], size_t block_n)=0
size_t buffer_insert(std::vector< T, Alloc > &buf, size_t buf_offset, const T input[], size_t input_length)
Definition: secmem.h:80

◆ clear()

void Botan::SHA_384::clear ( )
overridevirtual

Reset the state.

Reimplemented from Botan::MDx_HashFunction.

Definition at line 255 of file sha2_64.cpp.

References Botan::MDx_HashFunction::clear().

256  {
258  m_digest[0] = 0xCBBB9D5DC1059ED8;
259  m_digest[1] = 0x629A292A367CD507;
260  m_digest[2] = 0x9159015A3070DD17;
261  m_digest[3] = 0x152FECD8F70E5939;
262  m_digest[4] = 0x67332667FFC00B31;
263  m_digest[5] = 0x8EB44A8768581511;
264  m_digest[6] = 0xDB0C2E0D64F98FA7;
265  m_digest[7] = 0x47B5481DBEFA4FA4;
266  }
void clear() override
Definition: mdx_hash.cpp:41

◆ clone()

HashFunction* Botan::SHA_384::clone ( ) const
inlineoverridevirtual
Returns
new object representing the same algorithm as *this

Implements Botan::HashFunction.

Definition at line 25 of file sha2_64.h.

25 { return new SHA_384; }

◆ copy_state()

std::unique_ptr< HashFunction > Botan::SHA_384::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 31 of file sha2_64.cpp.

References SHA_384().

32  {
33  return std::unique_ptr<HashFunction>(new SHA_384(*this));
34  }

◆ 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_commoncrypto_hash(), Botan::make_openssl_hash(), and Botan::HashFunction::provider().

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

108  {
109 
110 #if defined(BOTAN_HAS_COMMONCRYPTO)
111  if(provider.empty() || provider == "commoncrypto")
112  {
113  if(auto hash = make_commoncrypto_hash(algo_spec))
114  return hash;
115 
116  if(!provider.empty())
117  return nullptr;
118  }
119 #endif
120 
121 #if defined(BOTAN_HAS_OPENSSL)
122  if(provider.empty() || provider == "openssl")
123  {
124  if(auto hash = make_openssl_hash(algo_spec))
125  return hash;
126 
127  if(!provider.empty())
128  return nullptr;
129  }
130 #endif
131 
132  if(provider.empty() == false && provider != "base")
133  return nullptr; // unknown provider
134 
135 #if defined(BOTAN_HAS_SHA1)
136  if(algo_spec == "SHA-160" ||
137  algo_spec == "SHA-1" ||
138  algo_spec == "SHA1")
139  {
140  return std::unique_ptr<HashFunction>(new SHA_160);
141  }
142 #endif
143 
144 #if defined(BOTAN_HAS_SHA2_32)
145  if(algo_spec == "SHA-224")
146  {
147  return std::unique_ptr<HashFunction>(new SHA_224);
148  }
149 
150  if(algo_spec == "SHA-256")
151  {
152  return std::unique_ptr<HashFunction>(new SHA_256);
153  }
154 #endif
155 
156 #if defined(BOTAN_HAS_SHA2_64)
157  if(algo_spec == "SHA-384")
158  {
159  return std::unique_ptr<HashFunction>(new SHA_384);
160  }
161 
162  if(algo_spec == "SHA-512")
163  {
164  return std::unique_ptr<HashFunction>(new SHA_512);
165  }
166 
167  if(algo_spec == "SHA-512-256")
168  {
169  return std::unique_ptr<HashFunction>(new SHA_512_256);
170  }
171 #endif
172 
173 #if defined(BOTAN_HAS_RIPEMD_160)
174  if(algo_spec == "RIPEMD-160")
175  {
176  return std::unique_ptr<HashFunction>(new RIPEMD_160);
177  }
178 #endif
179 
180 #if defined(BOTAN_HAS_WHIRLPOOL)
181  if(algo_spec == "Whirlpool")
182  {
183  return std::unique_ptr<HashFunction>(new Whirlpool);
184  }
185 #endif
186 
187 #if defined(BOTAN_HAS_MD5)
188  if(algo_spec == "MD5")
189  {
190  return std::unique_ptr<HashFunction>(new MD5);
191  }
192 #endif
193 
194 #if defined(BOTAN_HAS_MD4)
195  if(algo_spec == "MD4")
196  {
197  return std::unique_ptr<HashFunction>(new MD4);
198  }
199 #endif
200 
201 #if defined(BOTAN_HAS_GOST_34_11)
202  if(algo_spec == "GOST-R-34.11-94" || algo_spec == "GOST-34.11")
203  {
204  return std::unique_ptr<HashFunction>(new GOST_34_11);
205  }
206 #endif
207 
208 #if defined(BOTAN_HAS_ADLER32)
209  if(algo_spec == "Adler32")
210  {
211  return std::unique_ptr<HashFunction>(new Adler32);
212  }
213 #endif
214 
215 #if defined(BOTAN_HAS_CRC24)
216  if(algo_spec == "CRC24")
217  {
218  return std::unique_ptr<HashFunction>(new CRC24);
219  }
220 #endif
221 
222 #if defined(BOTAN_HAS_CRC32)
223  if(algo_spec == "CRC32")
224  {
225  return std::unique_ptr<HashFunction>(new CRC32);
226  }
227 #endif
228 
229  const SCAN_Name req(algo_spec);
230 
231 #if defined(BOTAN_HAS_TIGER)
232  if(req.algo_name() == "Tiger")
233  {
234  return std::unique_ptr<HashFunction>(
235  new Tiger(req.arg_as_integer(0, 24),
236  req.arg_as_integer(1, 3)));
237  }
238 #endif
239 
240 #if defined(BOTAN_HAS_SKEIN_512)
241  if(req.algo_name() == "Skein-512")
242  {
243  return std::unique_ptr<HashFunction>(
244  new Skein_512(req.arg_as_integer(0, 512), req.arg(1, "")));
245  }
246 #endif
247 
248 #if defined(BOTAN_HAS_BLAKE2B)
249  if(req.algo_name() == "Blake2b" || req.algo_name() == "BLAKE2b")
250  {
251  return std::unique_ptr<HashFunction>(
252  new Blake2b(req.arg_as_integer(0, 512)));
253  }
254 #endif
255 
256 #if defined(BOTAN_HAS_KECCAK)
257  if(req.algo_name() == "Keccak-1600")
258  {
259  return std::unique_ptr<HashFunction>(
260  new Keccak_1600(req.arg_as_integer(0, 512)));
261  }
262 #endif
263 
264 #if defined(BOTAN_HAS_SHA3)
265  if(req.algo_name() == "SHA-3")
266  {
267  return std::unique_ptr<HashFunction>(
268  new SHA_3(req.arg_as_integer(0, 512)));
269  }
270 #endif
271 
272 #if defined(BOTAN_HAS_SHAKE)
273  if(req.algo_name() == "SHAKE-128")
274  {
275  return std::unique_ptr<HashFunction>(new SHAKE_128(req.arg_as_integer(0, 128)));
276  }
277  if(req.algo_name() == "SHAKE-256")
278  {
279  return std::unique_ptr<HashFunction>(new SHAKE_256(req.arg_as_integer(0, 256)));
280  }
281 #endif
282 
283 #if defined(BOTAN_HAS_STREEBOG)
284  if(algo_spec == "Streebog-256")
285  {
286  return std::unique_ptr<HashFunction>(new Streebog_256);
287  }
288  if(algo_spec == "Streebog-512")
289  {
290  return std::unique_ptr<HashFunction>(new Streebog_512);
291  }
292 #endif
293 
294 #if defined(BOTAN_HAS_SM3)
295  if(algo_spec == "SM3")
296  {
297  return std::unique_ptr<HashFunction>(new SM3);
298  }
299 #endif
300 
301 #if defined(BOTAN_HAS_WHIRLPOOL)
302  if(req.algo_name() == "Whirlpool")
303  {
304  return std::unique_ptr<HashFunction>(new Whirlpool);
305  }
306 #endif
307 
308 #if defined(BOTAN_HAS_PARALLEL_HASH)
309  if(req.algo_name() == "Parallel")
310  {
311  std::vector<std::unique_ptr<HashFunction>> hashes;
312 
313  for(size_t i = 0; i != req.arg_count(); ++i)
314  {
315  auto h = HashFunction::create(req.arg(i));
316  if(!h)
317  {
318  return nullptr;
319  }
320  hashes.push_back(std::move(h));
321  }
322 
323  return std::unique_ptr<HashFunction>(new Parallel(hashes));
324  }
325 #endif
326 
327 #if defined(BOTAN_HAS_COMB4P)
328  if(req.algo_name() == "Comb4P" && req.arg_count() == 2)
329  {
330  std::unique_ptr<HashFunction> h1(HashFunction::create(req.arg(0)));
331  std::unique_ptr<HashFunction> h2(HashFunction::create(req.arg(1)));
332 
333  if(h1 && h2)
334  return std::unique_ptr<HashFunction>(new Comb4P(h1.release(), h2.release()));
335  }
336 #endif
337 
338 
339  return nullptr;
340  }
BLAKE2b Blake2b
Definition: blake2b.h:56
virtual std::string provider() const
Definition: hash.h:58
std::unique_ptr< HashFunction > make_openssl_hash(const std::string &name)
static std::unique_ptr< HashFunction > create(const std::string &algo_spec, const std::string &provider="")
Definition: hash.cpp:106
std::unique_ptr< HashFunction > make_commoncrypto_hash(const std::string &name)
MechanismType hash

◆ 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_specalgorithm name
providerprovider implementation to use Throws Lookup_Error if not found.

Definition at line 344 of file hash.cpp.

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

Referenced by Botan::argon2(), Botan::bcrypt_pbkdf(), botan_pubkey_sm2_compute_za(), Botan::OCSP::CertID::CertID(), Botan::create_hex_fingerprint(), Botan::Sodium::crypto_hash_sha256(), Botan::Sodium::crypto_hash_sha512(), Botan::EMSA_PKCS1v15_Raw::EMSA_PKCS1v15_Raw(), Botan::TLS::Handshake_Hash::final(), Botan::generate_dsa_primes(), Botan::OCSP::CertID::is_id_for(), Botan::TLS::make_hello_random(), Botan::newhope_shareda(), Botan::newhope_sharedb(), Botan::Roughtime::nonce_from_blind(), Botan::RTSS_Share::split(), and Botan::Cert_Extension::Subject_Key_ID::Subject_Key_ID().

346  {
347  if(auto hash = HashFunction::create(algo, provider))
348  {
349  return hash;
350  }
351  throw Lookup_Error("Hash", algo, provider);
352  }
virtual std::string provider() const
Definition: hash.h:58
static std::unique_ptr< HashFunction > create(const std::string &algo_spec, const std::string &provider="")
Definition: hash.cpp:106
MechanismType hash

◆ final() [1/3]

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

Complete the computation and retrieve the final result.

Parameters
outThe byte array to be filled with the result. Must be of length output_length()

Definition at line 83 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().

83 { 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 90 of file buf_comp.h.

91  {
92  secure_vector<uint8_t> output(output_length());
93  final_result(output.data());
94  return output;
95  }
virtual size_t output_length() const =0

◆ final() [3/3]

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

Definition at line 105 of file buf_comp.h.

106  {
107  out.resize(output_length());
108  final_result(out.data());
109  }
virtual size_t output_length() const =0

◆ final_result()

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

Write the final output to out

Parameters
outis an output buffer of output_length()

Implements Botan::Buffered_Computation.

Definition at line 85 of file mdx_hash.cpp.

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

86  {
87  const size_t block_len = static_cast<size_t>(1) << m_block_bits;
88 
89  clear_mem(&m_buffer[m_position], block_len - m_position);
90  m_buffer[m_position] = m_pad_char;
91 
92  if(m_position >= block_len - m_counter_size)
93  {
94  compress_n(m_buffer.data(), 1);
95  zeroise(m_buffer);
96  }
97 
98  write_count(&m_buffer[block_len - m_counter_size]);
99 
100  compress_n(m_buffer.data(), 1);
101  copy_out(output);
102  clear();
103  }
void clear() override
Definition: mdx_hash.cpp:41
void clear_mem(T *ptr, size_t n)
Definition: mem_ops.h:115
virtual void compress_n(const uint8_t blocks[], size_t block_n)=0
virtual void copy_out(uint8_t buffer[])=0
virtual void write_count(uint8_t out[])
Definition: mdx_hash.cpp:108
void zeroise(std::vector< T, Alloc > &vec)
Definition: secmem.h:160

◆ final_stdvec()

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

Definition at line 97 of file buf_comp.h.

98  {
99  std::vector<uint8_t> output(output_length());
100  final_result(output.data());
101  return output;
102  }
virtual size_t output_length() const =0

◆ hash_block_size()

size_t Botan::MDx_HashFunction::hash_block_size ( ) const
inlinefinaloverridevirtualinherited
Returns
hash block size as defined for this algorithm

Reimplemented from Botan::HashFunction.

Definition at line 35 of file mdx_hash.h.

35 { return m_buffer.size(); }

◆ name()

std::string Botan::SHA_384::name ( ) const
inlineoverridevirtual
Returns
the hash function name

Implements Botan::HashFunction.

Definition at line 23 of file sha2_64.h.

23 { return "SHA-384"; }

◆ output_length()

size_t Botan::SHA_384::output_length ( ) const
inlineoverridevirtual
Returns
length of the output of this function in bytes

Implements Botan::Buffered_Computation.

Definition at line 24 of file sha2_64.h.

24 { return 48; }

◆ 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
inthe input to process as a byte array
lengththe length of the byte array
Returns
the result of the call to final()

Definition at line 118 of file buf_comp.h.

119  {
120  add_data(in, length);
121  return final();
122  }

◆ 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
inthe input to process
Returns
the result of the call to final()

Definition at line 130 of file buf_comp.h.

131  {
132  add_data(in.data(), in.size());
133  return final();
134  }

◆ 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
inthe input to process
Returns
the result of the call to final()

Definition at line 142 of file buf_comp.h.

143  {
144  add_data(in.data(), in.size());
145  return final();
146  }

◆ 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
inthe input to process as a string
Returns
the result of the call to final()

Definition at line 154 of file buf_comp.h.

References update.

155  {
156  update(in);
157  return final();
158  }
void update(const uint8_t in[], size_t length)
Definition: buf_comp.h:33

◆ provider()

std::string Botan::SHA_384::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 202 of file sha2_64.cpp.

203  {
204  return sha512_provider();
205  }

◆ 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_specalgorithm name

Definition at line 354 of file hash.cpp.

355  {
356  return probe_providers_of<HashFunction>(algo_spec, {"base", "openssl", "commoncrypto"});
357  }

◆ update() [1/5]

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

Add new input to process.

Parameters
inthe input to process as a byte array
lengthof param in in bytes

Definition at line 33 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().

33 { 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
inthe input to process as a secure_vector

Definition at line 39 of file buf_comp.h.

40  {
41  add_data(in.data(), in.size());
42  }

◆ update() [3/5]

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

Add new input to process.

Parameters
inthe input to process as a std::vector

Definition at line 48 of file buf_comp.h.

49  {
50  add_data(in.data(), in.size());
51  }

◆ update() [4/5]

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

Add new input to process.

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

Definition at line 66 of file buf_comp.h.

References Botan::cast_char_ptr_to_uint8().

67  {
68  add_data(cast_char_ptr_to_uint8(str.data()), str.size());
69  }
const uint8_t * cast_char_ptr_to_uint8(const char *s)
Definition: mem_ops.h:190

◆ update() [5/5]

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

Process a single byte.

Parameters
inthe byte to process

Definition at line 75 of file buf_comp.h.

75 { 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.

References Botan::store_be().

Referenced by Botan::pbkdf2().

13  {
14  uint8_t inb[sizeof(val)];
15  store_be(val, inb);
16  add_data(inb, sizeof(inb));
17  }
void store_be(uint16_t in, uint8_t out[2])
Definition: loadstor.h:438

◆ update_be() [2/3]

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

Definition at line 19 of file buf_comp.cpp.

References Botan::store_be().

20  {
21  uint8_t inb[sizeof(val)];
22  store_be(val, inb);
23  add_data(inb, sizeof(inb));
24  }
void store_be(uint16_t in, uint8_t out[2])
Definition: loadstor.h:438

◆ update_be() [3/3]

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

Definition at line 26 of file buf_comp.cpp.

References Botan::store_be().

27  {
28  uint8_t inb[sizeof(val)];
29  store_be(val, inb);
30  add_data(inb, sizeof(inb));
31  }
void store_be(uint16_t in, uint8_t out[2])
Definition: loadstor.h:438

◆ update_le() [1/3]

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

Definition at line 33 of file buf_comp.cpp.

References Botan::store_le().

34  {
35  uint8_t inb[sizeof(val)];
36  store_le(val, inb);
37  add_data(inb, sizeof(inb));
38  }
void store_le(uint16_t in, uint8_t out[2])
Definition: loadstor.h:454

◆ update_le() [2/3]

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

Definition at line 40 of file buf_comp.cpp.

References Botan::store_le().

41  {
42  uint8_t inb[sizeof(val)];
43  store_le(val, inb);
44  add_data(inb, sizeof(inb));
45  }
void store_le(uint16_t in, uint8_t out[2])
Definition: loadstor.h:454

◆ update_le() [3/3]

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

Definition at line 47 of file buf_comp.cpp.

References Botan::store_le().

48  {
49  uint8_t inb[sizeof(val)];
50  store_le(val, inb);
51  add_data(inb, sizeof(inb));
52  }
void store_le(uint16_t in, uint8_t out[2])
Definition: loadstor.h:454

◆ write_count()

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

Write the count, if used, to this spot

Parameters
outwhere to write the counter to

Definition at line 108 of file mdx_hash.cpp.

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

Referenced by Botan::MDx_HashFunction::final_result().

109  {
110  BOTAN_ASSERT_NOMSG(m_counter_size <= output_length());
111  BOTAN_ASSERT_NOMSG(m_counter_size >= 8);
112 
113  const uint64_t bit_count = m_count * 8;
114 
115  if(m_count_big_endian)
116  store_be(bit_count, out + m_counter_size - 8);
117  else
118  store_le(bit_count, out + m_counter_size - 8);
119  }
void store_be(uint16_t in, uint8_t out[2])
Definition: loadstor.h:438
#define BOTAN_ASSERT_NOMSG(expr)
Definition: assert.h:68
virtual size_t output_length() const =0
void store_le(uint16_t in, uint8_t out[2])
Definition: loadstor.h:454

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