Botan 3.14.1
Crypto and TLS for C&
hash_engine_sha2_32_avx2.cpp
Go to the documentation of this file.
1/*
2* (C) 2026 Jack Lloyd
3*
4* Botan is released under the Simplified BSD License (see license.txt)
5*/
6
7#include <botan/internal/hash_engine_sha2_32.h>
8
9#include <botan/internal/isa_extn.h>
10#include <botan/internal/sha2_32_f.h>
11#include <botan/internal/simd_8x32.h>
12
13namespace Botan {
14
15namespace {
16
17BOTAN_FN_ISA_AVX2 BOTAN_FORCE_INLINE void rnd(const SIMD_8x32& A,
18 const SIMD_8x32& B,
19 const SIMD_8x32& C,
20 SIMD_8x32& D,
21 const SIMD_8x32& E,
22 const SIMD_8x32& F,
23 const SIMD_8x32& G,
24 SIMD_8x32& H,
25 const SIMD_8x32& W,
26 uint32_t K) {
27 const auto T1 = H + E.sigma1() + SIMD_8x32::choose(E, F, G) + SIMD_8x32::splat(K) + W;
28 const auto T2 = A.sigma0() + SIMD_8x32::majority(A, B, C);
29 D += T1;
30 H = T1 + T2;
31}
32
33BOTAN_FN_ISA_AVX2 BOTAN_FORCE_INLINE SIMD_8x32 next_w(SIMD_8x32 W[16], size_t i) {
34 const auto& w15 = W[(i + 1) % 16];
35 const auto& w2 = W[(i + 14) % 16];
36 const auto s0 = w15.rotr<7>() ^ w15.rotr<18>() ^ w15.shr<3>();
37 const auto s1 = w2.rotr<17>() ^ w2.rotr<19>() ^ w2.shr<10>();
38 W[i] += s0 + s1 + W[(i + 9) % 16];
39 return W[i];
40}
41
42} // namespace
43
44BOTAN_FN_ISA_AVX2 void sha2_32_mb_compress_x8(uint8_t* states, const uint8_t* const* blocks, size_t nblocks) {
45 SIMD_8x32 S[8];
46 for(size_t j = 0; j != 8; ++j) {
47 S[j] = SIMD_8x32::load_le(states + 32 * j);
48 }
49
50 for(size_t n = 0; n != nblocks; ++n) {
51 // Initialized directly from the loads, since default construction
52 // would zero the whole array first
53 SIMD_8x32 W[16] = {SIMD_8x32::load_be<64>(blocks, 0, n, 0),
54 SIMD_8x32::load_be<64>(blocks, 1, n, 0),
55 SIMD_8x32::load_be<64>(blocks, 2, n, 0),
56 SIMD_8x32::load_be<64>(blocks, 3, n, 0),
57 SIMD_8x32::load_be<64>(blocks, 4, n, 0),
58 SIMD_8x32::load_be<64>(blocks, 5, n, 0),
59 SIMD_8x32::load_be<64>(blocks, 6, n, 0),
60 SIMD_8x32::load_be<64>(blocks, 7, n, 0),
61 SIMD_8x32::load_be<64>(blocks, 0, n, 32),
62 SIMD_8x32::load_be<64>(blocks, 1, n, 32),
63 SIMD_8x32::load_be<64>(blocks, 2, n, 32),
64 SIMD_8x32::load_be<64>(blocks, 3, n, 32),
65 SIMD_8x32::load_be<64>(blocks, 4, n, 32),
66 SIMD_8x32::load_be<64>(blocks, 5, n, 32),
67 SIMD_8x32::load_be<64>(blocks, 6, n, 32),
68 SIMD_8x32::load_be<64>(blocks, 7, n, 32)};
69 SIMD_8x32::transpose(W[0], W[1], W[2], W[3], W[4], W[5], W[6], W[7]);
70 SIMD_8x32::transpose(W[8], W[9], W[10], W[11], W[12], W[13], W[14], W[15]);
71
72 SIMD_8x32 A = S[0];
73 SIMD_8x32 B = S[1];
74 SIMD_8x32 C = S[2];
75 SIMD_8x32 D = S[3];
76 SIMD_8x32 E = S[4];
77 SIMD_8x32 F = S[5];
78 SIMD_8x32 G = S[6];
79 SIMD_8x32 H = S[7];
80
81 for(size_t t = 0; t != 16; t += 8) {
82 rnd(A, B, C, D, E, F, G, H, W[t + 0], SHA256_K[t + 0]);
83 rnd(H, A, B, C, D, E, F, G, W[t + 1], SHA256_K[t + 1]);
84 rnd(G, H, A, B, C, D, E, F, W[t + 2], SHA256_K[t + 2]);
85 rnd(F, G, H, A, B, C, D, E, W[t + 3], SHA256_K[t + 3]);
86 rnd(E, F, G, H, A, B, C, D, W[t + 4], SHA256_K[t + 4]);
87 rnd(D, E, F, G, H, A, B, C, W[t + 5], SHA256_K[t + 5]);
88 rnd(C, D, E, F, G, H, A, B, W[t + 6], SHA256_K[t + 6]);
89 rnd(B, C, D, E, F, G, H, A, W[t + 7], SHA256_K[t + 7]);
90 }
91
92 for(size_t t = 16; t != 64; t += 8) {
93 rnd(A, B, C, D, E, F, G, H, next_w(W, (t + 0) % 16), SHA256_K[t + 0]);
94 rnd(H, A, B, C, D, E, F, G, next_w(W, (t + 1) % 16), SHA256_K[t + 1]);
95 rnd(G, H, A, B, C, D, E, F, next_w(W, (t + 2) % 16), SHA256_K[t + 2]);
96 rnd(F, G, H, A, B, C, D, E, next_w(W, (t + 3) % 16), SHA256_K[t + 3]);
97 rnd(E, F, G, H, A, B, C, D, next_w(W, (t + 4) % 16), SHA256_K[t + 4]);
98 rnd(D, E, F, G, H, A, B, C, next_w(W, (t + 5) % 16), SHA256_K[t + 5]);
99 rnd(C, D, E, F, G, H, A, B, next_w(W, (t + 6) % 16), SHA256_K[t + 6]);
100 rnd(B, C, D, E, F, G, H, A, next_w(W, (t + 7) % 16), SHA256_K[t + 7]);
101 }
102
103 S[0] += A;
104 S[1] += B;
105 S[2] += C;
106 S[3] += D;
107 S[4] += E;
108 S[5] += F;
109 S[6] += G;
110 S[7] += H;
111 }
112
113 for(size_t j = 0; j != 8; ++j) {
114 S[j].store_le(states + 32 * j);
115 }
116}
117
118BOTAN_FN_ISA_AVX2 void sha2_32_mb_extract_x8(const uint8_t* states, uint8_t* digests) {
119 SIMD_8x32 S[8];
120 for(size_t j = 0; j != 8; ++j) {
121 S[j] = SIMD_8x32::load_le(states + 32 * j);
122 }
123
124 // Each S[j] holds word j of all 8 lanes; the transpose turns that
125 // into the 8 words of each lane
126 SIMD_8x32::transpose(S[0], S[1], S[2], S[3], S[4], S[5], S[6], S[7]);
127
128 for(size_t l = 0; l != 8; ++l) {
129 S[l].store_be(digests + 32 * l);
130 }
131}
132
133} // namespace Botan
BOTAN_FN_ISA_SIMD_8X32 SIMD_8x32 shr() const noexcept
Definition simd_8x32.h:232
static BOTAN_FN_ISA_SIMD_8X32 SIMD_8x32 splat(uint32_t B) noexcept
Definition simd_8x32.h:58
static BOTAN_FN_ISA_SIMD_8X32 void transpose(SIMD_8x32 &B0, SIMD_8x32 &B1, SIMD_8x32 &B2, SIMD_8x32 &B3) noexcept
Definition simd_8x32.h:274
static BOTAN_FN_ISA_SIMD_8X32 SIMD_8x32 load_le(const uint8_t *in) noexcept
Definition simd_8x32.h:61
BOTAN_FN_ISA_SIMD_8X32 SIMD_8x32 rotr() const noexcept
Definition simd_8x32.h:155
static BOTAN_FN_ISA_SIMD_8X32 SIMD_8x32 choose(const SIMD_8x32 &mask, const SIMD_8x32 &a, const SIMD_8x32 &b) noexcept
Definition simd_8x32.h:334
SIMD_8x32 BOTAN_FN_ISA_SIMD_8X32 sigma0() const noexcept
Definition simd_8x32.h:159
static BOTAN_FN_ISA_SIMD_8X32 SIMD_8x32 load_be(const uint8_t *in) noexcept
Definition simd_8x32.h:81
BOTAN_FN_ISA_SIMD_8X32 void store_be(uint8_t out[]) const noexcept
Definition simd_8x32.h:123
static BOTAN_FN_ISA_SIMD_8X32 SIMD_8x32 majority(const SIMD_8x32 &x, const SIMD_8x32 &y, const SIMD_8x32 &z) noexcept
Definition simd_8x32.h:343
BOTAN_FN_ISA_SIMD_8X32 void store_le(uint8_t out[]) const noexcept
Definition simd_8x32.h:94
#define BOTAN_FORCE_INLINE
Definition compiler.h:86
BOTAN_FN_ISA_AVX2 void sha2_32_mb_extract_x8(const uint8_t *states, uint8_t *digests)
constexpr uint32_t SHA256_K[64]
Definition sha2_32_f.h:19
BOTAN_FN_ISA_AVX2 void sha2_32_mb_compress_x8(uint8_t *states, const uint8_t *const *blocks, size_t nblocks)