1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright (c) 2021 Marvell.
3 */
4
5 #include "roc_api.h"
6
7 #define lrot32(bits, word) (((word) << (bits)) | ((word) >> (32 - (bits))))
8 #define rrot32(bits, word) lrot32(32 - (bits), word)
9 #define lrot64(bits, word) (((word) << (bits)) | ((word) >> (64 - (bits))))
10 #define rrot64(bits, word) lrot64(64 - (bits), word)
11
12 /*
13 * Compute a partial hash with the assumption that msg is the first block.
14 * Based on implementation from RFC 3174
15 */
16 void
roc_hash_sha1_gen(uint8_t * msg,uint32_t * hash)17 roc_hash_sha1_gen(uint8_t *msg, uint32_t *hash)
18 {
19 const uint32_t _K[] = {/* Round Constants defined in SHA-1 */
20 0x5A827999, 0x6ED9EBA1, 0x8F1BBCDC, 0xCA62C1D6};
21
22 const uint32_t _H[] = {/* Initial Hash constants defined in SHA-1 */
23 0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476,
24 0xC3D2E1F0};
25 int i;
26 uint32_t temp = 0; /* Temporary word value */
27 uint32_t W[80]; /* Word sequence */
28 uint32_t A, B, C, D, E; /* Word buffers */
29
30 /* Initialize the first 16 words in the array W */
31 memcpy(&W[0], msg, 16 * sizeof(W[0]));
32
33 for (i = 0; i < 16; i++)
34 W[i] = htobe32(W[i]);
35
36 for (i = 16; i < 80; i++)
37 W[i] = lrot32(1, W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16]);
38
39 A = _H[0];
40 B = _H[1];
41 C = _H[2];
42 D = _H[3];
43 E = _H[4];
44
45 for (i = 0; i < 80; i++) {
46 if (i >= 0 && i <= 19)
47 temp = ((B & C) | ((~B) & D)) + _K[0];
48 else if (i >= 20 && i <= 39)
49 temp = (B ^ C ^ D) + _K[1];
50 else if (i >= 40 && i <= 59)
51 temp = ((B & C) | (B & D) | (C & D)) + _K[2];
52 else if (i >= 60 && i <= 79)
53 temp = (B ^ C ^ D) + _K[3];
54
55 temp = lrot32(5, A) + temp + E + W[i];
56 E = D;
57 D = C;
58 C = lrot32(30, B);
59 B = A;
60 A = temp;
61 }
62
63 A += _H[0];
64 B += _H[1];
65 C += _H[2];
66 D += _H[3];
67 E += _H[4];
68 hash[0] = htobe32(A);
69 hash[1] = htobe32(B);
70 hash[2] = htobe32(C);
71 hash[3] = htobe32(D);
72 hash[4] = htobe32(E);
73 }
74
75 /*
76 * Compute a partial hash with the assumption that msg is the first block.
77 * Based on implementation from RFC 3174
78 */
79 void
roc_hash_sha256_gen(uint8_t * msg,uint32_t * hash)80 roc_hash_sha256_gen(uint8_t *msg, uint32_t *hash)
81 {
82 const uint32_t _K[] = {
83 /* Round Constants defined in SHA-256 */
84 0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b,
85 0x59f111f1, 0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01,
86 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7,
87 0xc19bf174, 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,
88 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da, 0x983e5152,
89 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147,
90 0x06ca6351, 0x14292967, 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc,
91 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
92 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819,
93 0xd6990624, 0xf40e3585, 0x106aa070, 0x19a4c116, 0x1e376c08,
94 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f,
95 0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
96 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2};
97
98 const uint32_t _H[] = {/* Initial Hash constants defined in SHA-256 */
99 0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a,
100 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19};
101 int i;
102 uint32_t temp[4], S0, S1; /* Temporary word value */
103 uint32_t W[64]; /* Word sequence */
104 uint32_t A, B, C, D, E, F, G, H; /* Word buffers */
105
106 /* Initialize the first 16 words in the array W */
107 memcpy(&W[0], msg, 16 * sizeof(W[0]));
108
109 for (i = 0; i < 16; i++)
110 W[i] = htobe32(W[i]);
111
112 for (i = 16; i < 64; i++) {
113 S0 = rrot32(7, W[i - 15]) ^ rrot32(18, W[i - 15]) ^
114 (W[i - 15] >> 3);
115 S1 = rrot32(17, W[i - 2]) ^ rrot32(19, W[i - 2]) ^
116 (W[i - 2] >> 10);
117 W[i] = W[i - 16] + S0 + W[i - 7] + S1;
118 }
119
120 A = _H[0];
121 B = _H[1];
122 C = _H[2];
123 D = _H[3];
124 E = _H[4];
125 F = _H[5];
126 G = _H[6];
127 H = _H[7];
128
129 for (i = 0; i < 64; i++) {
130 S1 = rrot32(6, E) ^ rrot32(11, E) ^ rrot32(25, E);
131 temp[0] = (E & F) ^ ((~E) & G);
132 temp[1] = H + S1 + temp[0] + _K[i] + W[i];
133 S0 = rrot32(2, A) ^ rrot32(13, A) ^ rrot32(22, A);
134 temp[2] = (A & B) ^ (A & C) ^ (B & C);
135 temp[3] = S0 + temp[2];
136
137 H = G;
138 G = F;
139 F = E;
140 E = D + temp[1];
141 D = C;
142 C = B;
143 B = A;
144 A = temp[1] + temp[3];
145 }
146
147 A += _H[0];
148 B += _H[1];
149 C += _H[2];
150 D += _H[3];
151 E += _H[4];
152 F += _H[5];
153 G += _H[6];
154 H += _H[7];
155 hash[0] = htobe32(A);
156 hash[1] = htobe32(B);
157 hash[2] = htobe32(C);
158 hash[3] = htobe32(D);
159 hash[4] = htobe32(E);
160 hash[5] = htobe32(F);
161 hash[6] = htobe32(G);
162 hash[7] = htobe32(H);
163 }
164
165 /*
166 * Compute a partial hash with the assumption that msg is the first block.
167 * Based on implementation from RFC 3174
168 */
169 void
roc_hash_sha512_gen(uint8_t * msg,uint64_t * hash,int hash_size)170 roc_hash_sha512_gen(uint8_t *msg, uint64_t *hash, int hash_size)
171 {
172 const uint64_t _K[] = {
173 /* Round Constants defined in SHA-512 */
174 0x428a2f98d728ae22, 0x7137449123ef65cd, 0xb5c0fbcfec4d3b2f,
175 0xe9b5dba58189dbbc, 0x3956c25bf348b538, 0x59f111f1b605d019,
176 0x923f82a4af194f9b, 0xab1c5ed5da6d8118, 0xd807aa98a3030242,
177 0x12835b0145706fbe, 0x243185be4ee4b28c, 0x550c7dc3d5ffb4e2,
178 0x72be5d74f27b896f, 0x80deb1fe3b1696b1, 0x9bdc06a725c71235,
179 0xc19bf174cf692694, 0xe49b69c19ef14ad2, 0xefbe4786384f25e3,
180 0x0fc19dc68b8cd5b5, 0x240ca1cc77ac9c65, 0x2de92c6f592b0275,
181 0x4a7484aa6ea6e483, 0x5cb0a9dcbd41fbd4, 0x76f988da831153b5,
182 0x983e5152ee66dfab, 0xa831c66d2db43210, 0xb00327c898fb213f,
183 0xbf597fc7beef0ee4, 0xc6e00bf33da88fc2, 0xd5a79147930aa725,
184 0x06ca6351e003826f, 0x142929670a0e6e70, 0x27b70a8546d22ffc,
185 0x2e1b21385c26c926, 0x4d2c6dfc5ac42aed, 0x53380d139d95b3df,
186 0x650a73548baf63de, 0x766a0abb3c77b2a8, 0x81c2c92e47edaee6,
187 0x92722c851482353b, 0xa2bfe8a14cf10364, 0xa81a664bbc423001,
188 0xc24b8b70d0f89791, 0xc76c51a30654be30, 0xd192e819d6ef5218,
189 0xd69906245565a910, 0xf40e35855771202a, 0x106aa07032bbd1b8,
190 0x19a4c116b8d2d0c8, 0x1e376c085141ab53, 0x2748774cdf8eeb99,
191 0x34b0bcb5e19b48a8, 0x391c0cb3c5c95a63, 0x4ed8aa4ae3418acb,
192 0x5b9cca4f7763e373, 0x682e6ff3d6b2b8a3, 0x748f82ee5defb2fc,
193 0x78a5636f43172f60, 0x84c87814a1f0ab72, 0x8cc702081a6439ec,
194 0x90befffa23631e28, 0xa4506cebde82bde9, 0xbef9a3f7b2c67915,
195 0xc67178f2e372532b, 0xca273eceea26619c, 0xd186b8c721c0c207,
196 0xeada7dd6cde0eb1e, 0xf57d4f7fee6ed178, 0x06f067aa72176fba,
197 0x0a637dc5a2c898a6, 0x113f9804bef90dae, 0x1b710b35131c471b,
198 0x28db77f523047d84, 0x32caab7b40c72493, 0x3c9ebe0a15c9bebc,
199 0x431d67c49c100d4c, 0x4cc5d4becb3e42b6, 0x597f299cfc657e2a,
200 0x5fcb6fab3ad6faec, 0x6c44198c4a475817};
201
202 const uint64_t _H384[] = {/* Initial Hash constants defined in SHA384 */
203 0xcbbb9d5dc1059ed8, 0x629a292a367cd507,
204 0x9159015a3070dd17, 0x152fecd8f70e5939,
205 0x67332667ffc00b31, 0x8eb44a8768581511,
206 0xdb0c2e0d64f98fa7, 0x47b5481dbefa4fa4};
207 const uint64_t _H512[] = {/* Initial Hash constants defined in SHA512 */
208 0x6a09e667f3bcc908, 0xbb67ae8584caa73b,
209 0x3c6ef372fe94f82b, 0xa54ff53a5f1d36f1,
210 0x510e527fade682d1, 0x9b05688c2b3e6c1f,
211 0x1f83d9abfb41bd6b, 0x5be0cd19137e2179};
212 int i;
213 uint64_t temp[4], S0, S1; /* Temporary word value */
214 uint64_t W[80]; /* Word sequence */
215 uint64_t A, B, C, D, E, F, G, H; /* Word buffers */
216 const uint64_t *_H = (hash_size == 384) ? _H384 : _H512;
217
218 /* Initialize the first 16 words in the array W */
219 memcpy(&W[0], msg, 16 * sizeof(W[0]));
220
221 for (i = 0; i < 16; i++)
222 W[i] = htobe64(W[i]);
223
224 for (i = 16; i < 80; i++) {
225 S0 = rrot64(1, W[i - 15]) ^ rrot64(8, W[i - 15]) ^
226 (W[i - 15] >> 7);
227 S1 = rrot64(19, W[i - 2]) ^ rrot64(61, W[i - 2]) ^
228 (W[i - 2] >> 6);
229 W[i] = W[i - 16] + S0 + W[i - 7] + S1;
230 }
231
232 A = _H[0];
233 B = _H[1];
234 C = _H[2];
235 D = _H[3];
236 E = _H[4];
237 F = _H[5];
238 G = _H[6];
239 H = _H[7];
240
241 for (i = 0; i < 80; i++) {
242 S1 = rrot64(14, E) ^ rrot64(18, E) ^ rrot64(41, E);
243 temp[0] = (E & F) ^ ((~E) & G);
244 temp[1] = H + S1 + temp[0] + _K[i] + W[i];
245 S0 = rrot64(28, A) ^ rrot64(34, A) ^ rrot64(39, A);
246 temp[2] = (A & B) ^ (A & C) ^ (B & C);
247 temp[3] = S0 + temp[2];
248
249 H = G;
250 G = F;
251 F = E;
252 E = D + temp[1];
253 D = C;
254 C = B;
255 B = A;
256 A = temp[1] + temp[3];
257 }
258
259 A += _H[0];
260 B += _H[1];
261 C += _H[2];
262 D += _H[3];
263 E += _H[4];
264 F += _H[5];
265 G += _H[6];
266 H += _H[7];
267 hash[0] = htobe64(A);
268 hash[1] = htobe64(B);
269 hash[2] = htobe64(C);
270 hash[3] = htobe64(D);
271 hash[4] = htobe64(E);
272 hash[5] = htobe64(F);
273 hash[6] = htobe64(G);
274 hash[7] = htobe64(H);
275 }
276