Botan 3.0.0
Crypto and TLS for C&
Public Member Functions | Static Public Member Functions | Protected Member Functions | List of all members
Botan::SHA_1 Class Referencefinal

#include <sha1.h>

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

Public Member Functions

void clear () override
 
HashFunctionclone () const
 
std::unique_ptr< HashFunctioncopy_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 final
 
std::string name () const override
 
std::unique_ptr< HashFunctionnew_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_1 ()
 
void update (const uint8_t in[], size_t length)
 
void update (std::span< const uint8_t > in)
 
void update (std::string_view str)
 
void update (uint8_t in)
 
void update_be (uint16_t val)
 
void update_be (uint32_t val)
 
void update_be (uint64_t val)
 
void update_le (uint16_t val)
 
void update_le (uint32_t val)
 
void update_le (uint64_t val)
 

Static Public Member Functions

static std::unique_ptr< HashFunctioncreate (std::string_view algo_spec, std::string_view provider="")
 
static std::unique_ptr< HashFunctioncreate_or_throw (std::string_view algo_spec, std::string_view provider="")
 
static std::vector< std::string > providers (std::string_view 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
 

Detailed Description

NIST's SHA-1

Definition at line 18 of file sha1.h.

Constructor & Destructor Documentation

◆ SHA_1()

Botan::SHA_1::SHA_1 ( )
inline

Definition at line 30 of file sha1.h.

30 : MDx_HashFunction(64, true, true), m_digest(5)
31 {
32 clear();
33 }
MDx_HashFunction(size_t block_length, bool big_byte_endian, bool big_bit_endian, uint8_t counter_size=8)
Definition: mdx_hash.cpp:18
void clear() override
Definition: sha1.cpp:180

References clear().

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.

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: mem_ops.h:221

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

◆ clear()

void Botan::SHA_1::clear ( )
overridevirtual

Reset the state.

Reimplemented from Botan::MDx_HashFunction.

Definition at line 180 of file sha1.cpp.

181 {
183 zeroise(m_W);
184 m_digest[0] = 0x67452301;
185 m_digest[1] = 0xEFCDAB89;
186 m_digest[2] = 0x98BADCFE;
187 m_digest[3] = 0x10325476;
188 m_digest[4] = 0xC3D2E1F0;
189 }
void clear() override
Definition: mdx_hash.cpp:41
void zeroise(std::vector< T, Alloc > &vec)
Definition: secmem.h:119

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

Referenced by SHA_1().

◆ clone()

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

Definition at line 92 of file hash.h.

93 {
94 return this->new_object().release();
95 }
virtual std::unique_ptr< HashFunction > new_object() const =0

◆ copy_state()

std::unique_ptr< HashFunction > Botan::SHA_1::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 16 of file sha1.cpp.

17 {
18 return std::make_unique<SHA_1>(*this);
19 }

◆ 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.

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

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

◆ 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.

85 {
86 T output(output_length());
87 final_result(output.data());
88 return output;
89 }
virtual size_t output_length() const =0
FE_25519 T
Definition: ge.cpp:36

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.

97 {
98 BOTAN_ASSERT_NOMSG(out.size() >= output_length());
99 final_result(out.data());
100 }
#define BOTAN_ASSERT_NOMSG(expr)
Definition: assert.h:67

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.

104 {
105 out.resize(output_length());
106 final_result(out.data());
107 }

◆ final() [4/4]

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

76{ 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_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.

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 BOTAN_ASSERT_NOMSG(m_counter_size <= output_length());
99 BOTAN_ASSERT_NOMSG(m_counter_size >= 8);
100
101 const uint64_t bit_count = m_count * 8;
102
103 if(m_count_big_endian)
104 store_be(bit_count, &m_buffer[block_len - 8]);
105 else
106 store_le(bit_count, &m_buffer[block_len - 8]);
107
108 compress_n(m_buffer.data(), 1);
109 copy_out(output);
110 clear();
111 }
virtual void copy_out(uint8_t buffer[])=0
constexpr void store_le(uint16_t in, uint8_t out[2])
Definition: loadstor.h:465
constexpr void store_be(uint16_t in, uint8_t out[2])
Definition: loadstor.h:449
constexpr void clear_mem(T *ptr, size_t n)
Definition: mem_ops.h:115

References BOTAN_ASSERT_NOMSG, Botan::MDx_HashFunction::clear(), Botan::clear_mem(), Botan::MDx_HashFunction::compress_n(), Botan::MDx_HashFunction::copy_out(), Botan::Buffered_Computation::output_length(), Botan::store_be(), Botan::store_le(), and Botan::zeroise().

◆ final_stdvec()

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

Definition at line 91 of file buf_comp.h.

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

◆ 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 33 of file mdx_hash.h.

33{ return m_buffer.size(); }

◆ name()

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

Implements Botan::HashFunction.

Definition at line 21 of file sha1.h.

21{ return "SHA-1"; }

◆ new_object()

std::unique_ptr< HashFunction > Botan::SHA_1::new_object ( ) const
inlineoverridevirtual
Returns
new object representing the same algorithm as *this

Implements Botan::HashFunction.

Definition at line 23 of file sha1.h.

23{ return std::make_unique<SHA_1>(); }

◆ output_length()

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

Implements Botan::Buffered_Computation.

Definition at line 22 of file sha1.h.

22{ return 20; }

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

118 {
119 update(in, length);
120 return final<T>();
121 }
int(* update)(CTX *, const void *, CC_LONG len)

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

Definition at line 143 of file buf_comp.h.

144 {
145 update(in);
146 return final<T>();
147 }

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

Definition at line 130 of file buf_comp.h.

131 {
132 update(in);
133 return final<T>();
134 }

References update.

◆ provider()

std::string Botan::SHA_1::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 191 of file sha1.cpp.

192 {
193#if defined(BOTAN_HAS_SHA1_X86_SHA_NI)
194 if(CPUID::has_intel_sha())
195 {
196 return "intel_sha";
197 }
198#endif
199
200#if defined(BOTAN_HAS_SHA1_ARMV8)
201 if(CPUID::has_arm_sha1())
202 {
203 return "armv8_sha";
204 }
205#endif
206
207#if defined(BOTAN_HAS_SHA1_SSE2)
208 if(CPUID::has_sse2())
209 {
210 return "sse2";
211 }
212#endif
213
214 return "base";
215
216 }

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

Definition at line 330 of file hash.cpp.

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

◆ update() [1/4]

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

35{ 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
inthe input to process as a contiguous data range

Definition at line 41 of file buf_comp.h.

42 {
43 add_data(in.data(), in.size());
44 }

◆ update() [3/4]

void Botan::Buffered_Computation::update ( std::string_view  str)
inlineinherited

Add new input to process.

Parameters
strthe 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.

60 {
61 add_data(cast_char_ptr_to_uint8(str.data()), str.size());
62 }
const uint8_t * cast_char_ptr_to_uint8(const char *s)
Definition: mem_ops.h:183

References Botan::cast_char_ptr_to_uint8().

◆ update() [4/4]

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

Process a single byte.

Parameters
inthe byte to process

Definition at line 68 of file buf_comp.h.

68{ 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 }

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.

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 }

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


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