Botan 3.4.0
Crypto and TLS for C&
Public Types | Public Member Functions | Static Public Member Functions | Static Public Attributes | List of all members
Botan::RIPEMD_160 Class Referencefinal

#include <rmd160.h>

Inheritance diagram for Botan::RIPEMD_160:
Botan::HashFunction Botan::Buffered_Computation

Public Types

using digest_type = secure_vector<uint32_t>
 

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)
 
virtual std::string provider () const
 
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 void compress_n (digest_type &digest, std::span< const uint8_t > input, size_t blocks)
 
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 init (digest_type &digest)
 
static std::vector< std::string > providers (std::string_view algo_spec)
 

Static Public Attributes

static constexpr MD_Endian bit_endianness = MD_Endian::Big
 
static constexpr size_t block_bytes = 64
 
static constexpr MD_Endian byte_endianness = MD_Endian::Little
 
static constexpr size_t ctr_bytes = 8
 
static constexpr size_t output_bytes = 20
 

Detailed Description

RIPEMD-160

Definition at line 18 of file rmd160.h.

Member Typedef Documentation

◆ digest_type

using Botan::RIPEMD_160::digest_type = secure_vector<uint32_t>

Definition at line 20 of file rmd160.h.

Member Function Documentation

◆ clear()

void Botan::RIPEMD_160::clear ( )
inlineoverridevirtual

Reset the state.

Implements Botan::HashFunction.

Definition at line 42 of file rmd160.h.

42{ m_md.clear(); }

◆ clone()

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

Definition at line 87 of file hash.h.

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

◆ compress_n()

void Botan::RIPEMD_160::compress_n ( digest_type & digest,
std::span< const uint8_t > input,
size_t blocks )
static

Definition at line 76 of file rmd160.cpp.

76 {
77 const uint32_t MAGIC2 = 0x5A827999, MAGIC3 = 0x6ED9EBA1, MAGIC4 = 0x8F1BBCDC, MAGIC5 = 0xA953FD4E,
78 MAGIC6 = 0x50A28BE6, MAGIC7 = 0x5C4DD124, MAGIC8 = 0x6D703EF3, MAGIC9 = 0x7A6D76E9;
79 std::array<uint32_t, 16> M;
80
81 BufferSlicer in(input);
82
83 for(size_t i = 0; i != blocks; ++i) {
84 load_le(M.data(), in.take(block_bytes).data(), M.size());
85
86 uint32_t A1 = digest[0], A2 = A1, B1 = digest[1], B2 = B1, C1 = digest[2], C2 = C1, D1 = digest[3], D2 = D1,
87 E1 = digest[4], E2 = E1;
88
89 F1<11>(A1, B1, C1, D1, E1, M[0]);
90 F5<8>(A2, B2, C2, D2, E2, M[5] + MAGIC6);
91 F1<14>(E1, A1, B1, C1, D1, M[1]);
92 F5<9>(E2, A2, B2, C2, D2, M[14] + MAGIC6);
93 F1<15>(D1, E1, A1, B1, C1, M[2]);
94 F5<9>(D2, E2, A2, B2, C2, M[7] + MAGIC6);
95 F1<12>(C1, D1, E1, A1, B1, M[3]);
96 F5<11>(C2, D2, E2, A2, B2, M[0] + MAGIC6);
97 F1<5>(B1, C1, D1, E1, A1, M[4]);
98 F5<13>(B2, C2, D2, E2, A2, M[9] + MAGIC6);
99 F1<8>(A1, B1, C1, D1, E1, M[5]);
100 F5<15>(A2, B2, C2, D2, E2, M[2] + MAGIC6);
101 F1<7>(E1, A1, B1, C1, D1, M[6]);
102 F5<15>(E2, A2, B2, C2, D2, M[11] + MAGIC6);
103 F1<9>(D1, E1, A1, B1, C1, M[7]);
104 F5<5>(D2, E2, A2, B2, C2, M[4] + MAGIC6);
105 F1<11>(C1, D1, E1, A1, B1, M[8]);
106 F5<7>(C2, D2, E2, A2, B2, M[13] + MAGIC6);
107 F1<13>(B1, C1, D1, E1, A1, M[9]);
108 F5<7>(B2, C2, D2, E2, A2, M[6] + MAGIC6);
109 F1<14>(A1, B1, C1, D1, E1, M[10]);
110 F5<8>(A2, B2, C2, D2, E2, M[15] + MAGIC6);
111 F1<15>(E1, A1, B1, C1, D1, M[11]);
112 F5<11>(E2, A2, B2, C2, D2, M[8] + MAGIC6);
113 F1<6>(D1, E1, A1, B1, C1, M[12]);
114 F5<14>(D2, E2, A2, B2, C2, M[1] + MAGIC6);
115 F1<7>(C1, D1, E1, A1, B1, M[13]);
116 F5<14>(C2, D2, E2, A2, B2, M[10] + MAGIC6);
117 F1<9>(B1, C1, D1, E1, A1, M[14]);
118 F5<12>(B2, C2, D2, E2, A2, M[3] + MAGIC6);
119 F1<8>(A1, B1, C1, D1, E1, M[15]);
120 F5<6>(A2, B2, C2, D2, E2, M[12] + MAGIC6);
121
122 F2<7>(E1, A1, B1, C1, D1, M[7] + MAGIC2);
123 F4<9>(E2, A2, B2, C2, D2, M[6] + MAGIC7);
124 F2<6>(D1, E1, A1, B1, C1, M[4] + MAGIC2);
125 F4<13>(D2, E2, A2, B2, C2, M[11] + MAGIC7);
126 F2<8>(C1, D1, E1, A1, B1, M[13] + MAGIC2);
127 F4<15>(C2, D2, E2, A2, B2, M[3] + MAGIC7);
128 F2<13>(B1, C1, D1, E1, A1, M[1] + MAGIC2);
129 F4<7>(B2, C2, D2, E2, A2, M[7] + MAGIC7);
130 F2<11>(A1, B1, C1, D1, E1, M[10] + MAGIC2);
131 F4<12>(A2, B2, C2, D2, E2, M[0] + MAGIC7);
132 F2<9>(E1, A1, B1, C1, D1, M[6] + MAGIC2);
133 F4<8>(E2, A2, B2, C2, D2, M[13] + MAGIC7);
134 F2<7>(D1, E1, A1, B1, C1, M[15] + MAGIC2);
135 F4<9>(D2, E2, A2, B2, C2, M[5] + MAGIC7);
136 F2<15>(C1, D1, E1, A1, B1, M[3] + MAGIC2);
137 F4<11>(C2, D2, E2, A2, B2, M[10] + MAGIC7);
138 F2<7>(B1, C1, D1, E1, A1, M[12] + MAGIC2);
139 F4<7>(B2, C2, D2, E2, A2, M[14] + MAGIC7);
140 F2<12>(A1, B1, C1, D1, E1, M[0] + MAGIC2);
141 F4<7>(A2, B2, C2, D2, E2, M[15] + MAGIC7);
142 F2<15>(E1, A1, B1, C1, D1, M[9] + MAGIC2);
143 F4<12>(E2, A2, B2, C2, D2, M[8] + MAGIC7);
144 F2<9>(D1, E1, A1, B1, C1, M[5] + MAGIC2);
145 F4<7>(D2, E2, A2, B2, C2, M[12] + MAGIC7);
146 F2<11>(C1, D1, E1, A1, B1, M[2] + MAGIC2);
147 F4<6>(C2, D2, E2, A2, B2, M[4] + MAGIC7);
148 F2<7>(B1, C1, D1, E1, A1, M[14] + MAGIC2);
149 F4<15>(B2, C2, D2, E2, A2, M[9] + MAGIC7);
150 F2<13>(A1, B1, C1, D1, E1, M[11] + MAGIC2);
151 F4<13>(A2, B2, C2, D2, E2, M[1] + MAGIC7);
152 F2<12>(E1, A1, B1, C1, D1, M[8] + MAGIC2);
153 F4<11>(E2, A2, B2, C2, D2, M[2] + MAGIC7);
154
155 F3<11>(D1, E1, A1, B1, C1, M[3] + MAGIC3);
156 F3<9>(D2, E2, A2, B2, C2, M[15] + MAGIC8);
157 F3<13>(C1, D1, E1, A1, B1, M[10] + MAGIC3);
158 F3<7>(C2, D2, E2, A2, B2, M[5] + MAGIC8);
159 F3<6>(B1, C1, D1, E1, A1, M[14] + MAGIC3);
160 F3<15>(B2, C2, D2, E2, A2, M[1] + MAGIC8);
161 F3<7>(A1, B1, C1, D1, E1, M[4] + MAGIC3);
162 F3<11>(A2, B2, C2, D2, E2, M[3] + MAGIC8);
163 F3<14>(E1, A1, B1, C1, D1, M[9] + MAGIC3);
164 F3<8>(E2, A2, B2, C2, D2, M[7] + MAGIC8);
165 F3<9>(D1, E1, A1, B1, C1, M[15] + MAGIC3);
166 F3<6>(D2, E2, A2, B2, C2, M[14] + MAGIC8);
167 F3<13>(C1, D1, E1, A1, B1, M[8] + MAGIC3);
168 F3<6>(C2, D2, E2, A2, B2, M[6] + MAGIC8);
169 F3<15>(B1, C1, D1, E1, A1, M[1] + MAGIC3);
170 F3<14>(B2, C2, D2, E2, A2, M[9] + MAGIC8);
171 F3<14>(A1, B1, C1, D1, E1, M[2] + MAGIC3);
172 F3<12>(A2, B2, C2, D2, E2, M[11] + MAGIC8);
173 F3<8>(E1, A1, B1, C1, D1, M[7] + MAGIC3);
174 F3<13>(E2, A2, B2, C2, D2, M[8] + MAGIC8);
175 F3<13>(D1, E1, A1, B1, C1, M[0] + MAGIC3);
176 F3<5>(D2, E2, A2, B2, C2, M[12] + MAGIC8);
177 F3<6>(C1, D1, E1, A1, B1, M[6] + MAGIC3);
178 F3<14>(C2, D2, E2, A2, B2, M[2] + MAGIC8);
179 F3<5>(B1, C1, D1, E1, A1, M[13] + MAGIC3);
180 F3<13>(B2, C2, D2, E2, A2, M[10] + MAGIC8);
181 F3<12>(A1, B1, C1, D1, E1, M[11] + MAGIC3);
182 F3<13>(A2, B2, C2, D2, E2, M[0] + MAGIC8);
183 F3<7>(E1, A1, B1, C1, D1, M[5] + MAGIC3);
184 F3<7>(E2, A2, B2, C2, D2, M[4] + MAGIC8);
185 F3<5>(D1, E1, A1, B1, C1, M[12] + MAGIC3);
186 F3<5>(D2, E2, A2, B2, C2, M[13] + MAGIC8);
187
188 F4<11>(C1, D1, E1, A1, B1, M[1] + MAGIC4);
189 F2<15>(C2, D2, E2, A2, B2, M[8] + MAGIC9);
190 F4<12>(B1, C1, D1, E1, A1, M[9] + MAGIC4);
191 F2<5>(B2, C2, D2, E2, A2, M[6] + MAGIC9);
192 F4<14>(A1, B1, C1, D1, E1, M[11] + MAGIC4);
193 F2<8>(A2, B2, C2, D2, E2, M[4] + MAGIC9);
194 F4<15>(E1, A1, B1, C1, D1, M[10] + MAGIC4);
195 F2<11>(E2, A2, B2, C2, D2, M[1] + MAGIC9);
196 F4<14>(D1, E1, A1, B1, C1, M[0] + MAGIC4);
197 F2<14>(D2, E2, A2, B2, C2, M[3] + MAGIC9);
198 F4<15>(C1, D1, E1, A1, B1, M[8] + MAGIC4);
199 F2<14>(C2, D2, E2, A2, B2, M[11] + MAGIC9);
200 F4<9>(B1, C1, D1, E1, A1, M[12] + MAGIC4);
201 F2<6>(B2, C2, D2, E2, A2, M[15] + MAGIC9);
202 F4<8>(A1, B1, C1, D1, E1, M[4] + MAGIC4);
203 F2<14>(A2, B2, C2, D2, E2, M[0] + MAGIC9);
204 F4<9>(E1, A1, B1, C1, D1, M[13] + MAGIC4);
205 F2<6>(E2, A2, B2, C2, D2, M[5] + MAGIC9);
206 F4<14>(D1, E1, A1, B1, C1, M[3] + MAGIC4);
207 F2<9>(D2, E2, A2, B2, C2, M[12] + MAGIC9);
208 F4<5>(C1, D1, E1, A1, B1, M[7] + MAGIC4);
209 F2<12>(C2, D2, E2, A2, B2, M[2] + MAGIC9);
210 F4<6>(B1, C1, D1, E1, A1, M[15] + MAGIC4);
211 F2<9>(B2, C2, D2, E2, A2, M[13] + MAGIC9);
212 F4<8>(A1, B1, C1, D1, E1, M[14] + MAGIC4);
213 F2<12>(A2, B2, C2, D2, E2, M[9] + MAGIC9);
214 F4<6>(E1, A1, B1, C1, D1, M[5] + MAGIC4);
215 F2<5>(E2, A2, B2, C2, D2, M[7] + MAGIC9);
216 F4<5>(D1, E1, A1, B1, C1, M[6] + MAGIC4);
217 F2<15>(D2, E2, A2, B2, C2, M[10] + MAGIC9);
218 F4<12>(C1, D1, E1, A1, B1, M[2] + MAGIC4);
219 F2<8>(C2, D2, E2, A2, B2, M[14] + MAGIC9);
220
221 F5<9>(B1, C1, D1, E1, A1, M[4] + MAGIC5);
222 F1<8>(B2, C2, D2, E2, A2, M[12]);
223 F5<15>(A1, B1, C1, D1, E1, M[0] + MAGIC5);
224 F1<5>(A2, B2, C2, D2, E2, M[15]);
225 F5<5>(E1, A1, B1, C1, D1, M[5] + MAGIC5);
226 F1<12>(E2, A2, B2, C2, D2, M[10]);
227 F5<11>(D1, E1, A1, B1, C1, M[9] + MAGIC5);
228 F1<9>(D2, E2, A2, B2, C2, M[4]);
229 F5<6>(C1, D1, E1, A1, B1, M[7] + MAGIC5);
230 F1<12>(C2, D2, E2, A2, B2, M[1]);
231 F5<8>(B1, C1, D1, E1, A1, M[12] + MAGIC5);
232 F1<5>(B2, C2, D2, E2, A2, M[5]);
233 F5<13>(A1, B1, C1, D1, E1, M[2] + MAGIC5);
234 F1<14>(A2, B2, C2, D2, E2, M[8]);
235 F5<12>(E1, A1, B1, C1, D1, M[10] + MAGIC5);
236 F1<6>(E2, A2, B2, C2, D2, M[7]);
237 F5<5>(D1, E1, A1, B1, C1, M[14] + MAGIC5);
238 F1<8>(D2, E2, A2, B2, C2, M[6]);
239 F5<12>(C1, D1, E1, A1, B1, M[1] + MAGIC5);
240 F1<13>(C2, D2, E2, A2, B2, M[2]);
241 F5<13>(B1, C1, D1, E1, A1, M[3] + MAGIC5);
242 F1<6>(B2, C2, D2, E2, A2, M[13]);
243 F5<14>(A1, B1, C1, D1, E1, M[8] + MAGIC5);
244 F1<5>(A2, B2, C2, D2, E2, M[14]);
245 F5<11>(E1, A1, B1, C1, D1, M[11] + MAGIC5);
246 F1<15>(E2, A2, B2, C2, D2, M[0]);
247 F5<8>(D1, E1, A1, B1, C1, M[6] + MAGIC5);
248 F1<13>(D2, E2, A2, B2, C2, M[3]);
249 F5<5>(C1, D1, E1, A1, B1, M[15] + MAGIC5);
250 F1<11>(C2, D2, E2, A2, B2, M[9]);
251 F5<6>(B1, C1, D1, E1, A1, M[13] + MAGIC5);
252 F1<11>(B2, C2, D2, E2, A2, M[11]);
253
254 C1 = digest[1] + C1 + D2;
255 digest[1] = digest[2] + D1 + E2;
256 digest[2] = digest[3] + E1 + A2;
257 digest[3] = digest[4] + A1 + B2;
258 digest[4] = digest[0] + B1 + C2;
259 digest[0] = C1;
260 }
261}
Botan::RIPEMD_160::block_bytes
static constexpr size_t block_bytes
Definition rmd160.h:24
Botan::load_le
constexpr auto load_le(ParamTs &&... params)
Definition loadstor.h:462

References block_bytes, Botan::load_le(), and Botan::BufferSlicer::take().

◆ copy_state()

std::unique_ptr< HashFunction > Botan::RIPEMD_160::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 271 of file rmd160.cpp.

271 {
272 return std::make_unique<RIPEMD_160>(*this);
273}

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

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

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

Definition at line 298 of file hash.cpp.

298 {
299 if(auto hash = HashFunction::create(algo, provider)) {
300 return hash;
301 }
302 throw Lookup_Error("Hash", algo, provider);
303}

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

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

78 {
79 T output(output_length());
80 final_result(output);
81 return output;
82 }
Botan::Buffered_Computation::output_length
virtual size_t output_length() const =0
T
FE_25519 T
Definition ge.cpp:34

References T.

◆ final() [2/4]

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

Definition at line 86 of file buf_comp.h.

86 {
87 BOTAN_ARG_CHECK(out.size() >= output_length(), "provided output buffer has insufficient capacity");
88 final_result(out);
89 }
BOTAN_ARG_CHECK
#define BOTAN_ARG_CHECK(expr, msg)
Definition assert.h:29

References BOTAN_ARG_CHECK.

◆ final() [3/4]

template<concepts::resizable_byte_buffer T>
void Botan::Buffered_Computation::final ( T & out)
inlineinherited

Definition at line 92 of file buf_comp.h.

92 {
93 out.resize(output_length());
94 final_result(out);
95 }

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

70{ final_result({out, output_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(), Botan::Sphincs_Hash_Functions_Sha2::PRF_msg(), Botan::Sphincs_Hash_Functions_Shake::PRF_msg(), and Botan::sm2_compute_za().

◆ final_stdvec()

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

Definition at line 84 of file buf_comp.h.

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

◆ hash_block_size()

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

Reimplemented from Botan::HashFunction.

Definition at line 36 of file rmd160.h.

36{ return block_bytes; }

References block_bytes.

◆ init()

void Botan::RIPEMD_160::init ( digest_type & digest)
static

Definition at line 263 of file rmd160.cpp.

263 {
264 digest.assign({0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476, 0xC3D2E1F0});
265}

◆ name()

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

Implements Botan::HashFunction.

Definition at line 32 of file rmd160.h.

32{ return "RIPEMD-160"; }

◆ new_object()

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

Implements Botan::HashFunction.

Definition at line 267 of file rmd160.cpp.

267 {
268 return std::make_unique<RIPEMD_160>();
269}

◆ output_length()

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

Implements Botan::Buffered_Computation.

Definition at line 34 of file rmd160.h.

34{ return output_bytes; }
Botan::RIPEMD_160::output_bytes
static constexpr size_t output_bytes
Definition rmd160.h:25

References output_bytes.

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

105 {
106 update(in, length);
107 return final<T>();
108 }
update
int(* update)(CTX *, const void *, CC_LONG len)
Definition commoncrypto_hash.cpp:28

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

129 {
130 update(in);
131 return final<T>();
132 }

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

117 {
118 update(in);
119 return final<T>();
120 }

References update.

◆ provider()

virtual std::string Botan::HashFunction::provider ( ) const
inlinevirtualinherited
Returns
provider information about this implementation. Default is "base", might also return "sse2", "avx2", "openssl", or some other arbitrary string.

Reimplemented in Botan::Keccak_1600, Botan::SHA_1, Botan::SHA_224, Botan::SHA_256, Botan::SHA_384, Botan::SHA_512, Botan::SHA_512_256, Botan::SHA_3, Botan::SHAKE_128, and Botan::SHAKE_256.

Definition at line 49 of file hash.h.

49{ return "base"; }

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

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

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

◆ 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(), Botan::Sphincs_Hash_Functions_Sha2::PRF_msg(), Botan::Sphincs_Hash_Functions_Shake::PRF_msg(), Botan::sm2_compute_za(), and Botan::Sphincs_Hash_Functions_Shake::Sphincs_Hash_Functions_Shake().

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

41{ add_data(in); }

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

56{ add_data({cast_char_ptr_to_uint8(str.data()), str.size()}); }
Botan::cast_char_ptr_to_uint8
const uint8_t * cast_char_ptr_to_uint8(const char *s)
Definition mem_ops.h:275

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

62{ add_data({&in, 1}); }

◆ update_be() [1/3]

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

Definition at line 13 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
constexpr auto store_be(ParamTs &&... params)
Definition loadstor.h:711

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.

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

References Botan::store_be().

◆ update_be() [3/3]

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

Definition at line 25 of file buf_comp.cpp.

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

References Botan::store_be().

◆ update_le() [1/3]

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

Definition at line 31 of file buf_comp.cpp.

31 {
32 uint8_t inb[sizeof(val)];
33 store_le(val, inb);
34 add_data({inb, sizeof(inb)});
35}
Botan::store_le
constexpr auto store_le(ParamTs &&... params)
Definition loadstor.h:702

References Botan::store_le().

◆ update_le() [2/3]

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

Definition at line 37 of file buf_comp.cpp.

37 {
38 uint8_t inb[sizeof(val)];
39 store_le(val, inb);
40 add_data({inb, sizeof(inb)});
41}

References Botan::store_le().

◆ update_le() [3/3]

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

Definition at line 43 of file buf_comp.cpp.

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

References Botan::store_le().

Member Data Documentation

◆ bit_endianness

constexpr MD_Endian Botan::RIPEMD_160::bit_endianness = MD_Endian::Big
staticconstexpr

Definition at line 23 of file rmd160.h.

◆ block_bytes

constexpr size_t Botan::RIPEMD_160::block_bytes = 64
staticconstexpr

Definition at line 24 of file rmd160.h.

Referenced by compress_n(), and hash_block_size().

◆ byte_endianness

constexpr MD_Endian Botan::RIPEMD_160::byte_endianness = MD_Endian::Little
staticconstexpr

Definition at line 22 of file rmd160.h.

◆ ctr_bytes

constexpr size_t Botan::RIPEMD_160::ctr_bytes = 8
staticconstexpr

Definition at line 26 of file rmd160.h.

◆ output_bytes

constexpr size_t Botan::RIPEMD_160::output_bytes = 20
staticconstexpr

Definition at line 25 of file rmd160.h.

Referenced by output_length().

The documentation for this class was generated from the following files:
Generated by doxygen 1.10.0