Debian Codegraph @

src/lib/block/shacal2/shacal2_avx2/shacal2_avx2.cpp

raw
1 /*
2 * (C) 2018 Jack Lloyd
3 *
4 * Botan is released under the Simplified BSD License (see license.txt)
5 */
6
7 #include <botan/internal/shacal2.h>
8
9 #include <botan/internal/simd_avx2.h>
10
11 namespace Botan {
12
13 namespace SHACAL2_AVX2_F {
14
15 namespace {
16
17 void BOTAN_FORCE_INLINE BOTAN_FN_ISA_AVX2 SHACAL2_Fwd(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 uint32_t RK) {
26 H += E.sigma1() + SIMD_8x32::choose(E, F, G) + SIMD_8x32::splat(RK);
27 D += H;
28 H += A.sigma0() + SIMD_8x32::majority(A, B, C);
29 }
30
31 void BOTAN_FORCE_INLINE BOTAN_FN_ISA_AVX2 SHACAL2_Rev(const SIMD_8x32& A,
32 const SIMD_8x32& B,
33 const SIMD_8x32& C,
34 SIMD_8x32& D,
35 const SIMD_8x32& E,
36 const SIMD_8x32& F,
37 const SIMD_8x32& G,
38 SIMD_8x32& H,
39 uint32_t RK) {
40 H -= A.sigma0() + SIMD_8x32::majority(A, B, C);
41 D -= H;
42 H -= E.sigma1() + SIMD_8x32::choose(E, F, G) + SIMD_8x32::splat(RK);
43 }
44
45 } // namespace
46
47 } // namespace SHACAL2_AVX2_F
48
49 void BOTAN_FN_ISA_AVX2 SHACAL2::avx2_encrypt_8(const uint8_t in[], uint8_t out[]) const {
50 using namespace SHACAL2_AVX2_F;
51
52 SIMD_8x32::reset_registers();
53
54 SIMD_8x32 A = SIMD_8x32::load_be(in);
55 SIMD_8x32 B = SIMD_8x32::load_be(in + 32);
56 SIMD_8x32 C = SIMD_8x32::load_be(in + 64);
57 SIMD_8x32 D = SIMD_8x32::load_be(in + 96);
58
59 SIMD_8x32 E = SIMD_8x32::load_be(in + 128);
60 SIMD_8x32 F = SIMD_8x32::load_be(in + 160);
61 SIMD_8x32 G = SIMD_8x32::load_be(in + 192);
62 SIMD_8x32 H = SIMD_8x32::load_be(in + 224);
63
64 SIMD_8x32::transpose(A, B, C, D, E, F, G, H);
65
66 for(size_t r = 0; r != 64; r += 8) {
67 SHACAL2_Fwd(A, B, C, D, E, F, G, H, m_RK[r + 0]);
68 SHACAL2_Fwd(H, A, B, C, D, E, F, G, m_RK[r + 1]);
69 SHACAL2_Fwd(G, H, A, B, C, D, E, F, m_RK[r + 2]);
70 SHACAL2_Fwd(F, G, H, A, B, C, D, E, m_RK[r + 3]);
71 SHACAL2_Fwd(E, F, G, H, A, B, C, D, m_RK[r + 4]);
72 SHACAL2_Fwd(D, E, F, G, H, A, B, C, m_RK[r + 5]);
73 SHACAL2_Fwd(C, D, E, F, G, H, A, B, m_RK[r + 6]);
74 SHACAL2_Fwd(B, C, D, E, F, G, H, A, m_RK[r + 7]);
75 }
76
77 SIMD_8x32::transpose(A, B, C, D, E, F, G, H);
78
79 A.store_be(out);
80 B.store_be(out + 32);
81 C.store_be(out + 64);
82 D.store_be(out + 96);
83
84 E.store_be(out + 128);
85 F.store_be(out + 160);
86 G.store_be(out + 192);
87 H.store_be(out + 224);
88
89 SIMD_8x32::zero_registers();
90 }
91
92 void BOTAN_FN_ISA_AVX2 SHACAL2::avx2_decrypt_8(const uint8_t in[], uint8_t out[]) const {
93 using namespace SHACAL2_AVX2_F;
94
95 SIMD_8x32::reset_registers();
96
97 SIMD_8x32 A = SIMD_8x32::load_be(in);
98 SIMD_8x32 B = SIMD_8x32::load_be(in + 32);
99 SIMD_8x32 C = SIMD_8x32::load_be(in + 64);
100 SIMD_8x32 D = SIMD_8x32::load_be(in + 96);
101
102 SIMD_8x32 E = SIMD_8x32::load_be(in + 128);
103 SIMD_8x32 F = SIMD_8x32::load_be(in + 160);
104 SIMD_8x32 G = SIMD_8x32::load_be(in + 192);
105 SIMD_8x32 H = SIMD_8x32::load_be(in + 224);
106
107 SIMD_8x32::transpose(A, B, C, D, E, F, G, H);
108
109 for(size_t r = 0; r != 64; r += 8) {
110 SHACAL2_Rev(B, C, D, E, F, G, H, A, m_RK[63 - r]);
111 SHACAL2_Rev(C, D, E, F, G, H, A, B, m_RK[62 - r]);
112 SHACAL2_Rev(D, E, F, G, H, A, B, C, m_RK[61 - r]);
113 SHACAL2_Rev(E, F, G, H, A, B, C, D, m_RK[60 - r]);
114 SHACAL2_Rev(F, G, H, A, B, C, D, E, m_RK[59 - r]);
115 SHACAL2_Rev(G, H, A, B, C, D, E, F, m_RK[58 - r]);
116 SHACAL2_Rev(H, A, B, C, D, E, F, G, m_RK[57 - r]);
117 SHACAL2_Rev(A, B, C, D, E, F, G, H, m_RK[56 - r]);
118 }
119
120 SIMD_8x32::transpose(A, B, C, D, E, F, G, H);
121
122 A.store_be(out);
123 B.store_be(out + 32);
124 C.store_be(out + 64);
125 D.store_be(out + 96);
126
127 E.store_be(out + 128);
128 F.store_be(out + 160);
129 G.store_be(out + 192);
130 H.store_be(out + 224);
131
132 SIMD_8x32::zero_registers();
133 }
134
135 } // namespace Botan