Debian Codegraph @

Modules/_hacl/Hacl_Hash_SHA3.c

raw
1 /* MIT License
2 *
3 * Copyright (c) 2016-2022 INRIA, CMU and Microsoft Corporation
4 * Copyright (c) 2022-2023 HACL* Contributors
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in all
14 * copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
22 * SOFTWARE.
23 */
24
25
26 #include "internal/Hacl_Hash_SHA3.h"
27
28 #include "Hacl_Streaming_Types.h"
29 #include "internal/Hacl_Streaming_Types.h"
30
31 const
32 uint32_t
33 Hacl_Hash_SHA3_keccak_rotc[24U] =
34 {
35 1U, 3U, 6U, 10U, 15U, 21U, 28U, 36U, 45U, 55U, 2U, 14U, 27U, 41U, 56U, 8U, 25U, 43U, 62U, 18U,
36 39U, 61U, 20U, 44U
37 };
38
39 const
40 uint32_t
41 Hacl_Hash_SHA3_keccak_piln[24U] =
42 {
43 10U, 7U, 11U, 17U, 18U, 3U, 5U, 16U, 8U, 21U, 24U, 4U, 15U, 23U, 19U, 13U, 12U, 2U, 20U, 14U,
44 22U, 9U, 6U, 1U
45 };
46
47 const
48 uint64_t
49 Hacl_Hash_SHA3_keccak_rndc[24U] =
50 {
51 0x0000000000000001ULL, 0x0000000000008082ULL, 0x800000000000808aULL, 0x8000000080008000ULL,
52 0x000000000000808bULL, 0x0000000080000001ULL, 0x8000000080008081ULL, 0x8000000000008009ULL,
53 0x000000000000008aULL, 0x0000000000000088ULL, 0x0000000080008009ULL, 0x000000008000000aULL,
54 0x000000008000808bULL, 0x800000000000008bULL, 0x8000000000008089ULL, 0x8000000000008003ULL,
55 0x8000000000008002ULL, 0x8000000000000080ULL, 0x000000000000800aULL, 0x800000008000000aULL,
56 0x8000000080008081ULL, 0x8000000000008080ULL, 0x0000000080000001ULL, 0x8000000080008008ULL
57 };
58
59 static void absorb_inner_32(uint8_t *b, uint64_t *s)
60 {
61 uint64_t ws[32U] = { 0U };
62 uint8_t *b1 = b;
63 uint64_t u = load64_le(b1);
64 ws[0U] = u;
65 uint64_t u0 = load64_le(b1 + 8U);
66 ws[1U] = u0;
67 uint64_t u1 = load64_le(b1 + 16U);
68 ws[2U] = u1;
69 uint64_t u2 = load64_le(b1 + 24U);
70 ws[3U] = u2;
71 uint64_t u3 = load64_le(b1 + 32U);
72 ws[4U] = u3;
73 uint64_t u4 = load64_le(b1 + 40U);
74 ws[5U] = u4;
75 uint64_t u5 = load64_le(b1 + 48U);
76 ws[6U] = u5;
77 uint64_t u6 = load64_le(b1 + 56U);
78 ws[7U] = u6;
79 uint64_t u7 = load64_le(b1 + 64U);
80 ws[8U] = u7;
81 uint64_t u8 = load64_le(b1 + 72U);
82 ws[9U] = u8;
83 uint64_t u9 = load64_le(b1 + 80U);
84 ws[10U] = u9;
85 uint64_t u10 = load64_le(b1 + 88U);
86 ws[11U] = u10;
87 uint64_t u11 = load64_le(b1 + 96U);
88 ws[12U] = u11;
89 uint64_t u12 = load64_le(b1 + 104U);
90 ws[13U] = u12;
91 uint64_t u13 = load64_le(b1 + 112U);
92 ws[14U] = u13;
93 uint64_t u14 = load64_le(b1 + 120U);
94 ws[15U] = u14;
95 uint64_t u15 = load64_le(b1 + 128U);
96 ws[16U] = u15;
97 uint64_t u16 = load64_le(b1 + 136U);
98 ws[17U] = u16;
99 uint64_t u17 = load64_le(b1 + 144U);
100 ws[18U] = u17;
101 uint64_t u18 = load64_le(b1 + 152U);
102 ws[19U] = u18;
103 uint64_t u19 = load64_le(b1 + 160U);
104 ws[20U] = u19;
105 uint64_t u20 = load64_le(b1 + 168U);
106 ws[21U] = u20;
107 uint64_t u21 = load64_le(b1 + 176U);
108 ws[22U] = u21;
109 uint64_t u22 = load64_le(b1 + 184U);
110 ws[23U] = u22;
111 uint64_t u23 = load64_le(b1 + 192U);
112 ws[24U] = u23;
113 uint64_t u24 = load64_le(b1 + 200U);
114 ws[25U] = u24;
115 uint64_t u25 = load64_le(b1 + 208U);
116 ws[26U] = u25;
117 uint64_t u26 = load64_le(b1 + 216U);
118 ws[27U] = u26;
119 uint64_t u27 = load64_le(b1 + 224U);
120 ws[28U] = u27;
121 uint64_t u28 = load64_le(b1 + 232U);
122 ws[29U] = u28;
123 uint64_t u29 = load64_le(b1 + 240U);
124 ws[30U] = u29;
125 uint64_t u30 = load64_le(b1 + 248U);
126 ws[31U] = u30;
127 for (uint32_t i = 0U; i < 25U; i++)
128 {
129 s[i] = s[i] ^ ws[i];
130 }
131 for (uint32_t i0 = 0U; i0 < 24U; i0++)
132 {
133 uint64_t _C[5U] = { 0U };
134 KRML_MAYBE_FOR5(i,
135 0U,
136 5U,
137 1U,
138 _C[i] = s[i + 0U] ^ (s[i + 5U] ^ (s[i + 10U] ^ (s[i + 15U] ^ s[i + 20U]))););
139 KRML_MAYBE_FOR5(i1,
140 0U,
141 5U,
142 1U,
143 uint64_t uu____0 = _C[(i1 + 1U) % 5U];
144 uint64_t _D = _C[(i1 + 4U) % 5U] ^ (uu____0 << 1U | uu____0 >> 63U);
145 KRML_MAYBE_FOR5(i, 0U, 5U, 1U, s[i1 + 5U * i] = s[i1 + 5U * i] ^ _D;););
146 uint64_t x = s[1U];
147 uint64_t current = x;
148 for (uint32_t i = 0U; i < 24U; i++)
149 {
150 uint32_t _Y = Hacl_Hash_SHA3_keccak_piln[i];
151 uint32_t r = Hacl_Hash_SHA3_keccak_rotc[i];
152 uint64_t temp = s[_Y];
153 uint64_t uu____1 = current;
154 s[_Y] = uu____1 << r | uu____1 >> (64U - r);
155 current = temp;
156 }
157 KRML_MAYBE_FOR5(i,
158 0U,
159 5U,
160 1U,
161 uint64_t v0 = s[0U + 5U * i] ^ (~s[1U + 5U * i] & s[2U + 5U * i]);
162 uint64_t v1 = s[1U + 5U * i] ^ (~s[2U + 5U * i] & s[3U + 5U * i]);
163 uint64_t v2 = s[2U + 5U * i] ^ (~s[3U + 5U * i] & s[4U + 5U * i]);
164 uint64_t v3 = s[3U + 5U * i] ^ (~s[4U + 5U * i] & s[0U + 5U * i]);
165 uint64_t v4 = s[4U + 5U * i] ^ (~s[0U + 5U * i] & s[1U + 5U * i]);
166 s[0U + 5U * i] = v0;
167 s[1U + 5U * i] = v1;
168 s[2U + 5U * i] = v2;
169 s[3U + 5U * i] = v3;
170 s[4U + 5U * i] = v4;);
171 uint64_t c = Hacl_Hash_SHA3_keccak_rndc[i0];
172 s[0U] = s[0U] ^ c;
173 }
174 }
175
176 static uint32_t block_len(Spec_Hash_Definitions_hash_alg a)
177 {
178 switch (a)
179 {
180 case Spec_Hash_Definitions_SHA3_224:
181 {
182 return 144U;
183 }
184 case Spec_Hash_Definitions_SHA3_256:
185 {
186 return 136U;
187 }
188 case Spec_Hash_Definitions_SHA3_384:
189 {
190 return 104U;
191 }
192 case Spec_Hash_Definitions_SHA3_512:
193 {
194 return 72U;
195 }
196 case Spec_Hash_Definitions_Shake128:
197 {
198 return 168U;
199 }
200 case Spec_Hash_Definitions_Shake256:
201 {
202 return 136U;
203 }
204 default:
205 {
206 KRML_HOST_EPRINTF("KaRaMeL incomplete match at %s:%d\n", __FILE__, __LINE__);
207 KRML_HOST_EXIT(253U);
208 }
209 }
210 }
211
212 static uint32_t hash_len(Spec_Hash_Definitions_hash_alg a)
213 {
214 switch (a)
215 {
216 case Spec_Hash_Definitions_SHA3_224:
217 {
218 return 28U;
219 }
220 case Spec_Hash_Definitions_SHA3_256:
221 {
222 return 32U;
223 }
224 case Spec_Hash_Definitions_SHA3_384:
225 {
226 return 48U;
227 }
228 case Spec_Hash_Definitions_SHA3_512:
229 {
230 return 64U;
231 }
232 default:
233 {
234 KRML_HOST_EPRINTF("KaRaMeL incomplete match at %s:%d\n", __FILE__, __LINE__);
235 KRML_HOST_EXIT(253U);
236 }
237 }
238 }
239
240 void Hacl_Hash_SHA3_init_(Spec_Hash_Definitions_hash_alg a, uint64_t *s)
241 {
242 KRML_MAYBE_UNUSED_VAR(a);
243 memset(s, 0U, 25U * sizeof (uint64_t));
244 }
245
246 void
247 Hacl_Hash_SHA3_update_multi_sha3(
248 Spec_Hash_Definitions_hash_alg a,
249 uint64_t *s,
250 uint8_t *blocks,
251 uint32_t n_blocks
252 )
253 {
254 uint32_t l = block_len(a) * n_blocks;
255 for (uint32_t i = 0U; i < l / block_len(a); i++)
256 {
257 uint8_t b[256U] = { 0U };
258 uint8_t *b_ = b;
259 uint8_t *b0 = blocks;
260 uint8_t *bl0 = b_;
261 uint8_t *uu____0 = b0 + i * block_len(a);
262 memcpy(bl0, uu____0, block_len(a) * sizeof (uint8_t));
263 uint32_t unused = block_len(a);
264 KRML_MAYBE_UNUSED_VAR(unused);
265 absorb_inner_32(b_, s);
266 }
267 }
268
269 void
270 Hacl_Hash_SHA3_update_last_sha3(
271 Spec_Hash_Definitions_hash_alg a,
272 uint64_t *s,
273 uint8_t *input,
274 uint32_t input_len
275 )
276 {
277 uint8_t suffix;
278 if (a == Spec_Hash_Definitions_Shake128 || a == Spec_Hash_Definitions_Shake256)
279 {
280 suffix = 0x1fU;
281 }
282 else
283 {
284 suffix = 0x06U;
285 }
286 uint32_t len = block_len(a);
287 if (input_len == len)
288 {
289 uint8_t b1[256U] = { 0U };
290 uint8_t *b_ = b1;
291 uint8_t *b00 = input;
292 uint8_t *bl00 = b_;
293 memcpy(bl00, b00 + 0U * len, len * sizeof (uint8_t));
294 absorb_inner_32(b_, s);
295 uint8_t b2[256U] = { 0U };
296 uint8_t *b_0 = b2;
297 uint32_t rem = 0U % len;
298 uint8_t *b01 = input + input_len;
299 uint8_t *bl0 = b_0;
300 memcpy(bl0, b01 + 0U - rem, rem * sizeof (uint8_t));
301 uint8_t *b02 = b_0;
302 b02[0U % len] = suffix;
303 uint64_t ws[32U] = { 0U };
304 uint8_t *b = b_0;
305 uint64_t u = load64_le(b);
306 ws[0U] = u;
307 uint64_t u0 = load64_le(b + 8U);
308 ws[1U] = u0;
309 uint64_t u1 = load64_le(b + 16U);
310 ws[2U] = u1;
311 uint64_t u2 = load64_le(b + 24U);
312 ws[3U] = u2;
313 uint64_t u3 = load64_le(b + 32U);
314 ws[4U] = u3;
315 uint64_t u4 = load64_le(b + 40U);
316 ws[5U] = u4;
317 uint64_t u5 = load64_le(b + 48U);
318 ws[6U] = u5;
319 uint64_t u6 = load64_le(b + 56U);
320 ws[7U] = u6;
321 uint64_t u7 = load64_le(b + 64U);
322 ws[8U] = u7;
323 uint64_t u8 = load64_le(b + 72U);
324 ws[9U] = u8;
325 uint64_t u9 = load64_le(b + 80U);
326 ws[10U] = u9;
327 uint64_t u10 = load64_le(b + 88U);
328 ws[11U] = u10;
329 uint64_t u11 = load64_le(b + 96U);
330 ws[12U] = u11;
331 uint64_t u12 = load64_le(b + 104U);
332 ws[13U] = u12;
333 uint64_t u13 = load64_le(b + 112U);
334 ws[14U] = u13;
335 uint64_t u14 = load64_le(b + 120U);
336 ws[15U] = u14;
337 uint64_t u15 = load64_le(b + 128U);
338 ws[16U] = u15;
339 uint64_t u16 = load64_le(b + 136U);
340 ws[17U] = u16;
341 uint64_t u17 = load64_le(b + 144U);
342 ws[18U] = u17;
343 uint64_t u18 = load64_le(b + 152U);
344 ws[19U] = u18;
345 uint64_t u19 = load64_le(b + 160U);
346 ws[20U] = u19;
347 uint64_t u20 = load64_le(b + 168U);
348 ws[21U] = u20;
349 uint64_t u21 = load64_le(b + 176U);
350 ws[22U] = u21;
351 uint64_t u22 = load64_le(b + 184U);
352 ws[23U] = u22;
353 uint64_t u23 = load64_le(b + 192U);
354 ws[24U] = u23;
355 uint64_t u24 = load64_le(b + 200U);
356 ws[25U] = u24;
357 uint64_t u25 = load64_le(b + 208U);
358 ws[26U] = u25;
359 uint64_t u26 = load64_le(b + 216U);
360 ws[27U] = u26;
361 uint64_t u27 = load64_le(b + 224U);
362 ws[28U] = u27;
363 uint64_t u28 = load64_le(b + 232U);
364 ws[29U] = u28;
365 uint64_t u29 = load64_le(b + 240U);
366 ws[30U] = u29;
367 uint64_t u30 = load64_le(b + 248U);
368 ws[31U] = u30;
369 for (uint32_t i = 0U; i < 25U; i++)
370 {
371 s[i] = s[i] ^ ws[i];
372 }
373 if (!(((uint32_t)suffix & 0x80U) == 0U) && 0U % len == len - 1U)
374 {
375 for (uint32_t i0 = 0U; i0 < 24U; i0++)
376 {
377 uint64_t _C[5U] = { 0U };
378 KRML_MAYBE_FOR5(i,
379 0U,
380 5U,
381 1U,
382 _C[i] = s[i + 0U] ^ (s[i + 5U] ^ (s[i + 10U] ^ (s[i + 15U] ^ s[i + 20U]))););
383 KRML_MAYBE_FOR5(i1,
384 0U,
385 5U,
386 1U,
387 uint64_t uu____0 = _C[(i1 + 1U) % 5U];
388 uint64_t _D = _C[(i1 + 4U) % 5U] ^ (uu____0 << 1U | uu____0 >> 63U);
389 KRML_MAYBE_FOR5(i, 0U, 5U, 1U, s[i1 + 5U * i] = s[i1 + 5U * i] ^ _D;););
390 uint64_t x = s[1U];
391 uint64_t current = x;
392 for (uint32_t i = 0U; i < 24U; i++)
393 {
394 uint32_t _Y = Hacl_Hash_SHA3_keccak_piln[i];
395 uint32_t r = Hacl_Hash_SHA3_keccak_rotc[i];
396 uint64_t temp = s[_Y];
397 uint64_t uu____1 = current;
398 s[_Y] = uu____1 << r | uu____1 >> (64U - r);
399 current = temp;
400 }
401 KRML_MAYBE_FOR5(i,
402 0U,
403 5U,
404 1U,
405 uint64_t v0 = s[0U + 5U * i] ^ (~s[1U + 5U * i] & s[2U + 5U * i]);
406 uint64_t v1 = s[1U + 5U * i] ^ (~s[2U + 5U * i] & s[3U + 5U * i]);
407 uint64_t v2 = s[2U + 5U * i] ^ (~s[3U + 5U * i] & s[4U + 5U * i]);
408 uint64_t v3 = s[3U + 5U * i] ^ (~s[4U + 5U * i] & s[0U + 5U * i]);
409 uint64_t v4 = s[4U + 5U * i] ^ (~s[0U + 5U * i] & s[1U + 5U * i]);
410 s[0U + 5U * i] = v0;
411 s[1U + 5U * i] = v1;
412 s[2U + 5U * i] = v2;
413 s[3U + 5U * i] = v3;
414 s[4U + 5U * i] = v4;);
415 uint64_t c = Hacl_Hash_SHA3_keccak_rndc[i0];
416 s[0U] = s[0U] ^ c;
417 }
418 }
419 uint8_t b3[256U] = { 0U };
420 uint8_t *b4 = b3;
421 uint8_t *b0 = b4;
422 b0[len - 1U] = 0x80U;
423 absorb_inner_32(b4, s);
424 return;
425 }
426 uint8_t b1[256U] = { 0U };
427 uint8_t *b_ = b1;
428 uint32_t rem = input_len % len;
429 uint8_t *b00 = input;
430 uint8_t *bl0 = b_;
431 memcpy(bl0, b00 + input_len - rem, rem * sizeof (uint8_t));
432 uint8_t *b01 = b_;
433 b01[input_len % len] = suffix;
434 uint64_t ws[32U] = { 0U };
435 uint8_t *b = b_;
436 uint64_t u = load64_le(b);
437 ws[0U] = u;
438 uint64_t u0 = load64_le(b + 8U);
439 ws[1U] = u0;
440 uint64_t u1 = load64_le(b + 16U);
441 ws[2U] = u1;
442 uint64_t u2 = load64_le(b + 24U);
443 ws[3U] = u2;
444 uint64_t u3 = load64_le(b + 32U);
445 ws[4U] = u3;
446 uint64_t u4 = load64_le(b + 40U);
447 ws[5U] = u4;
448 uint64_t u5 = load64_le(b + 48U);
449 ws[6U] = u5;
450 uint64_t u6 = load64_le(b + 56U);
451 ws[7U] = u6;
452 uint64_t u7 = load64_le(b + 64U);
453 ws[8U] = u7;
454 uint64_t u8 = load64_le(b + 72U);
455 ws[9U] = u8;
456 uint64_t u9 = load64_le(b + 80U);
457 ws[10U] = u9;
458 uint64_t u10 = load64_le(b + 88U);
459 ws[11U] = u10;
460 uint64_t u11 = load64_le(b + 96U);
461 ws[12U] = u11;
462 uint64_t u12 = load64_le(b + 104U);
463 ws[13U] = u12;
464 uint64_t u13 = load64_le(b + 112U);
465 ws[14U] = u13;
466 uint64_t u14 = load64_le(b + 120U);
467 ws[15U] = u14;
468 uint64_t u15 = load64_le(b + 128U);
469 ws[16U] = u15;
470 uint64_t u16 = load64_le(b + 136U);
471 ws[17U] = u16;
472 uint64_t u17 = load64_le(b + 144U);
473 ws[18U] = u17;
474 uint64_t u18 = load64_le(b + 152U);
475 ws[19U] = u18;
476 uint64_t u19 = load64_le(b + 160U);
477 ws[20U] = u19;
478 uint64_t u20 = load64_le(b + 168U);
479 ws[21U] = u20;
480 uint64_t u21 = load64_le(b + 176U);
481 ws[22U] = u21;
482 uint64_t u22 = load64_le(b + 184U);
483 ws[23U] = u22;
484 uint64_t u23 = load64_le(b + 192U);
485 ws[24U] = u23;
486 uint64_t u24 = load64_le(b + 200U);
487 ws[25U] = u24;
488 uint64_t u25 = load64_le(b + 208U);
489 ws[26U] = u25;
490 uint64_t u26 = load64_le(b + 216U);
491 ws[27U] = u26;
492 uint64_t u27 = load64_le(b + 224U);
493 ws[28U] = u27;
494 uint64_t u28 = load64_le(b + 232U);
495 ws[29U] = u28;
496 uint64_t u29 = load64_le(b + 240U);
497 ws[30U] = u29;
498 uint64_t u30 = load64_le(b + 248U);
499 ws[31U] = u30;
500 for (uint32_t i = 0U; i < 25U; i++)
501 {
502 s[i] = s[i] ^ ws[i];
503 }
504 if (!(((uint32_t)suffix & 0x80U) == 0U) && input_len % len == len - 1U)
505 {
506 for (uint32_t i0 = 0U; i0 < 24U; i0++)
507 {
508 uint64_t _C[5U] = { 0U };
509 KRML_MAYBE_FOR5(i,
510 0U,
511 5U,
512 1U,
513 _C[i] = s[i + 0U] ^ (s[i + 5U] ^ (s[i + 10U] ^ (s[i + 15U] ^ s[i + 20U]))););
514 KRML_MAYBE_FOR5(i1,
515 0U,
516 5U,
517 1U,
518 uint64_t uu____2 = _C[(i1 + 1U) % 5U];
519 uint64_t _D = _C[(i1 + 4U) % 5U] ^ (uu____2 << 1U | uu____2 >> 63U);
520 KRML_MAYBE_FOR5(i, 0U, 5U, 1U, s[i1 + 5U * i] = s[i1 + 5U * i] ^ _D;););
521 uint64_t x = s[1U];
522 uint64_t current = x;
523 for (uint32_t i = 0U; i < 24U; i++)
524 {
525 uint32_t _Y = Hacl_Hash_SHA3_keccak_piln[i];
526 uint32_t r = Hacl_Hash_SHA3_keccak_rotc[i];
527 uint64_t temp = s[_Y];
528 uint64_t uu____3 = current;
529 s[_Y] = uu____3 << r | uu____3 >> (64U - r);
530 current = temp;
531 }
532 KRML_MAYBE_FOR5(i,
533 0U,
534 5U,
535 1U,
536 uint64_t v0 = s[0U + 5U * i] ^ (~s[1U + 5U * i] & s[2U + 5U * i]);
537 uint64_t v1 = s[1U + 5U * i] ^ (~s[2U + 5U * i] & s[3U + 5U * i]);
538 uint64_t v2 = s[2U + 5U * i] ^ (~s[3U + 5U * i] & s[4U + 5U * i]);
539 uint64_t v3 = s[3U + 5U * i] ^ (~s[4U + 5U * i] & s[0U + 5U * i]);
540 uint64_t v4 = s[4U + 5U * i] ^ (~s[0U + 5U * i] & s[1U + 5U * i]);
541 s[0U + 5U * i] = v0;
542 s[1U + 5U * i] = v1;
543 s[2U + 5U * i] = v2;
544 s[3U + 5U * i] = v3;
545 s[4U + 5U * i] = v4;);
546 uint64_t c = Hacl_Hash_SHA3_keccak_rndc[i0];
547 s[0U] = s[0U] ^ c;
548 }
549 }
550 uint8_t b2[256U] = { 0U };
551 uint8_t *b3 = b2;
552 uint8_t *b0 = b3;
553 b0[len - 1U] = 0x80U;
554 absorb_inner_32(b3, s);
555 }
556
557 static void squeeze(uint64_t *s, uint32_t rateInBytes, uint32_t outputByteLen, uint8_t *b)
558 {
559 for (uint32_t i0 = 0U; i0 < outputByteLen / rateInBytes; i0++)
560 {
561 uint8_t hbuf[256U] = { 0U };
562 uint64_t ws[32U] = { 0U };
563 memcpy(ws, s, 25U * sizeof (uint64_t));
564 for (uint32_t i = 0U; i < 32U; i++)
565 {
566 store64_le(hbuf + i * 8U, ws[i]);
567 }
568 uint8_t *b0 = b;
569 memcpy(b0 + i0 * rateInBytes, hbuf, rateInBytes * sizeof (uint8_t));
570 for (uint32_t i1 = 0U; i1 < 24U; i1++)
571 {
572 uint64_t _C[5U] = { 0U };
573 KRML_MAYBE_FOR5(i,
574 0U,
575 5U,
576 1U,
577 _C[i] = s[i + 0U] ^ (s[i + 5U] ^ (s[i + 10U] ^ (s[i + 15U] ^ s[i + 20U]))););
578 KRML_MAYBE_FOR5(i2,
579 0U,
580 5U,
581 1U,
582 uint64_t uu____0 = _C[(i2 + 1U) % 5U];
583 uint64_t _D = _C[(i2 + 4U) % 5U] ^ (uu____0 << 1U | uu____0 >> 63U);
584 KRML_MAYBE_FOR5(i, 0U, 5U, 1U, s[i2 + 5U * i] = s[i2 + 5U * i] ^ _D;););
585 uint64_t x = s[1U];
586 uint64_t current = x;
587 for (uint32_t i = 0U; i < 24U; i++)
588 {
589 uint32_t _Y = Hacl_Hash_SHA3_keccak_piln[i];
590 uint32_t r = Hacl_Hash_SHA3_keccak_rotc[i];
591 uint64_t temp = s[_Y];
592 uint64_t uu____1 = current;
593 s[_Y] = uu____1 << r | uu____1 >> (64U - r);
594 current = temp;
595 }
596 KRML_MAYBE_FOR5(i,
597 0U,
598 5U,
599 1U,
600 uint64_t v0 = s[0U + 5U * i] ^ (~s[1U + 5U * i] & s[2U + 5U * i]);
601 uint64_t v1 = s[1U + 5U * i] ^ (~s[2U + 5U * i] & s[3U + 5U * i]);
602 uint64_t v2 = s[2U + 5U * i] ^ (~s[3U + 5U * i] & s[4U + 5U * i]);
603 uint64_t v3 = s[3U + 5U * i] ^ (~s[4U + 5U * i] & s[0U + 5U * i]);
604 uint64_t v4 = s[4U + 5U * i] ^ (~s[0U + 5U * i] & s[1U + 5U * i]);
605 s[0U + 5U * i] = v0;
606 s[1U + 5U * i] = v1;
607 s[2U + 5U * i] = v2;
608 s[3U + 5U * i] = v3;
609 s[4U + 5U * i] = v4;);
610 uint64_t c = Hacl_Hash_SHA3_keccak_rndc[i1];
611 s[0U] = s[0U] ^ c;
612 }
613 }
614 uint32_t remOut = outputByteLen % rateInBytes;
615 uint8_t hbuf[256U] = { 0U };
616 uint64_t ws[32U] = { 0U };
617 memcpy(ws, s, 25U * sizeof (uint64_t));
618 for (uint32_t i = 0U; i < 32U; i++)
619 {
620 store64_le(hbuf + i * 8U, ws[i]);
621 }
622 memcpy(b + outputByteLen - remOut, hbuf, remOut * sizeof (uint8_t));
623 }
624
625 typedef struct hash_buf2_s
626 {
627 Hacl_Hash_SHA3_hash_buf fst;
628 Hacl_Hash_SHA3_hash_buf snd;
629 }
630 hash_buf2;
631
632 Spec_Hash_Definitions_hash_alg Hacl_Hash_SHA3_get_alg(Hacl_Hash_SHA3_state_t *s)
633 {
634 Hacl_Hash_SHA3_hash_buf block_state = (*s).block_state;
635 return block_state.fst;
636 }
637
638 typedef struct option___Spec_Hash_Definitions_hash_alg____uint64_t___s
639 {
640 Hacl_Streaming_Types_optional tag;
641 Hacl_Hash_SHA3_hash_buf v;
642 }
643 option___Spec_Hash_Definitions_hash_alg____uint64_t__;
644
645 Hacl_Hash_SHA3_state_t *Hacl_Hash_SHA3_malloc(Spec_Hash_Definitions_hash_alg a)
646 {
647 KRML_CHECK_SIZE(sizeof (uint8_t), block_len(a));
648 uint8_t *buf = (uint8_t *)KRML_HOST_CALLOC(block_len(a), sizeof (uint8_t));
649 if (buf == NULL)
650 {
651 return NULL;
652 }
653 uint8_t *buf1 = buf;
654 uint64_t *s = (uint64_t *)KRML_HOST_CALLOC(25U, sizeof (uint64_t));
655 option___Spec_Hash_Definitions_hash_alg____uint64_t__ block_state;
656 if (s == NULL)
657 {
658 block_state =
659 ((option___Spec_Hash_Definitions_hash_alg____uint64_t__){ .tag = Hacl_Streaming_Types_None });
660 }
661 else
662 {
663 block_state =
664 (
665 (option___Spec_Hash_Definitions_hash_alg____uint64_t__){
666 .tag = Hacl_Streaming_Types_Some,
667 .v = { .fst = a, .snd = s }
668 }
669 );
670 }
671 if (block_state.tag == Hacl_Streaming_Types_None)
672 {
673 KRML_HOST_FREE(buf1);
674 return NULL;
675 }
676 if (block_state.tag == Hacl_Streaming_Types_Some)
677 {
678 Hacl_Hash_SHA3_hash_buf block_state1 = block_state.v;
679 Hacl_Streaming_Types_optional k_ = Hacl_Streaming_Types_Some;
680 switch (k_)
681 {
682 case Hacl_Streaming_Types_None:
683 {
684 return NULL;
685 }
686 case Hacl_Streaming_Types_Some:
687 {
688 Hacl_Hash_SHA3_state_t
689 s0 = { .block_state = block_state1, .buf = buf1, .total_len = (uint64_t)0U };
690 Hacl_Hash_SHA3_state_t
691 *p = (Hacl_Hash_SHA3_state_t *)KRML_HOST_MALLOC(sizeof (Hacl_Hash_SHA3_state_t));
692 if (p != NULL)
693 {
694 p[0U] = s0;
695 }
696 if (p == NULL)
697 {
698 uint64_t *s1 = block_state1.snd;
699 KRML_HOST_FREE(s1);
700 KRML_HOST_FREE(buf1);
701 return NULL;
702 }
703 Spec_Hash_Definitions_hash_alg a1 = block_state1.fst;
704 uint64_t *s1 = block_state1.snd;
705 Hacl_Hash_SHA3_init_(a1, s1);
706 return p;
707 }
708 default:
709 {
710 KRML_HOST_EPRINTF("KaRaMeL incomplete match at %s:%d\n", __FILE__, __LINE__);
711 KRML_HOST_EXIT(253U);
712 }
713 }
714 }
715 KRML_HOST_EPRINTF("KaRaMeL abort at %s:%d\n%s\n",
716 __FILE__,
717 __LINE__,
718 "unreachable (pattern matches are exhaustive in F*)");
719 KRML_HOST_EXIT(255U);
720 }
721
722 void Hacl_Hash_SHA3_free(Hacl_Hash_SHA3_state_t *state)
723 {
724 Hacl_Hash_SHA3_state_t scrut = *state;
725 uint8_t *buf = scrut.buf;
726 Hacl_Hash_SHA3_hash_buf block_state = scrut.block_state;
727 uint64_t *s = block_state.snd;
728 KRML_HOST_FREE(s);
729 KRML_HOST_FREE(buf);
730 KRML_HOST_FREE(state);
731 }
732
733 Hacl_Hash_SHA3_state_t *Hacl_Hash_SHA3_copy(Hacl_Hash_SHA3_state_t *state)
734 {
735 Hacl_Hash_SHA3_state_t scrut0 = *state;
736 Hacl_Hash_SHA3_hash_buf block_state0 = scrut0.block_state;
737 uint8_t *buf0 = scrut0.buf;
738 uint64_t total_len0 = scrut0.total_len;
739 Spec_Hash_Definitions_hash_alg i = block_state0.fst;
740 KRML_CHECK_SIZE(sizeof (uint8_t), block_len(i));
741 uint8_t *buf = (uint8_t *)KRML_HOST_CALLOC(block_len(i), sizeof (uint8_t));
742 if (buf == NULL)
743 {
744 return NULL;
745 }
746 memcpy(buf, buf0, block_len(i) * sizeof (uint8_t));
747 uint64_t *s = (uint64_t *)KRML_HOST_CALLOC(25U, sizeof (uint64_t));
748 option___Spec_Hash_Definitions_hash_alg____uint64_t__ block_state;
749 if (s == NULL)
750 {
751 block_state =
752 ((option___Spec_Hash_Definitions_hash_alg____uint64_t__){ .tag = Hacl_Streaming_Types_None });
753 }
754 else
755 {
756 block_state =
757 (
758 (option___Spec_Hash_Definitions_hash_alg____uint64_t__){
759 .tag = Hacl_Streaming_Types_Some,
760 .v = { .fst = i, .snd = s }
761 }
762 );
763 }
764 if (block_state.tag == Hacl_Streaming_Types_None)
765 {
766 KRML_HOST_FREE(buf);
767 return NULL;
768 }
769 if (block_state.tag == Hacl_Streaming_Types_Some)
770 {
771 Hacl_Hash_SHA3_hash_buf block_state1 = block_state.v;
772 hash_buf2 scrut = { .fst = block_state0, .snd = block_state1 };
773 uint64_t *s_dst = scrut.snd.snd;
774 uint64_t *s_src = scrut.fst.snd;
775 memcpy(s_dst, s_src, 25U * sizeof (uint64_t));
776 Hacl_Streaming_Types_optional k_ = Hacl_Streaming_Types_Some;
777 switch (k_)
778 {
779 case Hacl_Streaming_Types_None:
780 {
781 return NULL;
782 }
783 case Hacl_Streaming_Types_Some:
784 {
785 Hacl_Hash_SHA3_state_t
786 s0 = { .block_state = block_state1, .buf = buf, .total_len = total_len0 };
787 Hacl_Hash_SHA3_state_t
788 *p = (Hacl_Hash_SHA3_state_t *)KRML_HOST_MALLOC(sizeof (Hacl_Hash_SHA3_state_t));
789 if (p != NULL)
790 {
791 p[0U] = s0;
792 }
793 if (p == NULL)
794 {
795 uint64_t *s1 = block_state1.snd;
796 KRML_HOST_FREE(s1);
797 KRML_HOST_FREE(buf);
798 return NULL;
799 }
800 return p;
801 }
802 default:
803 {
804 KRML_HOST_EPRINTF("KaRaMeL incomplete match at %s:%d\n", __FILE__, __LINE__);
805 KRML_HOST_EXIT(253U);
806 }
807 }
808 }
809 KRML_HOST_EPRINTF("KaRaMeL abort at %s:%d\n%s\n",
810 __FILE__,
811 __LINE__,
812 "unreachable (pattern matches are exhaustive in F*)");
813 KRML_HOST_EXIT(255U);
814 }
815
816 void Hacl_Hash_SHA3_reset(Hacl_Hash_SHA3_state_t *state)
817 {
818 Hacl_Hash_SHA3_state_t scrut = *state;
819 uint8_t *buf = scrut.buf;
820 Hacl_Hash_SHA3_hash_buf block_state = scrut.block_state;
821 Spec_Hash_Definitions_hash_alg i = block_state.fst;
822 KRML_MAYBE_UNUSED_VAR(i);
823 Spec_Hash_Definitions_hash_alg a1 = block_state.fst;
824 uint64_t *s = block_state.snd;
825 Hacl_Hash_SHA3_init_(a1, s);
826 Hacl_Hash_SHA3_state_t
827 tmp = { .block_state = block_state, .buf = buf, .total_len = (uint64_t)0U };
828 state[0U] = tmp;
829 }
830
831 Hacl_Streaming_Types_error_code
832 Hacl_Hash_SHA3_update(Hacl_Hash_SHA3_state_t *state, uint8_t *chunk, uint32_t chunk_len)
833 {
834 Hacl_Hash_SHA3_state_t s = *state;
835 Hacl_Hash_SHA3_hash_buf block_state = s.block_state;
836 uint64_t total_len = s.total_len;
837 Spec_Hash_Definitions_hash_alg i = block_state.fst;
838 if ((uint64_t)chunk_len > 0xFFFFFFFFFFFFFFFFULL - total_len)
839 {
840 return Hacl_Streaming_Types_MaximumLengthExceeded;
841 }
842 uint32_t sz;
843 if (total_len % (uint64_t)block_len(i) == 0ULL && total_len > 0ULL)
844 {
845 sz = block_len(i);
846 }
847 else
848 {
849 sz = (uint32_t)(total_len % (uint64_t)block_len(i));
850 }
851 if (chunk_len <= block_len(i) - sz)
852 {
853 Hacl_Hash_SHA3_state_t s1 = *state;
854 Hacl_Hash_SHA3_hash_buf block_state1 = s1.block_state;
855 uint8_t *buf = s1.buf;
856 uint64_t total_len1 = s1.total_len;
857 uint32_t sz1;
858 if (total_len1 % (uint64_t)block_len(i) == 0ULL && total_len1 > 0ULL)
859 {
860 sz1 = block_len(i);
861 }
862 else
863 {
864 sz1 = (uint32_t)(total_len1 % (uint64_t)block_len(i));
865 }
866 uint8_t *buf2 = buf + sz1;
867 memcpy(buf2, chunk, chunk_len * sizeof (uint8_t));
868 uint64_t total_len2 = total_len1 + (uint64_t)chunk_len;
869 *state =
870 ((Hacl_Hash_SHA3_state_t){ .block_state = block_state1, .buf = buf, .total_len = total_len2 });
871 }
872 else if (sz == 0U)
873 {
874 Hacl_Hash_SHA3_state_t s1 = *state;
875 Hacl_Hash_SHA3_hash_buf block_state1 = s1.block_state;
876 uint8_t *buf = s1.buf;
877 uint64_t total_len1 = s1.total_len;
878 uint32_t sz1;
879 if (total_len1 % (uint64_t)block_len(i) == 0ULL && total_len1 > 0ULL)
880 {
881 sz1 = block_len(i);
882 }
883 else
884 {
885 sz1 = (uint32_t)(total_len1 % (uint64_t)block_len(i));
886 }
887 if (!(sz1 == 0U))
888 {
889 Spec_Hash_Definitions_hash_alg a1 = block_state1.fst;
890 uint64_t *s2 = block_state1.snd;
891 Hacl_Hash_SHA3_update_multi_sha3(a1, s2, buf, block_len(i) / block_len(a1));
892 }
893 uint32_t ite;
894 if ((uint64_t)chunk_len % (uint64_t)block_len(i) == 0ULL && (uint64_t)chunk_len > 0ULL)
895 {
896 ite = block_len(i);
897 }
898 else
899 {
900 ite = (uint32_t)((uint64_t)chunk_len % (uint64_t)block_len(i));
901 }
902 uint32_t n_blocks = (chunk_len - ite) / block_len(i);
903 uint32_t data1_len = n_blocks * block_len(i);
904 uint32_t data2_len = chunk_len - data1_len;
905 uint8_t *data1 = chunk;
906 uint8_t *data2 = chunk + data1_len;
907 Spec_Hash_Definitions_hash_alg a1 = block_state1.fst;
908 uint64_t *s2 = block_state1.snd;
909 Hacl_Hash_SHA3_update_multi_sha3(a1, s2, data1, data1_len / block_len(a1));
910 uint8_t *dst = buf;
911 memcpy(dst, data2, data2_len * sizeof (uint8_t));
912 *state =
913 (
914 (Hacl_Hash_SHA3_state_t){
915 .block_state = block_state1,
916 .buf = buf,
917 .total_len = total_len1 + (uint64_t)chunk_len
918 }
919 );
920 }
921 else
922 {
923 uint32_t diff = block_len(i) - sz;
924 uint8_t *chunk1 = chunk;
925 uint8_t *chunk2 = chunk + diff;
926 Hacl_Hash_SHA3_state_t s1 = *state;
927 Hacl_Hash_SHA3_hash_buf block_state10 = s1.block_state;
928 uint8_t *buf0 = s1.buf;
929 uint64_t total_len10 = s1.total_len;
930 uint32_t sz10;
931 if (total_len10 % (uint64_t)block_len(i) == 0ULL && total_len10 > 0ULL)
932 {
933 sz10 = block_len(i);
934 }
935 else
936 {
937 sz10 = (uint32_t)(total_len10 % (uint64_t)block_len(i));
938 }
939 uint8_t *buf2 = buf0 + sz10;
940 memcpy(buf2, chunk1, diff * sizeof (uint8_t));
941 uint64_t total_len2 = total_len10 + (uint64_t)diff;
942 *state =
943 (
944 (Hacl_Hash_SHA3_state_t){
945 .block_state = block_state10,
946 .buf = buf0,
947 .total_len = total_len2
948 }
949 );
950 Hacl_Hash_SHA3_state_t s10 = *state;
951 Hacl_Hash_SHA3_hash_buf block_state1 = s10.block_state;
952 uint8_t *buf = s10.buf;
953 uint64_t total_len1 = s10.total_len;
954 uint32_t sz1;
955 if (total_len1 % (uint64_t)block_len(i) == 0ULL && total_len1 > 0ULL)
956 {
957 sz1 = block_len(i);
958 }
959 else
960 {
961 sz1 = (uint32_t)(total_len1 % (uint64_t)block_len(i));
962 }
963 if (!(sz1 == 0U))
964 {
965 Spec_Hash_Definitions_hash_alg a1 = block_state1.fst;
966 uint64_t *s2 = block_state1.snd;
967 Hacl_Hash_SHA3_update_multi_sha3(a1, s2, buf, block_len(i) / block_len(a1));
968 }
969 uint32_t ite;
970 if
971 (
972 (uint64_t)(chunk_len - diff) % (uint64_t)block_len(i) == 0ULL &&
973 (uint64_t)(chunk_len - diff) > 0ULL
974 )
975 {
976 ite = block_len(i);
977 }
978 else
979 {
980 ite = (uint32_t)((uint64_t)(chunk_len - diff) % (uint64_t)block_len(i));
981 }
982 uint32_t n_blocks = (chunk_len - diff - ite) / block_len(i);
983 uint32_t data1_len = n_blocks * block_len(i);
984 uint32_t data2_len = chunk_len - diff - data1_len;
985 uint8_t *data1 = chunk2;
986 uint8_t *data2 = chunk2 + data1_len;
987 Spec_Hash_Definitions_hash_alg a1 = block_state1.fst;
988 uint64_t *s2 = block_state1.snd;
989 Hacl_Hash_SHA3_update_multi_sha3(a1, s2, data1, data1_len / block_len(a1));
990 uint8_t *dst = buf;
991 memcpy(dst, data2, data2_len * sizeof (uint8_t));
992 *state =
993 (
994 (Hacl_Hash_SHA3_state_t){
995 .block_state = block_state1,
996 .buf = buf,
997 .total_len = total_len1 + (uint64_t)(chunk_len - diff)
998 }
999 );
1000 }
1001 return Hacl_Streaming_Types_Success;
1002 }
1003
1004 static void
1005 digest_(
1006 Spec_Hash_Definitions_hash_alg a,
1007 Hacl_Hash_SHA3_state_t *state,
1008 uint8_t *output,
1009 uint32_t l
1010 )
1011 {
1012 Hacl_Hash_SHA3_state_t scrut0 = *state;
1013 Hacl_Hash_SHA3_hash_buf block_state = scrut0.block_state;
1014 uint8_t *buf_ = scrut0.buf;
1015 uint64_t total_len = scrut0.total_len;
1016 uint32_t r;
1017 if (total_len % (uint64_t)block_len(a) == 0ULL && total_len > 0ULL)
1018 {
1019 r = block_len(a);
1020 }
1021 else
1022 {
1023 r = (uint32_t)(total_len % (uint64_t)block_len(a));
1024 }
1025 uint8_t *buf_1 = buf_;
1026 uint64_t buf[25U] = { 0U };
1027 Hacl_Hash_SHA3_hash_buf tmp_block_state = { .fst = a, .snd = buf };
1028 hash_buf2 scrut = { .fst = block_state, .snd = tmp_block_state };
1029 uint64_t *s_dst = scrut.snd.snd;
1030 uint64_t *s_src = scrut.fst.snd;
1031 memcpy(s_dst, s_src, 25U * sizeof (uint64_t));
1032 uint32_t ite;
1033 if (r % block_len(a) == 0U && r > 0U)
1034 {
1035 ite = block_len(a);
1036 }
1037 else
1038 {
1039 ite = r % block_len(a);
1040 }
1041 uint8_t *buf_last = buf_1 + r - ite;
1042 uint8_t *buf_multi = buf_1;
1043 Spec_Hash_Definitions_hash_alg a1 = tmp_block_state.fst;
1044 uint64_t *s0 = tmp_block_state.snd;
1045 Hacl_Hash_SHA3_update_multi_sha3(a1, s0, buf_multi, 0U / block_len(a1));
1046 Spec_Hash_Definitions_hash_alg a10 = tmp_block_state.fst;
1047 uint64_t *s1 = tmp_block_state.snd;
1048 Hacl_Hash_SHA3_update_last_sha3(a10, s1, buf_last, r);
1049 Spec_Hash_Definitions_hash_alg a11 = tmp_block_state.fst;
1050 uint64_t *s = tmp_block_state.snd;
1051 bool sw;
1052 switch (a11)
1053 {
1054 case Spec_Hash_Definitions_Shake128:
1055 {
1056 sw = true;
1057 break;
1058 }
1059 case Spec_Hash_Definitions_Shake256:
1060 {
1061 sw = true;
1062 break;
1063 }
1064 default:
1065 {
1066 sw = false;
1067 }
1068 }
1069 if (sw)
1070 {
1071 squeeze(s, block_len(a11), l, output);
1072 return;
1073 }
1074 squeeze(s, block_len(a11), hash_len(a11), output);
1075 }
1076
1077 Hacl_Streaming_Types_error_code
1078 Hacl_Hash_SHA3_digest(Hacl_Hash_SHA3_state_t *state, uint8_t *output)
1079 {
1080 Spec_Hash_Definitions_hash_alg a1 = Hacl_Hash_SHA3_get_alg(state);
1081 if (a1 == Spec_Hash_Definitions_Shake128 || a1 == Spec_Hash_Definitions_Shake256)
1082 {
1083 return Hacl_Streaming_Types_InvalidAlgorithm;
1084 }
1085 digest_(a1, state, output, hash_len(a1));
1086 return Hacl_Streaming_Types_Success;
1087 }
1088
1089 Hacl_Streaming_Types_error_code
1090 Hacl_Hash_SHA3_squeeze(Hacl_Hash_SHA3_state_t *s, uint8_t *dst, uint32_t l)
1091 {
1092 Spec_Hash_Definitions_hash_alg a1 = Hacl_Hash_SHA3_get_alg(s);
1093 if (!(a1 == Spec_Hash_Definitions_Shake128 || a1 == Spec_Hash_Definitions_Shake256))
1094 {
1095 return Hacl_Streaming_Types_InvalidAlgorithm;
1096 }
1097 if (l == 0U)
1098 {
1099 return Hacl_Streaming_Types_InvalidLength;
1100 }
1101 digest_(a1, s, dst, l);
1102 return Hacl_Streaming_Types_Success;
1103 }
1104
1105 uint32_t Hacl_Hash_SHA3_block_len(Hacl_Hash_SHA3_state_t *s)
1106 {
1107 Spec_Hash_Definitions_hash_alg a1 = Hacl_Hash_SHA3_get_alg(s);
1108 return block_len(a1);
1109 }
1110
1111 uint32_t Hacl_Hash_SHA3_hash_len(Hacl_Hash_SHA3_state_t *s)
1112 {
1113 Spec_Hash_Definitions_hash_alg a1 = Hacl_Hash_SHA3_get_alg(s);
1114 return hash_len(a1);
1115 }
1116
1117 bool Hacl_Hash_SHA3_is_shake(Hacl_Hash_SHA3_state_t *s)
1118 {
1119 Spec_Hash_Definitions_hash_alg uu____0 = Hacl_Hash_SHA3_get_alg(s);
1120 return uu____0 == Spec_Hash_Definitions_Shake128 || uu____0 == Spec_Hash_Definitions_Shake256;
1121 }
1122
1123 void Hacl_Hash_SHA3_absorb_inner_32(uint32_t rateInBytes, uint8_t *b, uint64_t *s)
1124 {
1125 KRML_MAYBE_UNUSED_VAR(rateInBytes);
1126 uint64_t ws[32U] = { 0U };
1127 uint8_t *b1 = b;
1128 uint64_t u = load64_le(b1);
1129 ws[0U] = u;
1130 uint64_t u0 = load64_le(b1 + 8U);
1131 ws[1U] = u0;
1132 uint64_t u1 = load64_le(b1 + 16U);
1133 ws[2U] = u1;
1134 uint64_t u2 = load64_le(b1 + 24U);
1135 ws[3U] = u2;
1136 uint64_t u3 = load64_le(b1 + 32U);
1137 ws[4U] = u3;
1138 uint64_t u4 = load64_le(b1 + 40U);
1139 ws[5U] = u4;
1140 uint64_t u5 = load64_le(b1 + 48U);
1141 ws[6U] = u5;
1142 uint64_t u6 = load64_le(b1 + 56U);
1143 ws[7U] = u6;
1144 uint64_t u7 = load64_le(b1 + 64U);
1145 ws[8U] = u7;
1146 uint64_t u8 = load64_le(b1 + 72U);
1147 ws[9U] = u8;
1148 uint64_t u9 = load64_le(b1 + 80U);
1149 ws[10U] = u9;
1150 uint64_t u10 = load64_le(b1 + 88U);
1151 ws[11U] = u10;
1152 uint64_t u11 = load64_le(b1 + 96U);
1153 ws[12U] = u11;
1154 uint64_t u12 = load64_le(b1 + 104U);
1155 ws[13U] = u12;
1156 uint64_t u13 = load64_le(b1 + 112U);
1157 ws[14U] = u13;
1158 uint64_t u14 = load64_le(b1 + 120U);
1159 ws[15U] = u14;
1160 uint64_t u15 = load64_le(b1 + 128U);
1161 ws[16U] = u15;
1162 uint64_t u16 = load64_le(b1 + 136U);
1163 ws[17U] = u16;
1164 uint64_t u17 = load64_le(b1 + 144U);
1165 ws[18U] = u17;
1166 uint64_t u18 = load64_le(b1 + 152U);
1167 ws[19U] = u18;
1168 uint64_t u19 = load64_le(b1 + 160U);
1169 ws[20U] = u19;
1170 uint64_t u20 = load64_le(b1 + 168U);
1171 ws[21U] = u20;
1172 uint64_t u21 = load64_le(b1 + 176U);
1173 ws[22U] = u21;
1174 uint64_t u22 = load64_le(b1 + 184U);
1175 ws[23U] = u22;
1176 uint64_t u23 = load64_le(b1 + 192U);
1177 ws[24U] = u23;
1178 uint64_t u24 = load64_le(b1 + 200U);
1179 ws[25U] = u24;
1180 uint64_t u25 = load64_le(b1 + 208U);
1181 ws[26U] = u25;
1182 uint64_t u26 = load64_le(b1 + 216U);
1183 ws[27U] = u26;
1184 uint64_t u27 = load64_le(b1 + 224U);
1185 ws[28U] = u27;
1186 uint64_t u28 = load64_le(b1 + 232U);
1187 ws[29U] = u28;
1188 uint64_t u29 = load64_le(b1 + 240U);
1189 ws[30U] = u29;
1190 uint64_t u30 = load64_le(b1 + 248U);
1191 ws[31U] = u30;
1192 for (uint32_t i = 0U; i < 25U; i++)
1193 {
1194 s[i] = s[i] ^ ws[i];
1195 }
1196 for (uint32_t i0 = 0U; i0 < 24U; i0++)
1197 {
1198 uint64_t _C[5U] = { 0U };
1199 KRML_MAYBE_FOR5(i,
1200 0U,
1201 5U,
1202 1U,
1203 _C[i] = s[i + 0U] ^ (s[i + 5U] ^ (s[i + 10U] ^ (s[i + 15U] ^ s[i + 20U]))););
1204 KRML_MAYBE_FOR5(i1,
1205 0U,
1206 5U,
1207 1U,
1208 uint64_t uu____0 = _C[(i1 + 1U) % 5U];
1209 uint64_t _D = _C[(i1 + 4U) % 5U] ^ (uu____0 << 1U | uu____0 >> 63U);
1210 KRML_MAYBE_FOR5(i, 0U, 5U, 1U, s[i1 + 5U * i] = s[i1 + 5U * i] ^ _D;););
1211 uint64_t x = s[1U];
1212 uint64_t current = x;
1213 for (uint32_t i = 0U; i < 24U; i++)
1214 {
1215 uint32_t _Y = Hacl_Hash_SHA3_keccak_piln[i];
1216 uint32_t r = Hacl_Hash_SHA3_keccak_rotc[i];
1217 uint64_t temp = s[_Y];
1218 uint64_t uu____1 = current;
1219 s[_Y] = uu____1 << r | uu____1 >> (64U - r);
1220 current = temp;
1221 }
1222 KRML_MAYBE_FOR5(i,
1223 0U,
1224 5U,
1225 1U,
1226 uint64_t v0 = s[0U + 5U * i] ^ (~s[1U + 5U * i] & s[2U + 5U * i]);
1227 uint64_t v1 = s[1U + 5U * i] ^ (~s[2U + 5U * i] & s[3U + 5U * i]);
1228 uint64_t v2 = s[2U + 5U * i] ^ (~s[3U + 5U * i] & s[4U + 5U * i]);
1229 uint64_t v3 = s[3U + 5U * i] ^ (~s[4U + 5U * i] & s[0U + 5U * i]);
1230 uint64_t v4 = s[4U + 5U * i] ^ (~s[0U + 5U * i] & s[1U + 5U * i]);
1231 s[0U + 5U * i] = v0;
1232 s[1U + 5U * i] = v1;
1233 s[2U + 5U * i] = v2;
1234 s[3U + 5U * i] = v3;
1235 s[4U + 5U * i] = v4;);
1236 uint64_t c = Hacl_Hash_SHA3_keccak_rndc[i0];
1237 s[0U] = s[0U] ^ c;
1238 }
1239 }
1240
1241 void
1242 Hacl_Hash_SHA3_shake128(
1243 uint8_t *output,
1244 uint32_t outputByteLen,
1245 uint8_t *input,
1246 uint32_t inputByteLen
1247 )
1248 {
1249 uint8_t *ib = input;
1250 uint8_t *rb = output;
1251 uint64_t s[25U] = { 0U };
1252 uint32_t rateInBytes1 = 168U;
1253 for (uint32_t i = 0U; i < inputByteLen / rateInBytes1; i++)
1254 {
1255 uint8_t b[256U] = { 0U };
1256 uint8_t *b_ = b;
1257 uint8_t *b0 = ib;
1258 uint8_t *bl0 = b_;
1259 memcpy(bl0, b0 + i * rateInBytes1, rateInBytes1 * sizeof (uint8_t));
1260 Hacl_Hash_SHA3_absorb_inner_32(rateInBytes1, b_, s);
1261 }
1262 uint8_t b1[256U] = { 0U };
1263 uint8_t *b_ = b1;
1264 uint32_t rem = inputByteLen % rateInBytes1;
1265 uint8_t *b00 = ib;
1266 uint8_t *bl0 = b_;
1267 memcpy(bl0, b00 + inputByteLen - rem, rem * sizeof (uint8_t));
1268 uint8_t *b01 = b_;
1269 b01[inputByteLen % rateInBytes1] = 0x1FU;
1270 uint64_t ws0[32U] = { 0U };
1271 uint8_t *b = b_;
1272 uint64_t u = load64_le(b);
1273 ws0[0U] = u;
1274 uint64_t u0 = load64_le(b + 8U);
1275 ws0[1U] = u0;
1276 uint64_t u1 = load64_le(b + 16U);
1277 ws0[2U] = u1;
1278 uint64_t u2 = load64_le(b + 24U);
1279 ws0[3U] = u2;
1280 uint64_t u3 = load64_le(b + 32U);
1281 ws0[4U] = u3;
1282 uint64_t u4 = load64_le(b + 40U);
1283 ws0[5U] = u4;
1284 uint64_t u5 = load64_le(b + 48U);
1285 ws0[6U] = u5;
1286 uint64_t u6 = load64_le(b + 56U);
1287 ws0[7U] = u6;
1288 uint64_t u7 = load64_le(b + 64U);
1289 ws0[8U] = u7;
1290 uint64_t u8 = load64_le(b + 72U);
1291 ws0[9U] = u8;
1292 uint64_t u9 = load64_le(b + 80U);
1293 ws0[10U] = u9;
1294 uint64_t u10 = load64_le(b + 88U);
1295 ws0[11U] = u10;
1296 uint64_t u11 = load64_le(b + 96U);
1297 ws0[12U] = u11;
1298 uint64_t u12 = load64_le(b + 104U);
1299 ws0[13U] = u12;
1300 uint64_t u13 = load64_le(b + 112U);
1301 ws0[14U] = u13;
1302 uint64_t u14 = load64_le(b + 120U);
1303 ws0[15U] = u14;
1304 uint64_t u15 = load64_le(b + 128U);
1305 ws0[16U] = u15;
1306 uint64_t u16 = load64_le(b + 136U);
1307 ws0[17U] = u16;
1308 uint64_t u17 = load64_le(b + 144U);
1309 ws0[18U] = u17;
1310 uint64_t u18 = load64_le(b + 152U);
1311 ws0[19U] = u18;
1312 uint64_t u19 = load64_le(b + 160U);
1313 ws0[20U] = u19;
1314 uint64_t u20 = load64_le(b + 168U);
1315 ws0[21U] = u20;
1316 uint64_t u21 = load64_le(b + 176U);
1317 ws0[22U] = u21;
1318 uint64_t u22 = load64_le(b + 184U);
1319 ws0[23U] = u22;
1320 uint64_t u23 = load64_le(b + 192U);
1321 ws0[24U] = u23;
1322 uint64_t u24 = load64_le(b + 200U);
1323 ws0[25U] = u24;
1324 uint64_t u25 = load64_le(b + 208U);
1325 ws0[26U] = u25;
1326 uint64_t u26 = load64_le(b + 216U);
1327 ws0[27U] = u26;
1328 uint64_t u27 = load64_le(b + 224U);
1329 ws0[28U] = u27;
1330 uint64_t u28 = load64_le(b + 232U);
1331 ws0[29U] = u28;
1332 uint64_t u29 = load64_le(b + 240U);
1333 ws0[30U] = u29;
1334 uint64_t u30 = load64_le(b + 248U);
1335 ws0[31U] = u30;
1336 for (uint32_t i = 0U; i < 25U; i++)
1337 {
1338 s[i] = s[i] ^ ws0[i];
1339 }
1340 uint8_t b2[256U] = { 0U };
1341 uint8_t *b3 = b2;
1342 uint8_t *b0 = b3;
1343 b0[rateInBytes1 - 1U] = 0x80U;
1344 Hacl_Hash_SHA3_absorb_inner_32(rateInBytes1, b3, s);
1345 for (uint32_t i0 = 0U; i0 < outputByteLen / rateInBytes1; i0++)
1346 {
1347 uint8_t hbuf[256U] = { 0U };
1348 uint64_t ws[32U] = { 0U };
1349 memcpy(ws, s, 25U * sizeof (uint64_t));
1350 for (uint32_t i = 0U; i < 32U; i++)
1351 {
1352 store64_le(hbuf + i * 8U, ws[i]);
1353 }
1354 uint8_t *b02 = rb;
1355 memcpy(b02 + i0 * rateInBytes1, hbuf, rateInBytes1 * sizeof (uint8_t));
1356 for (uint32_t i1 = 0U; i1 < 24U; i1++)
1357 {
1358 uint64_t _C[5U] = { 0U };
1359 KRML_MAYBE_FOR5(i,
1360 0U,
1361 5U,
1362 1U,
1363 _C[i] = s[i + 0U] ^ (s[i + 5U] ^ (s[i + 10U] ^ (s[i + 15U] ^ s[i + 20U]))););
1364 KRML_MAYBE_FOR5(i2,
1365 0U,
1366 5U,
1367 1U,
1368 uint64_t uu____0 = _C[(i2 + 1U) % 5U];
1369 uint64_t _D = _C[(i2 + 4U) % 5U] ^ (uu____0 << 1U | uu____0 >> 63U);
1370 KRML_MAYBE_FOR5(i, 0U, 5U, 1U, s[i2 + 5U * i] = s[i2 + 5U * i] ^ _D;););
1371 uint64_t x = s[1U];
1372 uint64_t current = x;
1373 for (uint32_t i = 0U; i < 24U; i++)
1374 {
1375 uint32_t _Y = Hacl_Hash_SHA3_keccak_piln[i];
1376 uint32_t r = Hacl_Hash_SHA3_keccak_rotc[i];
1377 uint64_t temp = s[_Y];
1378 uint64_t uu____1 = current;
1379 s[_Y] = uu____1 << r | uu____1 >> (64U - r);
1380 current = temp;
1381 }
1382 KRML_MAYBE_FOR5(i,
1383 0U,
1384 5U,
1385 1U,
1386 uint64_t v0 = s[0U + 5U * i] ^ (~s[1U + 5U * i] & s[2U + 5U * i]);
1387 uint64_t v1 = s[1U + 5U * i] ^ (~s[2U + 5U * i] & s[3U + 5U * i]);
1388 uint64_t v2 = s[2U + 5U * i] ^ (~s[3U + 5U * i] & s[4U + 5U * i]);
1389 uint64_t v3 = s[3U + 5U * i] ^ (~s[4U + 5U * i] & s[0U + 5U * i]);
1390 uint64_t v4 = s[4U + 5U * i] ^ (~s[0U + 5U * i] & s[1U + 5U * i]);
1391 s[0U + 5U * i] = v0;
1392 s[1U + 5U * i] = v1;
1393 s[2U + 5U * i] = v2;
1394 s[3U + 5U * i] = v3;
1395 s[4U + 5U * i] = v4;);
1396 uint64_t c = Hacl_Hash_SHA3_keccak_rndc[i1];
1397 s[0U] = s[0U] ^ c;
1398 }
1399 }
1400 uint32_t remOut = outputByteLen % rateInBytes1;
1401 uint8_t hbuf[256U] = { 0U };
1402 uint64_t ws[32U] = { 0U };
1403 memcpy(ws, s, 25U * sizeof (uint64_t));
1404 for (uint32_t i = 0U; i < 32U; i++)
1405 {
1406 store64_le(hbuf + i * 8U, ws[i]);
1407 }
1408 memcpy(rb + outputByteLen - remOut, hbuf, remOut * sizeof (uint8_t));
1409 }
1410
1411 void
1412 Hacl_Hash_SHA3_shake256(
1413 uint8_t *output,
1414 uint32_t outputByteLen,
1415 uint8_t *input,
1416 uint32_t inputByteLen
1417 )
1418 {
1419 uint8_t *ib = input;
1420 uint8_t *rb = output;
1421 uint64_t s[25U] = { 0U };
1422 uint32_t rateInBytes1 = 136U;
1423 for (uint32_t i = 0U; i < inputByteLen / rateInBytes1; i++)
1424 {
1425 uint8_t b[256U] = { 0U };
1426 uint8_t *b_ = b;
1427 uint8_t *b0 = ib;
1428 uint8_t *bl0 = b_;
1429 memcpy(bl0, b0 + i * rateInBytes1, rateInBytes1 * sizeof (uint8_t));
1430 Hacl_Hash_SHA3_absorb_inner_32(rateInBytes1, b_, s);
1431 }
1432 uint8_t b1[256U] = { 0U };
1433 uint8_t *b_ = b1;
1434 uint32_t rem = inputByteLen % rateInBytes1;
1435 uint8_t *b00 = ib;
1436 uint8_t *bl0 = b_;
1437 memcpy(bl0, b00 + inputByteLen - rem, rem * sizeof (uint8_t));
1438 uint8_t *b01 = b_;
1439 b01[inputByteLen % rateInBytes1] = 0x1FU;
1440 uint64_t ws0[32U] = { 0U };
1441 uint8_t *b = b_;
1442 uint64_t u = load64_le(b);
1443 ws0[0U] = u;
1444 uint64_t u0 = load64_le(b + 8U);
1445 ws0[1U] = u0;
1446 uint64_t u1 = load64_le(b + 16U);
1447 ws0[2U] = u1;
1448 uint64_t u2 = load64_le(b + 24U);
1449 ws0[3U] = u2;
1450 uint64_t u3 = load64_le(b + 32U);
1451 ws0[4U] = u3;
1452 uint64_t u4 = load64_le(b + 40U);
1453 ws0[5U] = u4;
1454 uint64_t u5 = load64_le(b + 48U);
1455 ws0[6U] = u5;
1456 uint64_t u6 = load64_le(b + 56U);
1457 ws0[7U] = u6;
1458 uint64_t u7 = load64_le(b + 64U);
1459 ws0[8U] = u7;
1460 uint64_t u8 = load64_le(b + 72U);
1461 ws0[9U] = u8;
1462 uint64_t u9 = load64_le(b + 80U);
1463 ws0[10U] = u9;
1464 uint64_t u10 = load64_le(b + 88U);
1465 ws0[11U] = u10;
1466 uint64_t u11 = load64_le(b + 96U);
1467 ws0[12U] = u11;
1468 uint64_t u12 = load64_le(b + 104U);
1469 ws0[13U] = u12;
1470 uint64_t u13 = load64_le(b + 112U);
1471 ws0[14U] = u13;
1472 uint64_t u14 = load64_le(b + 120U);
1473 ws0[15U] = u14;
1474 uint64_t u15 = load64_le(b + 128U);
1475 ws0[16U] = u15;
1476 uint64_t u16 = load64_le(b + 136U);
1477 ws0[17U] = u16;
1478 uint64_t u17 = load64_le(b + 144U);
1479 ws0[18U] = u17;
1480 uint64_t u18 = load64_le(b + 152U);
1481 ws0[19U] = u18;
1482 uint64_t u19 = load64_le(b + 160U);
1483 ws0[20U] = u19;
1484 uint64_t u20 = load64_le(b + 168U);
1485 ws0[21U] = u20;
1486 uint64_t u21 = load64_le(b + 176U);
1487 ws0[22U] = u21;
1488 uint64_t u22 = load64_le(b + 184U);
1489 ws0[23U] = u22;
1490 uint64_t u23 = load64_le(b + 192U);
1491 ws0[24U] = u23;
1492 uint64_t u24 = load64_le(b + 200U);
1493 ws0[25U] = u24;
1494 uint64_t u25 = load64_le(b + 208U);
1495 ws0[26U] = u25;
1496 uint64_t u26 = load64_le(b + 216U);
1497 ws0[27U] = u26;
1498 uint64_t u27 = load64_le(b + 224U);
1499 ws0[28U] = u27;
1500 uint64_t u28 = load64_le(b + 232U);
1501 ws0[29U] = u28;
1502 uint64_t u29 = load64_le(b + 240U);
1503 ws0[30U] = u29;
1504 uint64_t u30 = load64_le(b + 248U);
1505 ws0[31U] = u30;
1506 for (uint32_t i = 0U; i < 25U; i++)
1507 {
1508 s[i] = s[i] ^ ws0[i];
1509 }
1510 uint8_t b2[256U] = { 0U };
1511 uint8_t *b3 = b2;
1512 uint8_t *b0 = b3;
1513 b0[rateInBytes1 - 1U] = 0x80U;
1514 Hacl_Hash_SHA3_absorb_inner_32(rateInBytes1, b3, s);
1515 for (uint32_t i0 = 0U; i0 < outputByteLen / rateInBytes1; i0++)
1516 {
1517 uint8_t hbuf[256U] = { 0U };
1518 uint64_t ws[32U] = { 0U };
1519 memcpy(ws, s, 25U * sizeof (uint64_t));
1520 for (uint32_t i = 0U; i < 32U; i++)
1521 {
1522 store64_le(hbuf + i * 8U, ws[i]);
1523 }
1524 uint8_t *b02 = rb;
1525 memcpy(b02 + i0 * rateInBytes1, hbuf, rateInBytes1 * sizeof (uint8_t));
1526 for (uint32_t i1 = 0U; i1 < 24U; i1++)
1527 {
1528 uint64_t _C[5U] = { 0U };
1529 KRML_MAYBE_FOR5(i,
1530 0U,
1531 5U,
1532 1U,
1533 _C[i] = s[i + 0U] ^ (s[i + 5U] ^ (s[i + 10U] ^ (s[i + 15U] ^ s[i + 20U]))););
1534 KRML_MAYBE_FOR5(i2,
1535 0U,
1536 5U,
1537 1U,
1538 uint64_t uu____0 = _C[(i2 + 1U) % 5U];
1539 uint64_t _D = _C[(i2 + 4U) % 5U] ^ (uu____0 << 1U | uu____0 >> 63U);
1540 KRML_MAYBE_FOR5(i, 0U, 5U, 1U, s[i2 + 5U * i] = s[i2 + 5U * i] ^ _D;););
1541 uint64_t x = s[1U];
1542 uint64_t current = x;
1543 for (uint32_t i = 0U; i < 24U; i++)
1544 {
1545 uint32_t _Y = Hacl_Hash_SHA3_keccak_piln[i];
1546 uint32_t r = Hacl_Hash_SHA3_keccak_rotc[i];
1547 uint64_t temp = s[_Y];
1548 uint64_t uu____1 = current;
1549 s[_Y] = uu____1 << r | uu____1 >> (64U - r);
1550 current = temp;
1551 }
1552 KRML_MAYBE_FOR5(i,
1553 0U,
1554 5U,
1555 1U,
1556 uint64_t v0 = s[0U + 5U * i] ^ (~s[1U + 5U * i] & s[2U + 5U * i]);
1557 uint64_t v1 = s[1U + 5U * i] ^ (~s[2U + 5U * i] & s[3U + 5U * i]);
1558 uint64_t v2 = s[2U + 5U * i] ^ (~s[3U + 5U * i] & s[4U + 5U * i]);
1559 uint64_t v3 = s[3U + 5U * i] ^ (~s[4U + 5U * i] & s[0U + 5U * i]);
1560 uint64_t v4 = s[4U + 5U * i] ^ (~s[0U + 5U * i] & s[1U + 5U * i]);
1561 s[0U + 5U * i] = v0;
1562 s[1U + 5U * i] = v1;
1563 s[2U + 5U * i] = v2;
1564 s[3U + 5U * i] = v3;
1565 s[4U + 5U * i] = v4;);
1566 uint64_t c = Hacl_Hash_SHA3_keccak_rndc[i1];
1567 s[0U] = s[0U] ^ c;
1568 }
1569 }
1570 uint32_t remOut = outputByteLen % rateInBytes1;
1571 uint8_t hbuf[256U] = { 0U };
1572 uint64_t ws[32U] = { 0U };
1573 memcpy(ws, s, 25U * sizeof (uint64_t));
1574 for (uint32_t i = 0U; i < 32U; i++)
1575 {
1576 store64_le(hbuf + i * 8U, ws[i]);
1577 }
1578 memcpy(rb + outputByteLen - remOut, hbuf, remOut * sizeof (uint8_t));
1579 }
1580
1581 void Hacl_Hash_SHA3_sha3_224(uint8_t *output, uint8_t *input, uint32_t inputByteLen)
1582 {
1583 uint8_t *ib = input;
1584 uint8_t *rb = output;
1585 uint64_t s[25U] = { 0U };
1586 uint32_t rateInBytes1 = 144U;
1587 for (uint32_t i = 0U; i < inputByteLen / rateInBytes1; i++)
1588 {
1589 uint8_t b[256U] = { 0U };
1590 uint8_t *b_ = b;
1591 uint8_t *b0 = ib;
1592 uint8_t *bl0 = b_;
1593 memcpy(bl0, b0 + i * rateInBytes1, rateInBytes1 * sizeof (uint8_t));
1594 Hacl_Hash_SHA3_absorb_inner_32(rateInBytes1, b_, s);
1595 }
1596 uint8_t b1[256U] = { 0U };
1597 uint8_t *b_ = b1;
1598 uint32_t rem = inputByteLen % rateInBytes1;
1599 uint8_t *b00 = ib;
1600 uint8_t *bl0 = b_;
1601 memcpy(bl0, b00 + inputByteLen - rem, rem * sizeof (uint8_t));
1602 uint8_t *b01 = b_;
1603 b01[inputByteLen % rateInBytes1] = 0x06U;
1604 uint64_t ws0[32U] = { 0U };
1605 uint8_t *b = b_;
1606 uint64_t u = load64_le(b);
1607 ws0[0U] = u;
1608 uint64_t u0 = load64_le(b + 8U);
1609 ws0[1U] = u0;
1610 uint64_t u1 = load64_le(b + 16U);
1611 ws0[2U] = u1;
1612 uint64_t u2 = load64_le(b + 24U);
1613 ws0[3U] = u2;
1614 uint64_t u3 = load64_le(b + 32U);
1615 ws0[4U] = u3;
1616 uint64_t u4 = load64_le(b + 40U);
1617 ws0[5U] = u4;
1618 uint64_t u5 = load64_le(b + 48U);
1619 ws0[6U] = u5;
1620 uint64_t u6 = load64_le(b + 56U);
1621 ws0[7U] = u6;
1622 uint64_t u7 = load64_le(b + 64U);
1623 ws0[8U] = u7;
1624 uint64_t u8 = load64_le(b + 72U);
1625 ws0[9U] = u8;
1626 uint64_t u9 = load64_le(b + 80U);
1627 ws0[10U] = u9;
1628 uint64_t u10 = load64_le(b + 88U);
1629 ws0[11U] = u10;
1630 uint64_t u11 = load64_le(b + 96U);
1631 ws0[12U] = u11;
1632 uint64_t u12 = load64_le(b + 104U);
1633 ws0[13U] = u12;
1634 uint64_t u13 = load64_le(b + 112U);
1635 ws0[14U] = u13;
1636 uint64_t u14 = load64_le(b + 120U);
1637 ws0[15U] = u14;
1638 uint64_t u15 = load64_le(b + 128U);
1639 ws0[16U] = u15;
1640 uint64_t u16 = load64_le(b + 136U);
1641 ws0[17U] = u16;
1642 uint64_t u17 = load64_le(b + 144U);
1643 ws0[18U] = u17;
1644 uint64_t u18 = load64_le(b + 152U);
1645 ws0[19U] = u18;
1646 uint64_t u19 = load64_le(b + 160U);
1647 ws0[20U] = u19;
1648 uint64_t u20 = load64_le(b + 168U);
1649 ws0[21U] = u20;
1650 uint64_t u21 = load64_le(b + 176U);
1651 ws0[22U] = u21;
1652 uint64_t u22 = load64_le(b + 184U);
1653 ws0[23U] = u22;
1654 uint64_t u23 = load64_le(b + 192U);
1655 ws0[24U] = u23;
1656 uint64_t u24 = load64_le(b + 200U);
1657 ws0[25U] = u24;
1658 uint64_t u25 = load64_le(b + 208U);
1659 ws0[26U] = u25;
1660 uint64_t u26 = load64_le(b + 216U);
1661 ws0[27U] = u26;
1662 uint64_t u27 = load64_le(b + 224U);
1663 ws0[28U] = u27;
1664 uint64_t u28 = load64_le(b + 232U);
1665 ws0[29U] = u28;
1666 uint64_t u29 = load64_le(b + 240U);
1667 ws0[30U] = u29;
1668 uint64_t u30 = load64_le(b + 248U);
1669 ws0[31U] = u30;
1670 for (uint32_t i = 0U; i < 25U; i++)
1671 {
1672 s[i] = s[i] ^ ws0[i];
1673 }
1674 uint8_t b2[256U] = { 0U };
1675 uint8_t *b3 = b2;
1676 uint8_t *b0 = b3;
1677 b0[rateInBytes1 - 1U] = 0x80U;
1678 Hacl_Hash_SHA3_absorb_inner_32(rateInBytes1, b3, s);
1679 for (uint32_t i0 = 0U; i0 < 28U / rateInBytes1; i0++)
1680 {
1681 uint8_t hbuf[256U] = { 0U };
1682 uint64_t ws[32U] = { 0U };
1683 memcpy(ws, s, 25U * sizeof (uint64_t));
1684 for (uint32_t i = 0U; i < 32U; i++)
1685 {
1686 store64_le(hbuf + i * 8U, ws[i]);
1687 }
1688 uint8_t *b02 = rb;
1689 memcpy(b02 + i0 * rateInBytes1, hbuf, rateInBytes1 * sizeof (uint8_t));
1690 for (uint32_t i1 = 0U; i1 < 24U; i1++)
1691 {
1692 uint64_t _C[5U] = { 0U };
1693 KRML_MAYBE_FOR5(i,
1694 0U,
1695 5U,
1696 1U,
1697 _C[i] = s[i + 0U] ^ (s[i + 5U] ^ (s[i + 10U] ^ (s[i + 15U] ^ s[i + 20U]))););
1698 KRML_MAYBE_FOR5(i2,
1699 0U,
1700 5U,
1701 1U,
1702 uint64_t uu____0 = _C[(i2 + 1U) % 5U];
1703 uint64_t _D = _C[(i2 + 4U) % 5U] ^ (uu____0 << 1U | uu____0 >> 63U);
1704 KRML_MAYBE_FOR5(i, 0U, 5U, 1U, s[i2 + 5U * i] = s[i2 + 5U * i] ^ _D;););
1705 uint64_t x = s[1U];
1706 uint64_t current = x;
1707 for (uint32_t i = 0U; i < 24U; i++)
1708 {
1709 uint32_t _Y = Hacl_Hash_SHA3_keccak_piln[i];
1710 uint32_t r = Hacl_Hash_SHA3_keccak_rotc[i];
1711 uint64_t temp = s[_Y];
1712 uint64_t uu____1 = current;
1713 s[_Y] = uu____1 << r | uu____1 >> (64U - r);
1714 current = temp;
1715 }
1716 KRML_MAYBE_FOR5(i,
1717 0U,
1718 5U,
1719 1U,
1720 uint64_t v0 = s[0U + 5U * i] ^ (~s[1U + 5U * i] & s[2U + 5U * i]);
1721 uint64_t v1 = s[1U + 5U * i] ^ (~s[2U + 5U * i] & s[3U + 5U * i]);
1722 uint64_t v2 = s[2U + 5U * i] ^ (~s[3U + 5U * i] & s[4U + 5U * i]);
1723 uint64_t v3 = s[3U + 5U * i] ^ (~s[4U + 5U * i] & s[0U + 5U * i]);
1724 uint64_t v4 = s[4U + 5U * i] ^ (~s[0U + 5U * i] & s[1U + 5U * i]);
1725 s[0U + 5U * i] = v0;
1726 s[1U + 5U * i] = v1;
1727 s[2U + 5U * i] = v2;
1728 s[3U + 5U * i] = v3;
1729 s[4U + 5U * i] = v4;);
1730 uint64_t c = Hacl_Hash_SHA3_keccak_rndc[i1];
1731 s[0U] = s[0U] ^ c;
1732 }
1733 }
1734 uint32_t remOut = 28U % rateInBytes1;
1735 uint8_t hbuf[256U] = { 0U };
1736 uint64_t ws[32U] = { 0U };
1737 memcpy(ws, s, 25U * sizeof (uint64_t));
1738 for (uint32_t i = 0U; i < 32U; i++)
1739 {
1740 store64_le(hbuf + i * 8U, ws[i]);
1741 }
1742 memcpy(rb + 28U - remOut, hbuf, remOut * sizeof (uint8_t));
1743 }
1744
1745 void Hacl_Hash_SHA3_sha3_256(uint8_t *output, uint8_t *input, uint32_t inputByteLen)
1746 {
1747 uint8_t *ib = input;
1748 uint8_t *rb = output;
1749 uint64_t s[25U] = { 0U };
1750 uint32_t rateInBytes1 = 136U;
1751 for (uint32_t i = 0U; i < inputByteLen / rateInBytes1; i++)
1752 {
1753 uint8_t b[256U] = { 0U };
1754 uint8_t *b_ = b;
1755 uint8_t *b0 = ib;
1756 uint8_t *bl0 = b_;
1757 memcpy(bl0, b0 + i * rateInBytes1, rateInBytes1 * sizeof (uint8_t));
1758 Hacl_Hash_SHA3_absorb_inner_32(rateInBytes1, b_, s);
1759 }
1760 uint8_t b1[256U] = { 0U };
1761 uint8_t *b_ = b1;
1762 uint32_t rem = inputByteLen % rateInBytes1;
1763 uint8_t *b00 = ib;
1764 uint8_t *bl0 = b_;
1765 memcpy(bl0, b00 + inputByteLen - rem, rem * sizeof (uint8_t));
1766 uint8_t *b01 = b_;
1767 b01[inputByteLen % rateInBytes1] = 0x06U;
1768 uint64_t ws0[32U] = { 0U };
1769 uint8_t *b = b_;
1770 uint64_t u = load64_le(b);
1771 ws0[0U] = u;
1772 uint64_t u0 = load64_le(b + 8U);
1773 ws0[1U] = u0;
1774 uint64_t u1 = load64_le(b + 16U);
1775 ws0[2U] = u1;
1776 uint64_t u2 = load64_le(b + 24U);
1777 ws0[3U] = u2;
1778 uint64_t u3 = load64_le(b + 32U);
1779 ws0[4U] = u3;
1780 uint64_t u4 = load64_le(b + 40U);
1781 ws0[5U] = u4;
1782 uint64_t u5 = load64_le(b + 48U);
1783 ws0[6U] = u5;
1784 uint64_t u6 = load64_le(b + 56U);
1785 ws0[7U] = u6;
1786 uint64_t u7 = load64_le(b + 64U);
1787 ws0[8U] = u7;
1788 uint64_t u8 = load64_le(b + 72U);
1789 ws0[9U] = u8;
1790 uint64_t u9 = load64_le(b + 80U);
1791 ws0[10U] = u9;
1792 uint64_t u10 = load64_le(b + 88U);
1793 ws0[11U] = u10;
1794 uint64_t u11 = load64_le(b + 96U);
1795 ws0[12U] = u11;
1796 uint64_t u12 = load64_le(b + 104U);
1797 ws0[13U] = u12;
1798 uint64_t u13 = load64_le(b + 112U);
1799 ws0[14U] = u13;
1800 uint64_t u14 = load64_le(b + 120U);
1801 ws0[15U] = u14;
1802 uint64_t u15 = load64_le(b + 128U);
1803 ws0[16U] = u15;
1804 uint64_t u16 = load64_le(b + 136U);
1805 ws0[17U] = u16;
1806 uint64_t u17 = load64_le(b + 144U);
1807 ws0[18U] = u17;
1808 uint64_t u18 = load64_le(b + 152U);
1809 ws0[19U] = u18;
1810 uint64_t u19 = load64_le(b + 160U);
1811 ws0[20U] = u19;
1812 uint64_t u20 = load64_le(b + 168U);
1813 ws0[21U] = u20;
1814 uint64_t u21 = load64_le(b + 176U);
1815 ws0[22U] = u21;
1816 uint64_t u22 = load64_le(b + 184U);
1817 ws0[23U] = u22;
1818 uint64_t u23 = load64_le(b + 192U);
1819 ws0[24U] = u23;
1820 uint64_t u24 = load64_le(b + 200U);
1821 ws0[25U] = u24;
1822 uint64_t u25 = load64_le(b + 208U);
1823 ws0[26U] = u25;
1824 uint64_t u26 = load64_le(b + 216U);
1825 ws0[27U] = u26;
1826 uint64_t u27 = load64_le(b + 224U);
1827 ws0[28U] = u27;
1828 uint64_t u28 = load64_le(b + 232U);
1829 ws0[29U] = u28;
1830 uint64_t u29 = load64_le(b + 240U);
1831 ws0[30U] = u29;
1832 uint64_t u30 = load64_le(b + 248U);
1833 ws0[31U] = u30;
1834 for (uint32_t i = 0U; i < 25U; i++)
1835 {
1836 s[i] = s[i] ^ ws0[i];
1837 }
1838 uint8_t b2[256U] = { 0U };
1839 uint8_t *b3 = b2;
1840 uint8_t *b0 = b3;
1841 b0[rateInBytes1 - 1U] = 0x80U;
1842 Hacl_Hash_SHA3_absorb_inner_32(rateInBytes1, b3, s);
1843 for (uint32_t i0 = 0U; i0 < 32U / rateInBytes1; i0++)
1844 {
1845 uint8_t hbuf[256U] = { 0U };
1846 uint64_t ws[32U] = { 0U };
1847 memcpy(ws, s, 25U * sizeof (uint64_t));
1848 for (uint32_t i = 0U; i < 32U; i++)
1849 {
1850 store64_le(hbuf + i * 8U, ws[i]);
1851 }
1852 uint8_t *b02 = rb;
1853 memcpy(b02 + i0 * rateInBytes1, hbuf, rateInBytes1 * sizeof (uint8_t));
1854 for (uint32_t i1 = 0U; i1 < 24U; i1++)
1855 {
1856 uint64_t _C[5U] = { 0U };
1857 KRML_MAYBE_FOR5(i,
1858 0U,
1859 5U,
1860 1U,
1861 _C[i] = s[i + 0U] ^ (s[i + 5U] ^ (s[i + 10U] ^ (s[i + 15U] ^ s[i + 20U]))););
1862 KRML_MAYBE_FOR5(i2,
1863 0U,
1864 5U,
1865 1U,
1866 uint64_t uu____0 = _C[(i2 + 1U) % 5U];
1867 uint64_t _D = _C[(i2 + 4U) % 5U] ^ (uu____0 << 1U | uu____0 >> 63U);
1868 KRML_MAYBE_FOR5(i, 0U, 5U, 1U, s[i2 + 5U * i] = s[i2 + 5U * i] ^ _D;););
1869 uint64_t x = s[1U];
1870 uint64_t current = x;
1871 for (uint32_t i = 0U; i < 24U; i++)
1872 {
1873 uint32_t _Y = Hacl_Hash_SHA3_keccak_piln[i];
1874 uint32_t r = Hacl_Hash_SHA3_keccak_rotc[i];
1875 uint64_t temp = s[_Y];
1876 uint64_t uu____1 = current;
1877 s[_Y] = uu____1 << r | uu____1 >> (64U - r);
1878 current = temp;
1879 }
1880 KRML_MAYBE_FOR5(i,
1881 0U,
1882 5U,
1883 1U,
1884 uint64_t v0 = s[0U + 5U * i] ^ (~s[1U + 5U * i] & s[2U + 5U * i]);
1885 uint64_t v1 = s[1U + 5U * i] ^ (~s[2U + 5U * i] & s[3U + 5U * i]);
1886 uint64_t v2 = s[2U + 5U * i] ^ (~s[3U + 5U * i] & s[4U + 5U * i]);
1887 uint64_t v3 = s[3U + 5U * i] ^ (~s[4U + 5U * i] & s[0U + 5U * i]);
1888 uint64_t v4 = s[4U + 5U * i] ^ (~s[0U + 5U * i] & s[1U + 5U * i]);
1889 s[0U + 5U * i] = v0;
1890 s[1U + 5U * i] = v1;
1891 s[2U + 5U * i] = v2;
1892 s[3U + 5U * i] = v3;
1893 s[4U + 5U * i] = v4;);
1894 uint64_t c = Hacl_Hash_SHA3_keccak_rndc[i1];
1895 s[0U] = s[0U] ^ c;
1896 }
1897 }
1898 uint32_t remOut = 32U % rateInBytes1;
1899 uint8_t hbuf[256U] = { 0U };
1900 uint64_t ws[32U] = { 0U };
1901 memcpy(ws, s, 25U * sizeof (uint64_t));
1902 for (uint32_t i = 0U; i < 32U; i++)
1903 {
1904 store64_le(hbuf + i * 8U, ws[i]);
1905 }
1906 memcpy(rb + 32U - remOut, hbuf, remOut * sizeof (uint8_t));
1907 }
1908
1909 void Hacl_Hash_SHA3_sha3_384(uint8_t *output, uint8_t *input, uint32_t inputByteLen)
1910 {
1911 uint8_t *ib = input;
1912 uint8_t *rb = output;
1913 uint64_t s[25U] = { 0U };
1914 uint32_t rateInBytes1 = 104U;
1915 for (uint32_t i = 0U; i < inputByteLen / rateInBytes1; i++)
1916 {
1917 uint8_t b[256U] = { 0U };
1918 uint8_t *b_ = b;
1919 uint8_t *b0 = ib;
1920 uint8_t *bl0 = b_;
1921 memcpy(bl0, b0 + i * rateInBytes1, rateInBytes1 * sizeof (uint8_t));
1922 Hacl_Hash_SHA3_absorb_inner_32(rateInBytes1, b_, s);
1923 }
1924 uint8_t b1[256U] = { 0U };
1925 uint8_t *b_ = b1;
1926 uint32_t rem = inputByteLen % rateInBytes1;
1927 uint8_t *b00 = ib;
1928 uint8_t *bl0 = b_;
1929 memcpy(bl0, b00 + inputByteLen - rem, rem * sizeof (uint8_t));
1930 uint8_t *b01 = b_;
1931 b01[inputByteLen % rateInBytes1] = 0x06U;
1932 uint64_t ws0[32U] = { 0U };
1933 uint8_t *b = b_;
1934 uint64_t u = load64_le(b);
1935 ws0[0U] = u;
1936 uint64_t u0 = load64_le(b + 8U);
1937 ws0[1U] = u0;
1938 uint64_t u1 = load64_le(b + 16U);
1939 ws0[2U] = u1;
1940 uint64_t u2 = load64_le(b + 24U);
1941 ws0[3U] = u2;
1942 uint64_t u3 = load64_le(b + 32U);
1943 ws0[4U] = u3;
1944 uint64_t u4 = load64_le(b + 40U);
1945 ws0[5U] = u4;
1946 uint64_t u5 = load64_le(b + 48U);
1947 ws0[6U] = u5;
1948 uint64_t u6 = load64_le(b + 56U);
1949 ws0[7U] = u6;
1950 uint64_t u7 = load64_le(b + 64U);
1951 ws0[8U] = u7;
1952 uint64_t u8 = load64_le(b + 72U);
1953 ws0[9U] = u8;
1954 uint64_t u9 = load64_le(b + 80U);
1955 ws0[10U] = u9;
1956 uint64_t u10 = load64_le(b + 88U);
1957 ws0[11U] = u10;
1958 uint64_t u11 = load64_le(b + 96U);
1959 ws0[12U] = u11;
1960 uint64_t u12 = load64_le(b + 104U);
1961 ws0[13U] = u12;
1962 uint64_t u13 = load64_le(b + 112U);
1963 ws0[14U] = u13;
1964 uint64_t u14 = load64_le(b + 120U);
1965 ws0[15U] = u14;
1966 uint64_t u15 = load64_le(b + 128U);
1967 ws0[16U] = u15;
1968 uint64_t u16 = load64_le(b + 136U);
1969 ws0[17U] = u16;
1970 uint64_t u17 = load64_le(b + 144U);
1971 ws0[18U] = u17;
1972 uint64_t u18 = load64_le(b + 152U);
1973 ws0[19U] = u18;
1974 uint64_t u19 = load64_le(b + 160U);
1975 ws0[20U] = u19;
1976 uint64_t u20 = load64_le(b + 168U);
1977 ws0[21U] = u20;
1978 uint64_t u21 = load64_le(b + 176U);
1979 ws0[22U] = u21;
1980 uint64_t u22 = load64_le(b + 184U);
1981 ws0[23U] = u22;
1982 uint64_t u23 = load64_le(b + 192U);
1983 ws0[24U] = u23;
1984 uint64_t u24 = load64_le(b + 200U);
1985 ws0[25U] = u24;
1986 uint64_t u25 = load64_le(b + 208U);
1987 ws0[26U] = u25;
1988 uint64_t u26 = load64_le(b + 216U);
1989 ws0[27U] = u26;
1990 uint64_t u27 = load64_le(b + 224U);
1991 ws0[28U] = u27;
1992 uint64_t u28 = load64_le(b + 232U);
1993 ws0[29U] = u28;
1994 uint64_t u29 = load64_le(b + 240U);
1995 ws0[30U] = u29;
1996 uint64_t u30 = load64_le(b + 248U);
1997 ws0[31U] = u30;
1998 for (uint32_t i = 0U; i < 25U; i++)
1999 {
2000 s[i] = s[i] ^ ws0[i];
2001 }
2002 uint8_t b2[256U] = { 0U };
2003 uint8_t *b3 = b2;
2004 uint8_t *b0 = b3;
2005 b0[rateInBytes1 - 1U] = 0x80U;
2006 Hacl_Hash_SHA3_absorb_inner_32(rateInBytes1, b3, s);
2007 for (uint32_t i0 = 0U; i0 < 48U / rateInBytes1; i0++)
2008 {
2009 uint8_t hbuf[256U] = { 0U };
2010 uint64_t ws[32U] = { 0U };
2011 memcpy(ws, s, 25U * sizeof (uint64_t));
2012 for (uint32_t i = 0U; i < 32U; i++)
2013 {
2014 store64_le(hbuf + i * 8U, ws[i]);
2015 }
2016 uint8_t *b02 = rb;
2017 memcpy(b02 + i0 * rateInBytes1, hbuf, rateInBytes1 * sizeof (uint8_t));
2018 for (uint32_t i1 = 0U; i1 < 24U; i1++)
2019 {
2020 uint64_t _C[5U] = { 0U };
2021 KRML_MAYBE_FOR5(i,
2022 0U,
2023 5U,
2024 1U,
2025 _C[i] = s[i + 0U] ^ (s[i + 5U] ^ (s[i + 10U] ^ (s[i + 15U] ^ s[i + 20U]))););
2026 KRML_MAYBE_FOR5(i2,
2027 0U,
2028 5U,
2029 1U,
2030 uint64_t uu____0 = _C[(i2 + 1U) % 5U];
2031 uint64_t _D = _C[(i2 + 4U) % 5U] ^ (uu____0 << 1U | uu____0 >> 63U);
2032 KRML_MAYBE_FOR5(i, 0U, 5U, 1U, s[i2 + 5U * i] = s[i2 + 5U * i] ^ _D;););
2033 uint64_t x = s[1U];
2034 uint64_t current = x;
2035 for (uint32_t i = 0U; i < 24U; i++)
2036 {
2037 uint32_t _Y = Hacl_Hash_SHA3_keccak_piln[i];
2038 uint32_t r = Hacl_Hash_SHA3_keccak_rotc[i];
2039 uint64_t temp = s[_Y];
2040 uint64_t uu____1 = current;
2041 s[_Y] = uu____1 << r | uu____1 >> (64U - r);
2042 current = temp;
2043 }
2044 KRML_MAYBE_FOR5(i,
2045 0U,
2046 5U,
2047 1U,
2048 uint64_t v0 = s[0U + 5U * i] ^ (~s[1U + 5U * i] & s[2U + 5U * i]);
2049 uint64_t v1 = s[1U + 5U * i] ^ (~s[2U + 5U * i] & s[3U + 5U * i]);
2050 uint64_t v2 = s[2U + 5U * i] ^ (~s[3U + 5U * i] & s[4U + 5U * i]);
2051 uint64_t v3 = s[3U + 5U * i] ^ (~s[4U + 5U * i] & s[0U + 5U * i]);
2052 uint64_t v4 = s[4U + 5U * i] ^ (~s[0U + 5U * i] & s[1U + 5U * i]);
2053 s[0U + 5U * i] = v0;
2054 s[1U + 5U * i] = v1;
2055 s[2U + 5U * i] = v2;
2056 s[3U + 5U * i] = v3;
2057 s[4U + 5U * i] = v4;);
2058 uint64_t c = Hacl_Hash_SHA3_keccak_rndc[i1];
2059 s[0U] = s[0U] ^ c;
2060 }
2061 }
2062 uint32_t remOut = 48U % rateInBytes1;
2063 uint8_t hbuf[256U] = { 0U };
2064 uint64_t ws[32U] = { 0U };
2065 memcpy(ws, s, 25U * sizeof (uint64_t));
2066 for (uint32_t i = 0U; i < 32U; i++)
2067 {
2068 store64_le(hbuf + i * 8U, ws[i]);
2069 }
2070 memcpy(rb + 48U - remOut, hbuf, remOut * sizeof (uint8_t));
2071 }
2072
2073 void Hacl_Hash_SHA3_sha3_512(uint8_t *output, uint8_t *input, uint32_t inputByteLen)
2074 {
2075 uint8_t *ib = input;
2076 uint8_t *rb = output;
2077 uint64_t s[25U] = { 0U };
2078 uint32_t rateInBytes1 = 72U;
2079 for (uint32_t i = 0U; i < inputByteLen / rateInBytes1; i++)
2080 {
2081 uint8_t b[256U] = { 0U };
2082 uint8_t *b_ = b;
2083 uint8_t *b0 = ib;
2084 uint8_t *bl0 = b_;
2085 memcpy(bl0, b0 + i * rateInBytes1, rateInBytes1 * sizeof (uint8_t));
2086 Hacl_Hash_SHA3_absorb_inner_32(rateInBytes1, b_, s);
2087 }
2088 uint8_t b1[256U] = { 0U };
2089 uint8_t *b_ = b1;
2090 uint32_t rem = inputByteLen % rateInBytes1;
2091 uint8_t *b00 = ib;
2092 uint8_t *bl0 = b_;
2093 memcpy(bl0, b00 + inputByteLen - rem, rem * sizeof (uint8_t));
2094 uint8_t *b01 = b_;
2095 b01[inputByteLen % rateInBytes1] = 0x06U;
2096 uint64_t ws0[32U] = { 0U };
2097 uint8_t *b = b_;
2098 uint64_t u = load64_le(b);
2099 ws0[0U] = u;
2100 uint64_t u0 = load64_le(b + 8U);
2101 ws0[1U] = u0;
2102 uint64_t u1 = load64_le(b + 16U);
2103 ws0[2U] = u1;
2104 uint64_t u2 = load64_le(b + 24U);
2105 ws0[3U] = u2;
2106 uint64_t u3 = load64_le(b + 32U);
2107 ws0[4U] = u3;
2108 uint64_t u4 = load64_le(b + 40U);
2109 ws0[5U] = u4;
2110 uint64_t u5 = load64_le(b + 48U);
2111 ws0[6U] = u5;
2112 uint64_t u6 = load64_le(b + 56U);
2113 ws0[7U] = u6;
2114 uint64_t u7 = load64_le(b + 64U);
2115 ws0[8U] = u7;
2116 uint64_t u8 = load64_le(b + 72U);
2117 ws0[9U] = u8;
2118 uint64_t u9 = load64_le(b + 80U);
2119 ws0[10U] = u9;
2120 uint64_t u10 = load64_le(b + 88U);
2121 ws0[11U] = u10;
2122 uint64_t u11 = load64_le(b + 96U);
2123 ws0[12U] = u11;
2124 uint64_t u12 = load64_le(b + 104U);
2125 ws0[13U] = u12;
2126 uint64_t u13 = load64_le(b + 112U);
2127 ws0[14U] = u13;
2128 uint64_t u14 = load64_le(b + 120U);
2129 ws0[15U] = u14;
2130 uint64_t u15 = load64_le(b + 128U);
2131 ws0[16U] = u15;
2132 uint64_t u16 = load64_le(b + 136U);
2133 ws0[17U] = u16;
2134 uint64_t u17 = load64_le(b + 144U);
2135 ws0[18U] = u17;
2136 uint64_t u18 = load64_le(b + 152U);
2137 ws0[19U] = u18;
2138 uint64_t u19 = load64_le(b + 160U);
2139 ws0[20U] = u19;
2140 uint64_t u20 = load64_le(b + 168U);
2141 ws0[21U] = u20;
2142 uint64_t u21 = load64_le(b + 176U);
2143 ws0[22U] = u21;
2144 uint64_t u22 = load64_le(b + 184U);
2145 ws0[23U] = u22;
2146 uint64_t u23 = load64_le(b + 192U);
2147 ws0[24U] = u23;
2148 uint64_t u24 = load64_le(b + 200U);
2149 ws0[25U] = u24;
2150 uint64_t u25 = load64_le(b + 208U);
2151 ws0[26U] = u25;
2152 uint64_t u26 = load64_le(b + 216U);
2153 ws0[27U] = u26;
2154 uint64_t u27 = load64_le(b + 224U);
2155 ws0[28U] = u27;
2156 uint64_t u28 = load64_le(b + 232U);
2157 ws0[29U] = u28;
2158 uint64_t u29 = load64_le(b + 240U);
2159 ws0[30U] = u29;
2160 uint64_t u30 = load64_le(b + 248U);
2161 ws0[31U] = u30;
2162 for (uint32_t i = 0U; i < 25U; i++)
2163 {
2164 s[i] = s[i] ^ ws0[i];
2165 }
2166 uint8_t b2[256U] = { 0U };
2167 uint8_t *b3 = b2;
2168 uint8_t *b0 = b3;
2169 b0[rateInBytes1 - 1U] = 0x80U;
2170 Hacl_Hash_SHA3_absorb_inner_32(rateInBytes1, b3, s);
2171 for (uint32_t i0 = 0U; i0 < 64U / rateInBytes1; i0++)
2172 {
2173 uint8_t hbuf[256U] = { 0U };
2174 uint64_t ws[32U] = { 0U };
2175 memcpy(ws, s, 25U * sizeof (uint64_t));
2176 for (uint32_t i = 0U; i < 32U; i++)
2177 {
2178 store64_le(hbuf + i * 8U, ws[i]);
2179 }
2180 uint8_t *b02 = rb;
2181 memcpy(b02 + i0 * rateInBytes1, hbuf, rateInBytes1 * sizeof (uint8_t));
2182 for (uint32_t i1 = 0U; i1 < 24U; i1++)
2183 {
2184 uint64_t _C[5U] = { 0U };
2185 KRML_MAYBE_FOR5(i,
2186 0U,
2187 5U,
2188 1U,
2189 _C[i] = s[i + 0U] ^ (s[i + 5U] ^ (s[i + 10U] ^ (s[i + 15U] ^ s[i + 20U]))););
2190 KRML_MAYBE_FOR5(i2,
2191 0U,
2192 5U,
2193 1U,
2194 uint64_t uu____0 = _C[(i2 + 1U) % 5U];
2195 uint64_t _D = _C[(i2 + 4U) % 5U] ^ (uu____0 << 1U | uu____0 >> 63U);
2196 KRML_MAYBE_FOR5(i, 0U, 5U, 1U, s[i2 + 5U * i] = s[i2 + 5U * i] ^ _D;););
2197 uint64_t x = s[1U];
2198 uint64_t current = x;
2199 for (uint32_t i = 0U; i < 24U; i++)
2200 {
2201 uint32_t _Y = Hacl_Hash_SHA3_keccak_piln[i];
2202 uint32_t r = Hacl_Hash_SHA3_keccak_rotc[i];
2203 uint64_t temp = s[_Y];
2204 uint64_t uu____1 = current;
2205 s[_Y] = uu____1 << r | uu____1 >> (64U - r);
2206 current = temp;
2207 }
2208 KRML_MAYBE_FOR5(i,
2209 0U,
2210 5U,
2211 1U,
2212 uint64_t v0 = s[0U + 5U * i] ^ (~s[1U + 5U * i] & s[2U + 5U * i]);
2213 uint64_t v1 = s[1U + 5U * i] ^ (~s[2U + 5U * i] & s[3U + 5U * i]);
2214 uint64_t v2 = s[2U + 5U * i] ^ (~s[3U + 5U * i] & s[4U + 5U * i]);
2215 uint64_t v3 = s[3U + 5U * i] ^ (~s[4U + 5U * i] & s[0U + 5U * i]);
2216 uint64_t v4 = s[4U + 5U * i] ^ (~s[0U + 5U * i] & s[1U + 5U * i]);
2217 s[0U + 5U * i] = v0;
2218 s[1U + 5U * i] = v1;
2219 s[2U + 5U * i] = v2;
2220 s[3U + 5U * i] = v3;
2221 s[4U + 5U * i] = v4;);
2222 uint64_t c = Hacl_Hash_SHA3_keccak_rndc[i1];
2223 s[0U] = s[0U] ^ c;
2224 }
2225 }
2226 uint32_t remOut = 64U % rateInBytes1;
2227 uint8_t hbuf[256U] = { 0U };
2228 uint64_t ws[32U] = { 0U };
2229 memcpy(ws, s, 25U * sizeof (uint64_t));
2230 for (uint32_t i = 0U; i < 32U; i++)
2231 {
2232 store64_le(hbuf + i * 8U, ws[i]);
2233 }
2234 memcpy(rb + 64U - remOut, hbuf, remOut * sizeof (uint8_t));
2235 }
2236
2237 /**
2238 Allocate state buffer of 200-bytes
2239 */
2240 uint64_t *Hacl_Hash_SHA3_state_malloc(void)
2241 {
2242 uint64_t *buf = (uint64_t *)KRML_HOST_CALLOC(25U, sizeof (uint64_t));
2243 return buf;
2244 }
2245
2246 /**
2247 Free state buffer
2248 */
2249 void Hacl_Hash_SHA3_state_free(uint64_t *s)
2250 {
2251 KRML_HOST_FREE(s);
2252 }
2253
2254 /**
2255 Absorb number of input blocks and write the output state
2256
2257 This function is intended to receive a hash state and input buffer.
2258 It processes an input of multiple of 168-bytes (SHAKE128 block size),
2259 any additional bytes of final partial block are ignored.
2260
2261 The argument `state` (IN/OUT) points to hash state, i.e., uint64_t[25]
2262 The argument `input` (IN) points to `inputByteLen` bytes of valid memory,
2263 i.e., uint8_t[inputByteLen]
2264 */
2265 void
2266 Hacl_Hash_SHA3_shake128_absorb_nblocks(uint64_t *state, uint8_t *input, uint32_t inputByteLen)
2267 {
2268 for (uint32_t i = 0U; i < inputByteLen / 168U; i++)
2269 {
2270 uint8_t b[256U] = { 0U };
2271 uint8_t *b_ = b;
2272 uint8_t *b0 = input;
2273 uint8_t *bl0 = b_;
2274 memcpy(bl0, b0 + i * 168U, 168U * sizeof (uint8_t));
2275 Hacl_Hash_SHA3_absorb_inner_32(168U, b_, state);
2276 }
2277 }
2278
2279 /**
2280 Absorb a final partial block of input and write the output state
2281
2282 This function is intended to receive a hash state and input buffer.
2283 It processes a sequence of bytes at end of input buffer that is less
2284 than 168-bytes (SHAKE128 block size),
2285 any bytes of full blocks at start of input buffer are ignored.
2286
2287 The argument `state` (IN/OUT) points to hash state, i.e., uint64_t[25]
2288 The argument `input` (IN) points to `inputByteLen` bytes of valid memory,
2289 i.e., uint8_t[inputByteLen]
2290
2291 Note: Full size of input buffer must be passed to `inputByteLen` including
2292 the number of full-block bytes at start of input buffer that are ignored
2293 */
2294 void
2295 Hacl_Hash_SHA3_shake128_absorb_final(uint64_t *state, uint8_t *input, uint32_t inputByteLen)
2296 {
2297 uint8_t b1[256U] = { 0U };
2298 uint8_t *b_ = b1;
2299 uint32_t rem = inputByteLen % 168U;
2300 uint8_t *b00 = input;
2301 uint8_t *bl0 = b_;
2302 memcpy(bl0, b00 + inputByteLen - rem, rem * sizeof (uint8_t));
2303 uint8_t *b01 = b_;
2304 b01[inputByteLen % 168U] = 0x1FU;
2305 uint64_t ws[32U] = { 0U };
2306 uint8_t *b = b_;
2307 uint64_t u = load64_le(b);
2308 ws[0U] = u;
2309 uint64_t u0 = load64_le(b + 8U);
2310 ws[1U] = u0;
2311 uint64_t u1 = load64_le(b + 16U);
2312 ws[2U] = u1;
2313 uint64_t u2 = load64_le(b + 24U);
2314 ws[3U] = u2;
2315 uint64_t u3 = load64_le(b + 32U);
2316 ws[4U] = u3;
2317 uint64_t u4 = load64_le(b + 40U);
2318 ws[5U] = u4;
2319 uint64_t u5 = load64_le(b + 48U);
2320 ws[6U] = u5;
2321 uint64_t u6 = load64_le(b + 56U);
2322 ws[7U] = u6;
2323 uint64_t u7 = load64_le(b + 64U);
2324 ws[8U] = u7;
2325 uint64_t u8 = load64_le(b + 72U);
2326 ws[9U] = u8;
2327 uint64_t u9 = load64_le(b + 80U);
2328 ws[10U] = u9;
2329 uint64_t u10 = load64_le(b + 88U);
2330 ws[11U] = u10;
2331 uint64_t u11 = load64_le(b + 96U);
2332 ws[12U] = u11;
2333 uint64_t u12 = load64_le(b + 104U);
2334 ws[13U] = u12;
2335 uint64_t u13 = load64_le(b + 112U);
2336 ws[14U] = u13;
2337 uint64_t u14 = load64_le(b + 120U);
2338 ws[15U] = u14;
2339 uint64_t u15 = load64_le(b + 128U);
2340 ws[16U] = u15;
2341 uint64_t u16 = load64_le(b + 136U);
2342 ws[17U] = u16;
2343 uint64_t u17 = load64_le(b + 144U);
2344 ws[18U] = u17;
2345 uint64_t u18 = load64_le(b + 152U);
2346 ws[19U] = u18;
2347 uint64_t u19 = load64_le(b + 160U);
2348 ws[20U] = u19;
2349 uint64_t u20 = load64_le(b + 168U);
2350 ws[21U] = u20;
2351 uint64_t u21 = load64_le(b + 176U);
2352 ws[22U] = u21;
2353 uint64_t u22 = load64_le(b + 184U);
2354 ws[23U] = u22;
2355 uint64_t u23 = load64_le(b + 192U);
2356 ws[24U] = u23;
2357 uint64_t u24 = load64_le(b + 200U);
2358 ws[25U] = u24;
2359 uint64_t u25 = load64_le(b + 208U);
2360 ws[26U] = u25;
2361 uint64_t u26 = load64_le(b + 216U);
2362 ws[27U] = u26;
2363 uint64_t u27 = load64_le(b + 224U);
2364 ws[28U] = u27;
2365 uint64_t u28 = load64_le(b + 232U);
2366 ws[29U] = u28;
2367 uint64_t u29 = load64_le(b + 240U);
2368 ws[30U] = u29;
2369 uint64_t u30 = load64_le(b + 248U);
2370 ws[31U] = u30;
2371 for (uint32_t i = 0U; i < 25U; i++)
2372 {
2373 state[i] = state[i] ^ ws[i];
2374 }
2375 uint8_t b2[256U] = { 0U };
2376 uint8_t *b3 = b2;
2377 uint8_t *b0 = b3;
2378 b0[167U] = 0x80U;
2379 Hacl_Hash_SHA3_absorb_inner_32(168U, b3, state);
2380 }
2381
2382 /**
2383 Squeeze a hash state to output buffer
2384
2385 This function is intended to receive a hash state and output buffer.
2386 It produces an output of multiple of 168-bytes (SHAKE128 block size),
2387 any additional bytes of final partial block are ignored.
2388
2389 The argument `state` (IN) points to hash state, i.e., uint64_t[25]
2390 The argument `output` (OUT) points to `outputByteLen` bytes of valid memory,
2391 i.e., uint8_t[outputByteLen]
2392 */
2393 void
2394 Hacl_Hash_SHA3_shake128_squeeze_nblocks(
2395 uint64_t *state,
2396 uint8_t *output,
2397 uint32_t outputByteLen
2398 )
2399 {
2400 for (uint32_t i0 = 0U; i0 < outputByteLen / 168U; i0++)
2401 {
2402 uint8_t hbuf[256U] = { 0U };
2403 uint64_t ws[32U] = { 0U };
2404 memcpy(ws, state, 25U * sizeof (uint64_t));
2405 for (uint32_t i = 0U; i < 32U; i++)
2406 {
2407 store64_le(hbuf + i * 8U, ws[i]);
2408 }
2409 uint8_t *b0 = output;
2410 memcpy(b0 + i0 * 168U, hbuf, 168U * sizeof (uint8_t));
2411 for (uint32_t i1 = 0U; i1 < 24U; i1++)
2412 {
2413 uint64_t _C[5U] = { 0U };
2414 KRML_MAYBE_FOR5(i,
2415 0U,
2416 5U,
2417 1U,
2418 _C[i] =
2419 state[i + 0U] ^ (state[i + 5U] ^ (state[i + 10U] ^ (state[i + 15U] ^ state[i + 20U]))););
2420 KRML_MAYBE_FOR5(i2,
2421 0U,
2422 5U,
2423 1U,
2424 uint64_t uu____0 = _C[(i2 + 1U) % 5U];
2425 uint64_t _D = _C[(i2 + 4U) % 5U] ^ (uu____0 << 1U | uu____0 >> 63U);
2426 KRML_MAYBE_FOR5(i, 0U, 5U, 1U, state[i2 + 5U * i] = state[i2 + 5U * i] ^ _D;););
2427 uint64_t x = state[1U];
2428 uint64_t current = x;
2429 for (uint32_t i = 0U; i < 24U; i++)
2430 {
2431 uint32_t _Y = Hacl_Hash_SHA3_keccak_piln[i];
2432 uint32_t r = Hacl_Hash_SHA3_keccak_rotc[i];
2433 uint64_t temp = state[_Y];
2434 uint64_t uu____1 = current;
2435 state[_Y] = uu____1 << r | uu____1 >> (64U - r);
2436 current = temp;
2437 }
2438 KRML_MAYBE_FOR5(i,
2439 0U,
2440 5U,
2441 1U,
2442 uint64_t v0 = state[0U + 5U * i] ^ (~state[1U + 5U * i] & state[2U + 5U * i]);
2443 uint64_t v1 = state[1U + 5U * i] ^ (~state[2U + 5U * i] & state[3U + 5U * i]);
2444 uint64_t v2 = state[2U + 5U * i] ^ (~state[3U + 5U * i] & state[4U + 5U * i]);
2445 uint64_t v3 = state[3U + 5U * i] ^ (~state[4U + 5U * i] & state[0U + 5U * i]);
2446 uint64_t v4 = state[4U + 5U * i] ^ (~state[0U + 5U * i] & state[1U + 5U * i]);
2447 state[0U + 5U * i] = v0;
2448 state[1U + 5U * i] = v1;
2449 state[2U + 5U * i] = v2;
2450 state[3U + 5U * i] = v3;
2451 state[4U + 5U * i] = v4;);
2452 uint64_t c = Hacl_Hash_SHA3_keccak_rndc[i1];
2453 state[0U] = state[0U] ^ c;
2454 }
2455 }
2456 }
2457