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

#include <sm3.h>

Inheritance diagram for Botan::SM3:
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)
std::string provider () const override
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::Big
static constexpr size_t ctr_bytes = 8
static constexpr size_t output_bytes = 32

Detailed Description

SM3

Definition at line 18 of file sm3.h.

Member Typedef Documentation

◆ digest_type

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

Definition at line 20 of file sm3.h.

Member Function Documentation

◆ clear()

void Botan::SM3::clear ( )
inlineoverridevirtual

Reset the state.

Implements Botan::HashFunction.

Definition at line 44 of file sm3.h.

44{ m_md.clear(); }

◆ clone()

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

Definition at line 85 of file hash.h.

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

References new_object().

◆ compress_n()

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

Definition at line 24 of file sm3.cpp.

24 {
25#if defined(BOTAN_HAS_SM3_ARMV8)
26 if(CPUID::has(CPUID::Feature::SM3)) {
27 return compress_digest_armv8(digest, input, blocks);
28 }
29#endif
30
31#if defined(BOTAN_HAS_SM3_X86)
32 if(CPUID::has(CPUID::Feature::SM3, CPUID::Feature::AVX2)) {
33 return compress_digest_x86(digest, input, blocks);
34 }
35#endif
36
37#if defined(BOTAN_HAS_SM3_X86_AVX2_BMI2)
38 if(CPUID::has(CPUID::Feature::AVX2, CPUID::Feature::BMI)) {
39 return compress_digest_x86_avx2(digest, input, blocks);
40 }
41#endif
42
43 uint32_t A = digest[0];
44 uint32_t B = digest[1];
45 uint32_t C = digest[2];
46 uint32_t D = digest[3];
47 uint32_t E = digest[4];
48 uint32_t F = digest[5];
49 uint32_t G = digest[6];
50 uint32_t H = digest[7];
51 std::array<uint32_t, 16> W{};
52
53 BufferSlicer in(input);
54
55 for(size_t i = 0; i != blocks; ++i) {
56 load_be(W, in.take<block_bytes>());
57
58 // clang-format off
59
60 R1(A, B, C, D, E, F, G, H, 0x79CC4519, W[ 0], W[ 4]);
61 W[ 0] = SM3_E(W[ 0], W[ 7], W[13], W[ 3], W[10]);
62 R1(D, A, B, C, H, E, F, G, 0xF3988A32, W[ 1], W[ 5]);
63 W[ 1] = SM3_E(W[ 1], W[ 8], W[14], W[ 4], W[11]);
64 R1(C, D, A, B, G, H, E, F, 0xE7311465, W[ 2], W[ 6]);
65 W[ 2] = SM3_E(W[ 2], W[ 9], W[15], W[ 5], W[12]);
66 R1(B, C, D, A, F, G, H, E, 0xCE6228CB, W[ 3], W[ 7]);
67 W[ 3] = SM3_E(W[ 3], W[10], W[ 0], W[ 6], W[13]);
68 R1(A, B, C, D, E, F, G, H, 0x9CC45197, W[ 4], W[ 8]);
69 W[ 4] = SM3_E(W[ 4], W[11], W[ 1], W[ 7], W[14]);
70 R1(D, A, B, C, H, E, F, G, 0x3988A32F, W[ 5], W[ 9]);
71 W[ 5] = SM3_E(W[ 5], W[12], W[ 2], W[ 8], W[15]);
72 R1(C, D, A, B, G, H, E, F, 0x7311465E, W[ 6], W[10]);
73 W[ 6] = SM3_E(W[ 6], W[13], W[ 3], W[ 9], W[ 0]);
74 R1(B, C, D, A, F, G, H, E, 0xE6228CBC, W[ 7], W[11]);
75 W[ 7] = SM3_E(W[ 7], W[14], W[ 4], W[10], W[ 1]);
76 R1(A, B, C, D, E, F, G, H, 0xCC451979, W[ 8], W[12]);
77 W[ 8] = SM3_E(W[ 8], W[15], W[ 5], W[11], W[ 2]);
78 R1(D, A, B, C, H, E, F, G, 0x988A32F3, W[ 9], W[13]);
79 W[ 9] = SM3_E(W[ 9], W[ 0], W[ 6], W[12], W[ 3]);
80 R1(C, D, A, B, G, H, E, F, 0x311465E7, W[10], W[14]);
81 W[10] = SM3_E(W[10], W[ 1], W[ 7], W[13], W[ 4]);
82 R1(B, C, D, A, F, G, H, E, 0x6228CBCE, W[11], W[15]);
83 W[11] = SM3_E(W[11], W[ 2], W[ 8], W[14], W[ 5]);
84 R1(A, B, C, D, E, F, G, H, 0xC451979C, W[12], W[ 0]);
85 W[12] = SM3_E(W[12], W[ 3], W[ 9], W[15], W[ 6]);
86 R1(D, A, B, C, H, E, F, G, 0x88A32F39, W[13], W[ 1]);
87 W[13] = SM3_E(W[13], W[ 4], W[10], W[ 0], W[ 7]);
88 R1(C, D, A, B, G, H, E, F, 0x11465E73, W[14], W[ 2]);
89 W[14] = SM3_E(W[14], W[ 5], W[11], W[ 1], W[ 8]);
90 R1(B, C, D, A, F, G, H, E, 0x228CBCE6, W[15], W[ 3]);
91 W[15] = SM3_E(W[15], W[ 6], W[12], W[ 2], W[ 9]);
92 R2(A, B, C, D, E, F, G, H, 0x9D8A7A87, W[ 0], W[ 4]);
93 W[ 0] = SM3_E(W[ 0], W[ 7], W[13], W[ 3], W[10]);
94 R2(D, A, B, C, H, E, F, G, 0x3B14F50F, W[ 1], W[ 5]);
95 W[ 1] = SM3_E(W[ 1], W[ 8], W[14], W[ 4], W[11]);
96 R2(C, D, A, B, G, H, E, F, 0x7629EA1E, W[ 2], W[ 6]);
97 W[ 2] = SM3_E(W[ 2], W[ 9], W[15], W[ 5], W[12]);
98 R2(B, C, D, A, F, G, H, E, 0xEC53D43C, W[ 3], W[ 7]);
99 W[ 3] = SM3_E(W[ 3], W[10], W[ 0], W[ 6], W[13]);
100 R2(A, B, C, D, E, F, G, H, 0xD8A7A879, W[ 4], W[ 8]);
101 W[ 4] = SM3_E(W[ 4], W[11], W[ 1], W[ 7], W[14]);
102 R2(D, A, B, C, H, E, F, G, 0xB14F50F3, W[ 5], W[ 9]);
103 W[ 5] = SM3_E(W[ 5], W[12], W[ 2], W[ 8], W[15]);
104 R2(C, D, A, B, G, H, E, F, 0x629EA1E7, W[ 6], W[10]);
105 W[ 6] = SM3_E(W[ 6], W[13], W[ 3], W[ 9], W[ 0]);
106 R2(B, C, D, A, F, G, H, E, 0xC53D43CE, W[ 7], W[11]);
107 W[ 7] = SM3_E(W[ 7], W[14], W[ 4], W[10], W[ 1]);
108 R2(A, B, C, D, E, F, G, H, 0x8A7A879D, W[ 8], W[12]);
109 W[ 8] = SM3_E(W[ 8], W[15], W[ 5], W[11], W[ 2]);
110 R2(D, A, B, C, H, E, F, G, 0x14F50F3B, W[ 9], W[13]);
111 W[ 9] = SM3_E(W[ 9], W[ 0], W[ 6], W[12], W[ 3]);
112 R2(C, D, A, B, G, H, E, F, 0x29EA1E76, W[10], W[14]);
113 W[10] = SM3_E(W[10], W[ 1], W[ 7], W[13], W[ 4]);
114 R2(B, C, D, A, F, G, H, E, 0x53D43CEC, W[11], W[15]);
115 W[11] = SM3_E(W[11], W[ 2], W[ 8], W[14], W[ 5]);
116 R2(A, B, C, D, E, F, G, H, 0xA7A879D8, W[12], W[ 0]);
117 W[12] = SM3_E(W[12], W[ 3], W[ 9], W[15], W[ 6]);
118 R2(D, A, B, C, H, E, F, G, 0x4F50F3B1, W[13], W[ 1]);
119 W[13] = SM3_E(W[13], W[ 4], W[10], W[ 0], W[ 7]);
120 R2(C, D, A, B, G, H, E, F, 0x9EA1E762, W[14], W[ 2]);
121 W[14] = SM3_E(W[14], W[ 5], W[11], W[ 1], W[ 8]);
122 R2(B, C, D, A, F, G, H, E, 0x3D43CEC5, W[15], W[ 3]);
123 W[15] = SM3_E(W[15], W[ 6], W[12], W[ 2], W[ 9]);
124 R2(A, B, C, D, E, F, G, H, 0x7A879D8A, W[ 0], W[ 4]);
125 W[ 0] = SM3_E(W[ 0], W[ 7], W[13], W[ 3], W[10]);
126 R2(D, A, B, C, H, E, F, G, 0xF50F3B14, W[ 1], W[ 5]);
127 W[ 1] = SM3_E(W[ 1], W[ 8], W[14], W[ 4], W[11]);
128 R2(C, D, A, B, G, H, E, F, 0xEA1E7629, W[ 2], W[ 6]);
129 W[ 2] = SM3_E(W[ 2], W[ 9], W[15], W[ 5], W[12]);
130 R2(B, C, D, A, F, G, H, E, 0xD43CEC53, W[ 3], W[ 7]);
131 W[ 3] = SM3_E(W[ 3], W[10], W[ 0], W[ 6], W[13]);
132 R2(A, B, C, D, E, F, G, H, 0xA879D8A7, W[ 4], W[ 8]);
133 W[ 4] = SM3_E(W[ 4], W[11], W[ 1], W[ 7], W[14]);
134 R2(D, A, B, C, H, E, F, G, 0x50F3B14F, W[ 5], W[ 9]);
135 W[ 5] = SM3_E(W[ 5], W[12], W[ 2], W[ 8], W[15]);
136 R2(C, D, A, B, G, H, E, F, 0xA1E7629E, W[ 6], W[10]);
137 W[ 6] = SM3_E(W[ 6], W[13], W[ 3], W[ 9], W[ 0]);
138 R2(B, C, D, A, F, G, H, E, 0x43CEC53D, W[ 7], W[11]);
139 W[ 7] = SM3_E(W[ 7], W[14], W[ 4], W[10], W[ 1]);
140 R2(A, B, C, D, E, F, G, H, 0x879D8A7A, W[ 8], W[12]);
141 W[ 8] = SM3_E(W[ 8], W[15], W[ 5], W[11], W[ 2]);
142 R2(D, A, B, C, H, E, F, G, 0x0F3B14F5, W[ 9], W[13]);
143 W[ 9] = SM3_E(W[ 9], W[ 0], W[ 6], W[12], W[ 3]);
144 R2(C, D, A, B, G, H, E, F, 0x1E7629EA, W[10], W[14]);
145 W[10] = SM3_E(W[10], W[ 1], W[ 7], W[13], W[ 4]);
146 R2(B, C, D, A, F, G, H, E, 0x3CEC53D4, W[11], W[15]);
147 W[11] = SM3_E(W[11], W[ 2], W[ 8], W[14], W[ 5]);
148 R2(A, B, C, D, E, F, G, H, 0x79D8A7A8, W[12], W[ 0]);
149 W[12] = SM3_E(W[12], W[ 3], W[ 9], W[15], W[ 6]);
150 R2(D, A, B, C, H, E, F, G, 0xF3B14F50, W[13], W[ 1]);
151 W[13] = SM3_E(W[13], W[ 4], W[10], W[ 0], W[ 7]);
152 R2(C, D, A, B, G, H, E, F, 0xE7629EA1, W[14], W[ 2]);
153 W[14] = SM3_E(W[14], W[ 5], W[11], W[ 1], W[ 8]);
154 R2(B, C, D, A, F, G, H, E, 0xCEC53D43, W[15], W[ 3]);
155 W[15] = SM3_E(W[15], W[ 6], W[12], W[ 2], W[ 9]);
156 R2(A, B, C, D, E, F, G, H, 0x9D8A7A87, W[ 0], W[ 4]);
157 W[ 0] = SM3_E(W[ 0], W[ 7], W[13], W[ 3], W[10]);
158 R2(D, A, B, C, H, E, F, G, 0x3B14F50F, W[ 1], W[ 5]);
159 W[ 1] = SM3_E(W[ 1], W[ 8], W[14], W[ 4], W[11]);
160 R2(C, D, A, B, G, H, E, F, 0x7629EA1E, W[ 2], W[ 6]);
161 W[ 2] = SM3_E(W[ 2], W[ 9], W[15], W[ 5], W[12]);
162 R2(B, C, D, A, F, G, H, E, 0xEC53D43C, W[ 3], W[ 7]);
163 W[ 3] = SM3_E(W[ 3], W[10], W[ 0], W[ 6], W[13]);
164 R2(A, B, C, D, E, F, G, H, 0xD8A7A879, W[ 4], W[ 8]);
165 R2(D, A, B, C, H, E, F, G, 0xB14F50F3, W[ 5], W[ 9]);
166 R2(C, D, A, B, G, H, E, F, 0x629EA1E7, W[ 6], W[10]);
167 R2(B, C, D, A, F, G, H, E, 0xC53D43CE, W[ 7], W[11]);
168 R2(A, B, C, D, E, F, G, H, 0x8A7A879D, W[ 8], W[12]);
169 R2(D, A, B, C, H, E, F, G, 0x14F50F3B, W[ 9], W[13]);
170 R2(C, D, A, B, G, H, E, F, 0x29EA1E76, W[10], W[14]);
171 R2(B, C, D, A, F, G, H, E, 0x53D43CEC, W[11], W[15]);
172 R2(A, B, C, D, E, F, G, H, 0xA7A879D8, W[12], W[ 0]);
173 R2(D, A, B, C, H, E, F, G, 0x4F50F3B1, W[13], W[ 1]);
174 R2(C, D, A, B, G, H, E, F, 0x9EA1E762, W[14], W[ 2]);
175 R2(B, C, D, A, F, G, H, E, 0x3D43CEC5, W[15], W[ 3]);
176
177 // clang-format on
178
179 A = (digest[0] ^= A);
180 B = (digest[1] ^= B);
181 C = (digest[2] ^= C);
182 D = (digest[3] ^= D);
183 E = (digest[4] ^= E);
184 F = (digest[5] ^= F);
185 G = (digest[6] ^= G);
186 H = (digest[7] ^= H);
187 }
188}
Botan::CPUID::has
static bool has(CPUID::Feature feat)
Definition cpuid.h:94
Botan::SM3::block_bytes
static constexpr size_t block_bytes
Definition sm3.h:24
Botan::SM3_E
uint32_t SM3_E(uint32_t W0, uint32_t W7, uint32_t W13, uint32_t W3, uint32_t W10)
Definition sm3_fn.h:69
Botan::R2
void R2(uint32_t A, uint32_t &B, uint32_t C, uint32_t &D, uint32_t E, uint32_t &F, uint32_t G, uint32_t &H, uint32_t TJ, uint32_t Wi, uint32_t Wj)
Definition sm3_fn.h:43
Botan::R1
void R1(uint32_t A, uint32_t &B, uint32_t C, uint32_t &D, uint32_t E, uint32_t &F, uint32_t G, uint32_t &H, uint32_t TJ, uint32_t Wi, uint32_t Wj)
Definition sm3_fn.h:21
Botan::load_be
constexpr auto load_be(ParamTs &&... params)
Definition loadstor.h:504

References Botan::CPUFeature::AVX2, block_bytes, Botan::CPUFeature::BMI, Botan::CPUID::has(), Botan::load_be(), Botan::R1(), Botan::R2(), Botan::CPUFeature::SM3, Botan::SM3_E(), and Botan::BufferSlicer::take().

◆ copy_state()

std::unique_ptr< HashFunction > Botan::SM3::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 199 of file sm3.cpp.

199 {
200 return std::make_unique<SM3>(*this);
201}

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

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

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

Referenced by botan_hash_init(), Botan::BlockCipher::create(), Botan::EncryptionPaddingScheme::create(), create(), Botan::KDF::create(), Botan::MessageAuthenticationCode::create(), Botan::PasswordHashFamily::create(), Botan::PBKDF::create(), Botan::SignaturePaddingScheme::create(), and create_or_throw().

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

308 {
309 if(auto hash = HashFunction::create(algo, provider)) {
310 return hash;
311 }
312 throw Lookup_Error("Hash", algo, provider);
313}

References create(), and provider().

Referenced by botan_pubkey_fingerprint(), botan_pubkey_sm2_compute_za(), Botan::OCSP::CertID::CertID(), Botan::TLS::Client_Hello_Internal::Client_Hello_Internal(), Botan::Kyber_90s_Symmetric_Primitives::create_G(), Botan::Kyber_Modern_Symmetric_Primitives::create_G(), Botan::ML_KEM_Symmetric_Primitives::create_G(), Botan::Kyber_90s_Symmetric_Primitives::create_H(), Botan::Kyber_Modern_Symmetric_Primitives::create_H(), Botan::ML_KEM_Symmetric_Primitives::create_H(), Botan::create_hex_fingerprint(), Botan::ML_KEM_Symmetric_Primitives::create_J(), Botan::Kyber_90s_Symmetric_Primitives::create_KDF(), Botan::Kyber_Modern_Symmetric_Primitives::create_KDF(), Botan::Sodium::crypto_hash_sha256(), Botan::Sodium::crypto_hash_sha512(), Botan::Bcrypt_PBKDF::derive_key(), Botan::ed25519_gen_keypair(), Botan::ed25519_sign(), Botan::ed25519_verify(), Botan::expand_message_xmd(), Botan::TLS::Handshake_Hash::final(), Botan::Certificate_Store_In_Memory::find_cert_by_pubkey_sha1(), Botan::Certificate_Store_In_Memory::find_cert_by_raw_subject_dn_sha256(), Botan::generate_dsa_primes(), Botan::LMOTS_Params::hash(), Botan::LMS_Params::hash(), Botan::Classic_McEliece_Parameters::hash_func(), Botan::OCSP::CertID::is_id_for(), Botan::Stateful_Key_Index_Registry::KeyId::KeyId(), Botan::TLS::make_hello_random(), Botan::Roughtime::nonce_from_blind(), Botan::PKCS1v15_Raw_SignaturePaddingScheme::PKCS1v15_Raw_SignaturePaddingScheme(), 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 77 of file buf_comp.h.

77 {
78 T output(output_length());
79 final_result(output);
80 return output;
81 }
Botan::Buffered_Computation::output_length
virtual size_t output_length() const =0

References output_length().

◆ final() [2/4]

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

Definition at line 54 of file buf_comp.cpp.

54 {
55 BOTAN_ARG_CHECK(out.size() >= output_length(), "provided output buffer has insufficient capacity");
56 final_result(out);
57}
BOTAN_ARG_CHECK
#define BOTAN_ARG_CHECK(expr, msg)
Definition assert.h:33

References BOTAN_ARG_CHECK, and output_length().

◆ final() [3/4]

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

Definition at line 88 of file buf_comp.h.

88 {
89 out.resize(output_length());
90 final_result(out);
91 }

References output_length().

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

69{ final_result({out, output_length()}); }

References output_length().

Referenced by final_stdvec(), Botan::PseudorandomKeyGeneration::gen(), Botan::TPM2::Verification_Operation::is_valid_signature(), Botan::mgf1_mask(), Botan::KMAC::operator=(), Botan::pbkdf2(), Botan::Sphincs_Hash_Functions_Sha2::PRF_msg(), process(), process(), process(), Botan::TPM2::Signature_Operation::sign(), and Botan::sm2_compute_za().

◆ final_stdvec()

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

Definition at line 83 of file buf_comp.h.

83{ return final<std::vector<uint8_t>>(); }
Botan::Buffered_Computation::final
void final(uint8_t out[])
Definition buf_comp.h:69

References final().

◆ hash_block_size()

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

Reimplemented from Botan::HashFunction.

Definition at line 38 of file sm3.h.

38{ return block_bytes; }

References block_bytes.

◆ init()

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

Definition at line 190 of file sm3.cpp.

190 {
191 digest.assign(
192 {0x7380166fUL, 0x4914b2b9UL, 0x172442d7UL, 0xda8a0600UL, 0xa96f30bcUL, 0x163138aaUL, 0xe38dee4dUL, 0xb0fb0e4eUL});
193}

◆ name()

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

Implements Botan::HashFunction.

Definition at line 32 of file sm3.h.

32{ return "SM3"; }

◆ new_object()

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

Implements Botan::HashFunction.

Definition at line 195 of file sm3.cpp.

195 {
196 return std::make_unique<SM3>();
197}

◆ output_length()

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

Implements Botan::Buffered_Computation.

Definition at line 36 of file sm3.h.

36{ return output_bytes; }
Botan::SM3::output_bytes
static constexpr size_t output_bytes
Definition sm3.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 101 of file buf_comp.h.

101 {
102 update(in, length);
103 return final<T>();
104 }
Botan::Buffered_Computation::update
void update(const uint8_t in[], size_t length)
Definition buf_comp.h:34
Botan::Buffered_Computation::final
T final()
Definition buf_comp.h:77

References final(), and update().

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

125 {
126 update(in);
127 return final<T>();
128 }

References final(), and 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 113 of file buf_comp.h.

113 {
114 update(in);
115 return final<T>();
116 }

References final(), and update().

◆ provider()

std::string Botan::SM3::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 211 of file sm3.cpp.

211 {
212#if defined(BOTAN_HAS_SM3_ARMV8)
213 if(auto feat = CPUID::check(CPUID::Feature::SM3)) {
214 return *feat;
215 }
216#endif
217
218#if defined(BOTAN_HAS_SM3_X86)
219 if(auto feat = CPUID::check(CPUID::Feature::SM3, CPUID::Feature::AVX2)) {
220 return *feat;
221 }
222#endif
223
224#if defined(BOTAN_HAS_SM3_X86_AVX2_BMI2)
225 if(auto feat = CPUID::check(CPUID::Feature::AVX2, CPUID::Feature::BMI)) {
226 return *feat;
227 }
228#endif
229
230 return "base";
231}
Botan::CPUID::check
static std::optional< std::string > check(CPUID::Feature feat)
Definition cpuid.h:67

References Botan::CPUFeature::AVX2, Botan::CPUFeature::BMI, Botan::CPUID::check(), and Botan::CPUFeature::SM3.

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

315 {
316 return probe_providers_of<HashFunction>(algo_spec, {"base", "commoncrypto"});
317}
Botan::probe_providers_of
std::vector< std::string > probe_providers_of(std::string_view algo_spec, const std::vector< std::string > &possible={"base"})
Definition scan_name.h:105

References Botan::probe_providers_of().

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

34{ add_data({in, length}); }

Referenced by Botan::PseudorandomKeyGeneration::gen(), Botan::LMOTS_Public_Key::LMOTS_Public_Key(), Botan::mgf1_mask(), Botan::pbkdf2(), Botan::Sphincs_Hash_Functions_Sha2::PRF_msg(), process(), process(), process(), Botan::TLS::TLS_NULL_HMAC_AEAD_Mode::set_associated_data_n(), 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 40 of file buf_comp.h.

40{ add_data(in); }

◆ update() [3/4]

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

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

14 {
15 add_data(as_span_of_bytes(str));
16}
Botan::as_span_of_bytes
std::span< const uint8_t > as_span_of_bytes(const char *s, size_t len)
Definition mem_utils.h:59

References Botan::as_span_of_bytes().

◆ update() [4/4]

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

Process a single byte.

Parameters
inthe byte to process

Definition at line 61 of file buf_comp.h.

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

◆ update_be() [1/3]

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

Definition at line 18 of file buf_comp.cpp.

18 {
19 uint8_t inb[sizeof(val)];
20 store_be(val, inb);
21 add_data({inb, sizeof(inb)});
22}
Botan::store_be
constexpr auto store_be(ParamTs &&... params)
Definition loadstor.h:745

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 24 of file buf_comp.cpp.

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

References Botan::store_be().

◆ update_be() [3/3]

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

Definition at line 30 of file buf_comp.cpp.

30 {
31 uint8_t inb[sizeof(val)];
32 store_be(val, inb);
33 add_data({inb, sizeof(inb)});
34}

References Botan::store_be().

◆ update_le() [1/3]

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

Definition at line 36 of file buf_comp.cpp.

36 {
37 uint8_t inb[sizeof(val)];
38 store_le(val, inb);
39 add_data({inb, sizeof(inb)});
40}
Botan::store_le
constexpr auto store_le(ParamTs &&... params)
Definition loadstor.h:736

References Botan::store_le().

◆ update_le() [2/3]

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

Definition at line 42 of file buf_comp.cpp.

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

References Botan::store_le().

◆ update_le() [3/3]

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

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

Member Data Documentation

◆ bit_endianness

MD_Endian Botan::SM3::bit_endianness = MD_Endian::Big
staticconstexpr

Definition at line 23 of file sm3.h.

◆ block_bytes

size_t Botan::SM3::block_bytes = 64
staticconstexpr

Definition at line 24 of file sm3.h.

Referenced by compress_n(), and hash_block_size().

◆ byte_endianness

MD_Endian Botan::SM3::byte_endianness = MD_Endian::Big
staticconstexpr

Definition at line 22 of file sm3.h.

◆ ctr_bytes

size_t Botan::SM3::ctr_bytes = 8
staticconstexpr

Definition at line 26 of file sm3.h.

◆ output_bytes

size_t Botan::SM3::output_bytes = 32
staticconstexpr

Definition at line 25 of file sm3.h.

Referenced by output_length().

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