Botan 3.14.1
Crypto and TLS for C&
sha2_32.cpp
Go to the documentation of this file.
1/*
2* SHA-{224,256}
3* (C) 1999-2010,2017 Jack Lloyd
4* 2007 FlexSecure GmbH
5*
6* Botan is released under the Simplified BSD License (see license.txt)
7*/
8
9#include <botan/internal/sha2_32.h>
10
11#include <botan/internal/buffer_slicer.h>
12#include <botan/internal/loadstor.h>
13#include <botan/internal/sha2_32_f.h>
14#include <botan/internal/stack_scrubbing.h>
15
16#if defined(BOTAN_HAS_CPUID)
17 #include <botan/internal/cpuid.h>
18#endif
19
20namespace Botan {
21
22namespace {
23
24std::string sha256_provider() {
25#if defined(BOTAN_HAS_SHA2_32_ARMV8)
26 if(auto feat = CPUID::check(CPUID::Feature::SHA2)) {
27 return *feat;
28 }
29#endif
30
31#if defined(BOTAN_HAS_SHA2_32_X86)
32 if(auto feat = CPUID::check(CPUID::Feature::SHA)) {
33 return *feat;
34 }
35#endif
36
37#if defined(BOTAN_HAS_SHA2_32_X86_AVX2)
39 return *feat;
40 }
41#endif
42
43#if defined(BOTAN_HAS_SHA2_32_SIMD)
45 return *feat;
46 }
47#endif
48
49 return "base";
50}
51
52} // namespace
53
54/*
55* SHA-224 / SHA-256 compression function
56*/
58 std::span<const uint8_t> input,
59 size_t blocks) {
60#if defined(BOTAN_HAS_SHA2_32_X86)
62 return SHA_256::compress_digest_x86(digest, input, blocks);
63 }
64#endif
65
66#if defined(BOTAN_HAS_SHA2_32_ARMV8)
68 return SHA_256::compress_digest_armv8(digest, input, blocks);
69 }
70#endif
71
72#if defined(BOTAN_HAS_SHA2_32_X86_AVX2)
74 return SHA_256::compress_digest_x86_avx2(digest, input, blocks);
75 }
76#endif
77
78#if defined(BOTAN_HAS_SHA2_32_SIMD)
80 return SHA_256::compress_digest_x86_simd(digest, input, blocks);
81 }
82#endif
83
84 uint32_t A = digest[0];
85 uint32_t B = digest[1];
86 uint32_t C = digest[2];
87 uint32_t D = digest[3];
88 uint32_t E = digest[4];
89 uint32_t F = digest[5];
90 uint32_t G = digest[6];
91 uint32_t H = digest[7];
92
93 std::array<uint32_t, 16> W{};
94
95 BufferSlicer in(input);
96
97 for(size_t i = 0; i != blocks; ++i) {
98 load_be(W, in.take<block_bytes>());
99
100 // clang-format off
101
102 SHA2_32_F(A, B, C, D, E, F, G, H, W[ 0], W[14], W[ 9], W[ 1], SHA256_K[ 0]);
103 SHA2_32_F(H, A, B, C, D, E, F, G, W[ 1], W[15], W[10], W[ 2], SHA256_K[ 1]);
104 SHA2_32_F(G, H, A, B, C, D, E, F, W[ 2], W[ 0], W[11], W[ 3], SHA256_K[ 2]);
105 SHA2_32_F(F, G, H, A, B, C, D, E, W[ 3], W[ 1], W[12], W[ 4], SHA256_K[ 3]);
106 SHA2_32_F(E, F, G, H, A, B, C, D, W[ 4], W[ 2], W[13], W[ 5], SHA256_K[ 4]);
107 SHA2_32_F(D, E, F, G, H, A, B, C, W[ 5], W[ 3], W[14], W[ 6], SHA256_K[ 5]);
108 SHA2_32_F(C, D, E, F, G, H, A, B, W[ 6], W[ 4], W[15], W[ 7], SHA256_K[ 6]);
109 SHA2_32_F(B, C, D, E, F, G, H, A, W[ 7], W[ 5], W[ 0], W[ 8], SHA256_K[ 7]);
110 SHA2_32_F(A, B, C, D, E, F, G, H, W[ 8], W[ 6], W[ 1], W[ 9], SHA256_K[ 8]);
111 SHA2_32_F(H, A, B, C, D, E, F, G, W[ 9], W[ 7], W[ 2], W[10], SHA256_K[ 9]);
112 SHA2_32_F(G, H, A, B, C, D, E, F, W[10], W[ 8], W[ 3], W[11], SHA256_K[10]);
113 SHA2_32_F(F, G, H, A, B, C, D, E, W[11], W[ 9], W[ 4], W[12], SHA256_K[11]);
114 SHA2_32_F(E, F, G, H, A, B, C, D, W[12], W[10], W[ 5], W[13], SHA256_K[12]);
115 SHA2_32_F(D, E, F, G, H, A, B, C, W[13], W[11], W[ 6], W[14], SHA256_K[13]);
116 SHA2_32_F(C, D, E, F, G, H, A, B, W[14], W[12], W[ 7], W[15], SHA256_K[14]);
117 SHA2_32_F(B, C, D, E, F, G, H, A, W[15], W[13], W[ 8], W[ 0], SHA256_K[15]);
118
119 SHA2_32_F(A, B, C, D, E, F, G, H, W[ 0], W[14], W[ 9], W[ 1], SHA256_K[16]);
120 SHA2_32_F(H, A, B, C, D, E, F, G, W[ 1], W[15], W[10], W[ 2], SHA256_K[17]);
121 SHA2_32_F(G, H, A, B, C, D, E, F, W[ 2], W[ 0], W[11], W[ 3], SHA256_K[18]);
122 SHA2_32_F(F, G, H, A, B, C, D, E, W[ 3], W[ 1], W[12], W[ 4], SHA256_K[19]);
123 SHA2_32_F(E, F, G, H, A, B, C, D, W[ 4], W[ 2], W[13], W[ 5], SHA256_K[20]);
124 SHA2_32_F(D, E, F, G, H, A, B, C, W[ 5], W[ 3], W[14], W[ 6], SHA256_K[21]);
125 SHA2_32_F(C, D, E, F, G, H, A, B, W[ 6], W[ 4], W[15], W[ 7], SHA256_K[22]);
126 SHA2_32_F(B, C, D, E, F, G, H, A, W[ 7], W[ 5], W[ 0], W[ 8], SHA256_K[23]);
127 SHA2_32_F(A, B, C, D, E, F, G, H, W[ 8], W[ 6], W[ 1], W[ 9], SHA256_K[24]);
128 SHA2_32_F(H, A, B, C, D, E, F, G, W[ 9], W[ 7], W[ 2], W[10], SHA256_K[25]);
129 SHA2_32_F(G, H, A, B, C, D, E, F, W[10], W[ 8], W[ 3], W[11], SHA256_K[26]);
130 SHA2_32_F(F, G, H, A, B, C, D, E, W[11], W[ 9], W[ 4], W[12], SHA256_K[27]);
131 SHA2_32_F(E, F, G, H, A, B, C, D, W[12], W[10], W[ 5], W[13], SHA256_K[28]);
132 SHA2_32_F(D, E, F, G, H, A, B, C, W[13], W[11], W[ 6], W[14], SHA256_K[29]);
133 SHA2_32_F(C, D, E, F, G, H, A, B, W[14], W[12], W[ 7], W[15], SHA256_K[30]);
134 SHA2_32_F(B, C, D, E, F, G, H, A, W[15], W[13], W[ 8], W[ 0], SHA256_K[31]);
135
136 SHA2_32_F(A, B, C, D, E, F, G, H, W[ 0], W[14], W[ 9], W[ 1], SHA256_K[32]);
137 SHA2_32_F(H, A, B, C, D, E, F, G, W[ 1], W[15], W[10], W[ 2], SHA256_K[33]);
138 SHA2_32_F(G, H, A, B, C, D, E, F, W[ 2], W[ 0], W[11], W[ 3], SHA256_K[34]);
139 SHA2_32_F(F, G, H, A, B, C, D, E, W[ 3], W[ 1], W[12], W[ 4], SHA256_K[35]);
140 SHA2_32_F(E, F, G, H, A, B, C, D, W[ 4], W[ 2], W[13], W[ 5], SHA256_K[36]);
141 SHA2_32_F(D, E, F, G, H, A, B, C, W[ 5], W[ 3], W[14], W[ 6], SHA256_K[37]);
142 SHA2_32_F(C, D, E, F, G, H, A, B, W[ 6], W[ 4], W[15], W[ 7], SHA256_K[38]);
143 SHA2_32_F(B, C, D, E, F, G, H, A, W[ 7], W[ 5], W[ 0], W[ 8], SHA256_K[39]);
144 SHA2_32_F(A, B, C, D, E, F, G, H, W[ 8], W[ 6], W[ 1], W[ 9], SHA256_K[40]);
145 SHA2_32_F(H, A, B, C, D, E, F, G, W[ 9], W[ 7], W[ 2], W[10], SHA256_K[41]);
146 SHA2_32_F(G, H, A, B, C, D, E, F, W[10], W[ 8], W[ 3], W[11], SHA256_K[42]);
147 SHA2_32_F(F, G, H, A, B, C, D, E, W[11], W[ 9], W[ 4], W[12], SHA256_K[43]);
148 SHA2_32_F(E, F, G, H, A, B, C, D, W[12], W[10], W[ 5], W[13], SHA256_K[44]);
149 SHA2_32_F(D, E, F, G, H, A, B, C, W[13], W[11], W[ 6], W[14], SHA256_K[45]);
150 SHA2_32_F(C, D, E, F, G, H, A, B, W[14], W[12], W[ 7], W[15], SHA256_K[46]);
151 SHA2_32_F(B, C, D, E, F, G, H, A, W[15], W[13], W[ 8], W[ 0], SHA256_K[47]);
152
153 SHA2_32_F(A, B, C, D, E, F, G, H, W[ 0], W[14], W[ 9], W[ 1], SHA256_K[48]);
154 SHA2_32_F(H, A, B, C, D, E, F, G, W[ 1], W[15], W[10], W[ 2], SHA256_K[49]);
155 SHA2_32_F(G, H, A, B, C, D, E, F, W[ 2], W[ 0], W[11], W[ 3], SHA256_K[50]);
156 SHA2_32_F(F, G, H, A, B, C, D, E, W[ 3], W[ 1], W[12], W[ 4], SHA256_K[51]);
157 SHA2_32_F(E, F, G, H, A, B, C, D, W[ 4], W[ 2], W[13], W[ 5], SHA256_K[52]);
158 SHA2_32_F(D, E, F, G, H, A, B, C, W[ 5], W[ 3], W[14], W[ 6], SHA256_K[53]);
159 SHA2_32_F(C, D, E, F, G, H, A, B, W[ 6], W[ 4], W[15], W[ 7], SHA256_K[54]);
160 SHA2_32_F(B, C, D, E, F, G, H, A, W[ 7], W[ 5], W[ 0], W[ 8], SHA256_K[55]);
161 SHA2_32_F(A, B, C, D, E, F, G, H, W[ 8], W[ 6], W[ 1], W[ 9], SHA256_K[56]);
162 SHA2_32_F(H, A, B, C, D, E, F, G, W[ 9], W[ 7], W[ 2], W[10], SHA256_K[57]);
163 SHA2_32_F(G, H, A, B, C, D, E, F, W[10], W[ 8], W[ 3], W[11], SHA256_K[58]);
164 SHA2_32_F(F, G, H, A, B, C, D, E, W[11], W[ 9], W[ 4], W[12], SHA256_K[59]);
165 SHA2_32_F(E, F, G, H, A, B, C, D, W[12], W[10], W[ 5], W[13], SHA256_K[60]);
166 SHA2_32_F(D, E, F, G, H, A, B, C, W[13], W[11], W[ 6], W[14], SHA256_K[61]);
167 SHA2_32_F(C, D, E, F, G, H, A, B, W[14], W[12], W[ 7], W[15], SHA256_K[62]);
168 SHA2_32_F(B, C, D, E, F, G, H, A, W[15], W[13], W[ 8], W[ 0], SHA256_K[63]);
169
170 // clang-format on
171
172 A = (digest[0] += A);
173 B = (digest[1] += B);
174 C = (digest[2] += C);
175 D = (digest[3] += D);
176 E = (digest[4] += E);
177 F = (digest[5] += F);
178 G = (digest[6] += G);
179 H = (digest[7] += H);
180 }
181}
182
183std::string SHA_224::provider() const {
184 return sha256_provider();
185}
186
187void SHA_224::compress_n(digest_type& digest, std::span<const uint8_t> input, size_t blocks) {
188 SHA_256::compress_digest(digest, input, blocks);
189}
190
192 digest.assign({0xC1059ED8, 0x367CD507, 0x3070DD17, 0xF70E5939, 0xFFC00B31, 0x68581511, 0x64F98FA7, 0xBEFA4FA4});
193}
194
195std::unique_ptr<HashFunction> SHA_224::new_object() const {
196 return std::make_unique<SHA_224>();
197}
198
199std::unique_ptr<HashFunction> SHA_224::copy_state() const {
200 return std::make_unique<SHA_224>(*this);
201}
202
203void SHA_224::add_data(std::span<const uint8_t> input) {
204 m_md.update(input);
205}
206
207void SHA_224::final_result(std::span<uint8_t> output) {
208 m_md.final(output);
209}
210
211std::string SHA_256::provider() const {
212 return sha256_provider();
213}
214
215void SHA_256::compress_n(digest_type& digest, std::span<const uint8_t> input, size_t blocks) {
216 SHA_256::compress_digest(digest, input, blocks);
217}
218
220 digest.assign({0x6A09E667, 0xBB67AE85, 0x3C6EF372, 0xA54FF53A, 0x510E527F, 0x9B05688C, 0x1F83D9AB, 0x5BE0CD19});
221}
222
223std::unique_ptr<HashFunction> SHA_256::new_object() const {
224 return std::make_unique<SHA_256>();
225}
226
227std::unique_ptr<HashFunction> SHA_256::copy_state() const {
228 return std::make_unique<SHA_256>(*this);
229}
230
231void SHA_256::add_data(std::span<const uint8_t> input) {
232 m_md.update(input);
233}
234
235void SHA_256::final_result(std::span<uint8_t> output) {
236 m_md.final(output);
237}
238
239} // namespace Botan
std::span< const uint8_t > take(const size_t count)
static std::optional< std::string > check(CPUID::Feature feat)
Definition cpuid.h:66
static bool has(CPUID::Feature feat)
Definition cpuid.h:93
static void compress_n(digest_type &digest, std::span< const uint8_t > input, size_t blocks)
Definition sha2_32.cpp:187
std::string provider() const override
Definition sha2_32.cpp:183
static void init(digest_type &digest)
Definition sha2_32.cpp:191
secure_vector< uint32_t > digest_type
Definition sha2_32.h:21
std::unique_ptr< HashFunction > new_object() const override
Definition sha2_32.cpp:195
std::unique_ptr< HashFunction > copy_state() const override
Definition sha2_32.cpp:199
secure_vector< uint32_t > digest_type
Definition sha2_32.h:61
static void compress_n(digest_type &digest, std::span< const uint8_t > input, size_t blocks)
Definition sha2_32.cpp:215
static void compress_digest_x86(digest_type &digest, std::span< const uint8_t > input, size_t blocks)
static void compress_digest_armv8(digest_type &digest, std::span< const uint8_t > input, size_t blocks)
static void compress_digest(digest_type &digest, std::span< const uint8_t > input, size_t blocks)
Definition sha2_32.cpp:57
std::unique_ptr< HashFunction > new_object() const override
Definition sha2_32.cpp:223
std::unique_ptr< HashFunction > copy_state() const override
Definition sha2_32.cpp:227
std::string provider() const override
Definition sha2_32.cpp:211
static void init(digest_type &digest)
Definition sha2_32.cpp:219
static constexpr size_t block_bytes
Definition sha2_32.h:65
BOTAN_FORCE_INLINE void SHA2_32_F(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 &M1, uint32_t M2, uint32_t M3, uint32_t M4, uint32_t magic)
Definition sha2_32_f.h:33
constexpr uint32_t SHA256_K[64]
Definition sha2_32_f.h:19
constexpr auto load_be(ParamTs &&... params)
Definition loadstor.h:504
#define BOTAN_SCRUB_STACK_AFTER_RETURN