Botan 2.19.5 Crypto and TLS for C&

Public Member Functions | Static Public Member Functions | Protected Member Functions | List of all members
Botan::MD5 Class Referencefinal

`#include <md5.h>`

Inheritance diagram for Botan::MD5:

## Public Member Functions
void | clear () override
HashFunction * | clone () const override
std::unique_ptr< HashFunction > | copy_state () const override
secure_vector< uint8_t > | final ()
template<typename Alloc >
void | final (std::vector< uint8_t, Alloc > &out)
void | final (uint8_t out[])
std::vector< uint8_t > | final_stdvec ()
size_t | hash_block_size () const override final
| MD5 ()
std::string | name () const override
size_t | output_length () const override
secure_vector< uint8_t > | process (const secure_vector< uint8_t > &in)
secure_vector< uint8_t > | process (const std::string &in)
secure_vector< uint8_t > | process (const std::vector< uint8_t > &in)
secure_vector< uint8_t > | process (const uint8_t in[], size_t length)
virtual std::string | provider () const
void | update (const secure_vector< uint8_t > &in)
void | update (const std::string &str)
void | update (const std::vector< uint8_t > &in)
void | update (const uint8_t in[], size_t length)
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 (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 | final_result (uint8_t output[]) override final
virtual void | write_count (uint8_t out[])

## Detailed Description

MD5

Definition at line 20 of file md5.h.

## Constructor & Destructor Documentation

## ◆ MD5()

Botan::MD5::MD5 | ( |  | ) |
| inline

Definition at line 30 of file md5.h.

30 : MDx_HashFunction(64, false, true), m_M(16), m_digest(4)
31 { clear(); }
Botan::MD5::clear
void clear() override
Definition: md5.cpp:130
Botan::MDx_HashFunction::MDx_HashFunction
MDx_HashFunction(size_t block_length, bool big_byte_endian, bool big_bit_endian, uint8_t counter_size=8)
Definition: mdx_hash.cpp:18

Referenced by copy_state().

## Member Function Documentation

## ◆ add_data()

void Botan::MDx_HashFunction::add_data | ( | const uint8_t | input[],
|  | size_t | length
| ) |  |
| final override protected virtual inherited

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 50 of file mdx_hash.cpp.

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 }
Botan::MDx_HashFunction::compress_n
virtual void compress_n(const uint8_t blocks[], size_t block_n)=0
Botan::buffer_insert
size_t buffer_insert(std::vector< T, Alloc > &buf, size_t buf_offset, const T input[], size_t input_length)
Definition: mem_ops.h:228

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

## ◆ clear()

void Botan::MD5::clear | ( |  | ) |
| override virtual

Reset the state.

Implements Botan::HashFunction.

Definition at line 130 of file md5.cpp.

131 {
132 MDx_HashFunction::clear();
133 zeroise(m_M);
134 m_digest[0] = 0x67452301;
135 m_digest[1] = 0xEFCDAB89;
136 m_digest[2] = 0x98BADCFE;
137 m_digest[3] = 0x10325476;
138 }
Botan::MDx_HashFunction::clear
void clear() override
Definition: mdx_hash.cpp:41
Botan::zeroise
void zeroise(std::vector< T, Alloc > &vec)
Definition: secmem.h:114

References Botan::MDx_HashFunction::clear(), and Botan::zeroise().

## ◆ clone()

HashFunction * Botan::MD5::clone | ( |  | ) | const
| inline override virtual

Returns
  new object representing the same algorithm as *this

Implements Botan::HashFunction.

Definition at line 25 of file md5.h.

25{ return new MD5; }
Botan::MD5::MD5
MD5()
Definition: md5.h:30

## ◆ copy_state()

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

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 14 of file md5.cpp.

15 {
16 return std::unique_ptr<HashFunction>(new MD5(*this));
17 }

References MD5().

## ◆ create()

std::unique_ptr< HashFunction > Botan::HashFunction::create | ( | const std::string & | algo_spec,
|  | const std::string & | provider = `""`
| ) |  |
| static inherited

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.

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

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

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

## ◆ create_or_throw()

std::unique_ptr< HashFunction > Botan::HashFunction::create_or_throw | ( | const std::string & | algo_spec,
|  | const std::string & | provider = `""`
| ) |  |
| static inherited

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

331 {
332 if(auto hash = HashFunction::create(algo, provider))
333 {
334 return hash;
335 }
336 throw Lookup_Error("Hash", algo, provider);
337 }

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().

## ◆ final() [1/3]

secure_vector< uint8_t > Botan::Buffered_Computation::final | ( |  | ) |
| inline inherited

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 }
Botan::Buffered_Computation::output_length
virtual size_t output_length() const =0

## ◆ final() [2/3]

template<typename Alloc >

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

Definition at line 105 of file buf_comp.h.

106 {
107 out.resize(output_length());
108 final_result(out.data());
109 }

## ◆ final() [3/3]

void Botan::Buffered_Computation::final | ( | uint8_t | out[] | ) |
| inline inherited

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

83{ final_result(out); }

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()

void Botan::MDx_HashFunction::final_result | ( | uint8_t | out[] | ) |
| final override protected virtual inherited

Write the final output to out

Parameters

  out | is an output buffer of output_length()

Implements Botan::Buffered_Computation.

Definition at line 85 of file mdx_hash.cpp.

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 }
Botan::MDx_HashFunction::write_count
virtual void write_count(uint8_t out[])
Definition: mdx_hash.cpp:108
Botan::MDx_HashFunction::copy_out
virtual void copy_out(uint8_t buffer[])=0
Botan::clear_mem
void clear_mem(T *ptr, size_t n)
Definition: mem_ops.h:115

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().

## ◆ final_stdvec()

std::vector< uint8_t > Botan::Buffered_Computation::final_stdvec | ( |  | ) |
| inline inherited

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 }

## ◆ hash_block_size()

size_t Botan::MDx_HashFunction::hash_block_size | ( |  | ) | const
| inline final override virtual inherited

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::MD5::name | ( |  | ) | const
| inline override virtual

Returns
  the hash function name

Implements Botan::HashFunction.

Definition at line 23 of file md5.h.

23{ return "MD5"; }

## ◆ output_length()

size_t Botan::MD5::output_length | ( |  | ) | const
| inline override virtual

Returns
  length of the output of this function in bytes

Implements Botan::Buffered_Computation.

Definition at line 24 of file md5.h.

24{ return 16; }

## ◆ process() [1/4]

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

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

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

## ◆ process() [2/4]

secure_vector< uint8_t > Botan::Buffered_Computation::process | ( | const std::string & | in | ) |
| inline inherited

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

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

References update.

## ◆ process() [3/4]

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

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 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 uint8_t | in[],
|  | size_t | length
| ) |  |
| inline inherited

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

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

## ◆ provider()

virtual std::string Botan::HashFunction::provider | ( |  | ) | const
| inline virtual inherited

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

Reimplemented in Botan::SHA_224, Botan::SHA_256, Botan::SHA_384, Botan::SHA_512, Botan::SHA_512_256, and Botan::SHA_3.

Definition at line 58 of file hash.h.

58{ return "base"; }

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

## ◆ providers()

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

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

Parameters

  algo_spec | algorithm name

Definition at line 339 of file hash.cpp.

340 {
341 return probe_providers_of<HashFunction>(algo_spec, {"base", "openssl", "commoncrypto"});
342 }

## ◆ update() [1/5]

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

Add new input to process.

Parameters

  in | the 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() [2/5]

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

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

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

References Botan::cast_char_ptr_to_uint8().

## ◆ update() [3/5]

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

Add new input to process.

Parameters

  in | the 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 uint8_t | in[],
|  | size_t | length
| ) |  |
| inline inherited

Add new input to process.

Parameters

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

Definition at line 33 of file buf_comp.h.

33{ add_data(in, length); }

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().

## ◆ update() [5/5]

void Botan::Buffered_Computation::update | ( | uint8_t | in | ) |
| inline inherited

Process a single byte.

Parameters

  in | the 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.

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

References Botan::store_be().

Referenced by 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.

20 {
21 uint8_t inb[sizeof(val)];
22 store_be(val, inb);
23 add_data(inb, sizeof(inb));
24 }

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.

27 {
28 uint8_t inb[sizeof(val)];
29 store_be(val, inb);
30 add_data(inb, sizeof(inb));
31 }

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.

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

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.

41 {
42 uint8_t inb[sizeof(val)];
43 store_le(val, inb);
44 add_data(inb, sizeof(inb));
45 }

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.

48 {
49 uint8_t inb[sizeof(val)];
50 store_le(val, inb);
51 add_data(inb, sizeof(inb));
52 }

References Botan::store_le().

## ◆ write_count()

void Botan::MDx_HashFunction::write_count | ( | uint8_t | out[] | ) |
| protected virtual inherited

Write the count, if used, to this spot

Parameters

  out | where to write the counter to

Definition at line 108 of file mdx_hash.cpp.

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 }
BOTAN_ASSERT_NOMSG
#define BOTAN_ASSERT_NOMSG(expr)
Definition: assert.h:68

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

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

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

- src/lib/hash/md5/md5.h
- src/lib/hash/md5/md5.cpp