Debian Codegraph @

Modules/_hacl/Hacl_Hash_Blake2s.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_Blake2s.h"
27
28 #include "Hacl_Streaming_Types.h"
29 #include "Hacl_Hash_Blake2b.h"
30 #include "internal/Hacl_Streaming_Types.h"
31 #include "internal/Hacl_Impl_Blake2_Constants.h"
32 #include "internal/Hacl_Hash_Blake2b.h"
33 #include "lib_memzero0.h"
34
35 static inline void
36 update_block(
37 uint32_t *wv,
38 uint32_t *hash,
39 bool flag,
40 bool last_node,
41 uint64_t totlen,
42 uint8_t *d
43 )
44 {
45 uint32_t m_w[16U] = { 0U };
46 KRML_MAYBE_FOR16(i,
47 0U,
48 16U,
49 1U,
50 uint32_t *os = m_w;
51 uint8_t *bj = d + i * 4U;
52 uint32_t u = load32_le(bj);
53 uint32_t r = u;
54 uint32_t x = r;
55 os[i] = x;);
56 uint32_t mask[4U] = { 0U };
57 uint32_t wv_14;
58 if (flag)
59 {
60 wv_14 = 0xFFFFFFFFU;
61 }
62 else
63 {
64 wv_14 = 0U;
65 }
66 uint32_t wv_15;
67 if (last_node)
68 {
69 wv_15 = 0xFFFFFFFFU;
70 }
71 else
72 {
73 wv_15 = 0U;
74 }
75 mask[0U] = (uint32_t)totlen;
76 mask[1U] = (uint32_t)(totlen >> 32U);
77 mask[2U] = wv_14;
78 mask[3U] = wv_15;
79 memcpy(wv, hash, 16U * sizeof (uint32_t));
80 uint32_t *wv3 = wv + 12U;
81 KRML_MAYBE_FOR4(i,
82 0U,
83 4U,
84 1U,
85 uint32_t *os = wv3;
86 uint32_t x = wv3[i] ^ mask[i];
87 os[i] = x;);
88 KRML_MAYBE_FOR10(i0,
89 0U,
90 10U,
91 1U,
92 uint32_t start_idx = i0 % 10U * 16U;
93 uint32_t m_st[16U] = { 0U };
94 uint32_t *r0 = m_st;
95 uint32_t *r1 = m_st + 4U;
96 uint32_t *r20 = m_st + 8U;
97 uint32_t *r30 = m_st + 12U;
98 uint32_t s0 = Hacl_Hash_Blake2b_sigmaTable[start_idx + 0U];
99 uint32_t s1 = Hacl_Hash_Blake2b_sigmaTable[start_idx + 1U];
100 uint32_t s2 = Hacl_Hash_Blake2b_sigmaTable[start_idx + 2U];
101 uint32_t s3 = Hacl_Hash_Blake2b_sigmaTable[start_idx + 3U];
102 uint32_t s4 = Hacl_Hash_Blake2b_sigmaTable[start_idx + 4U];
103 uint32_t s5 = Hacl_Hash_Blake2b_sigmaTable[start_idx + 5U];
104 uint32_t s6 = Hacl_Hash_Blake2b_sigmaTable[start_idx + 6U];
105 uint32_t s7 = Hacl_Hash_Blake2b_sigmaTable[start_idx + 7U];
106 uint32_t s8 = Hacl_Hash_Blake2b_sigmaTable[start_idx + 8U];
107 uint32_t s9 = Hacl_Hash_Blake2b_sigmaTable[start_idx + 9U];
108 uint32_t s10 = Hacl_Hash_Blake2b_sigmaTable[start_idx + 10U];
109 uint32_t s11 = Hacl_Hash_Blake2b_sigmaTable[start_idx + 11U];
110 uint32_t s12 = Hacl_Hash_Blake2b_sigmaTable[start_idx + 12U];
111 uint32_t s13 = Hacl_Hash_Blake2b_sigmaTable[start_idx + 13U];
112 uint32_t s14 = Hacl_Hash_Blake2b_sigmaTable[start_idx + 14U];
113 uint32_t s15 = Hacl_Hash_Blake2b_sigmaTable[start_idx + 15U];
114 uint32_t uu____0 = m_w[s2];
115 uint32_t uu____1 = m_w[s4];
116 uint32_t uu____2 = m_w[s6];
117 r0[0U] = m_w[s0];
118 r0[1U] = uu____0;
119 r0[2U] = uu____1;
120 r0[3U] = uu____2;
121 uint32_t uu____3 = m_w[s3];
122 uint32_t uu____4 = m_w[s5];
123 uint32_t uu____5 = m_w[s7];
124 r1[0U] = m_w[s1];
125 r1[1U] = uu____3;
126 r1[2U] = uu____4;
127 r1[3U] = uu____5;
128 uint32_t uu____6 = m_w[s10];
129 uint32_t uu____7 = m_w[s12];
130 uint32_t uu____8 = m_w[s14];
131 r20[0U] = m_w[s8];
132 r20[1U] = uu____6;
133 r20[2U] = uu____7;
134 r20[3U] = uu____8;
135 uint32_t uu____9 = m_w[s11];
136 uint32_t uu____10 = m_w[s13];
137 uint32_t uu____11 = m_w[s15];
138 r30[0U] = m_w[s9];
139 r30[1U] = uu____9;
140 r30[2U] = uu____10;
141 r30[3U] = uu____11;
142 uint32_t *x = m_st;
143 uint32_t *y = m_st + 4U;
144 uint32_t *z = m_st + 8U;
145 uint32_t *w = m_st + 12U;
146 uint32_t a = 0U;
147 uint32_t b0 = 1U;
148 uint32_t c0 = 2U;
149 uint32_t d10 = 3U;
150 uint32_t *wv_a0 = wv + a * 4U;
151 uint32_t *wv_b0 = wv + b0 * 4U;
152 KRML_MAYBE_FOR4(i,
153 0U,
154 4U,
155 1U,
156 uint32_t *os = wv_a0;
157 uint32_t x1 = wv_a0[i] + wv_b0[i];
158 os[i] = x1;);
159 KRML_MAYBE_FOR4(i,
160 0U,
161 4U,
162 1U,
163 uint32_t *os = wv_a0;
164 uint32_t x1 = wv_a0[i] + x[i];
165 os[i] = x1;);
166 uint32_t *wv_a1 = wv + d10 * 4U;
167 uint32_t *wv_b1 = wv + a * 4U;
168 KRML_MAYBE_FOR4(i,
169 0U,
170 4U,
171 1U,
172 uint32_t *os = wv_a1;
173 uint32_t x1 = wv_a1[i] ^ wv_b1[i];
174 os[i] = x1;);
175 uint32_t *r10 = wv_a1;
176 KRML_MAYBE_FOR4(i,
177 0U,
178 4U,
179 1U,
180 uint32_t *os = r10;
181 uint32_t x1 = r10[i];
182 uint32_t x10 = x1 >> 16U | x1 << 16U;
183 os[i] = x10;);
184 uint32_t *wv_a2 = wv + c0 * 4U;
185 uint32_t *wv_b2 = wv + d10 * 4U;
186 KRML_MAYBE_FOR4(i,
187 0U,
188 4U,
189 1U,
190 uint32_t *os = wv_a2;
191 uint32_t x1 = wv_a2[i] + wv_b2[i];
192 os[i] = x1;);
193 uint32_t *wv_a3 = wv + b0 * 4U;
194 uint32_t *wv_b3 = wv + c0 * 4U;
195 KRML_MAYBE_FOR4(i,
196 0U,
197 4U,
198 1U,
199 uint32_t *os = wv_a3;
200 uint32_t x1 = wv_a3[i] ^ wv_b3[i];
201 os[i] = x1;);
202 uint32_t *r12 = wv_a3;
203 KRML_MAYBE_FOR4(i,
204 0U,
205 4U,
206 1U,
207 uint32_t *os = r12;
208 uint32_t x1 = r12[i];
209 uint32_t x10 = x1 >> 12U | x1 << 20U;
210 os[i] = x10;);
211 uint32_t *wv_a4 = wv + a * 4U;
212 uint32_t *wv_b4 = wv + b0 * 4U;
213 KRML_MAYBE_FOR4(i,
214 0U,
215 4U,
216 1U,
217 uint32_t *os = wv_a4;
218 uint32_t x1 = wv_a4[i] + wv_b4[i];
219 os[i] = x1;);
220 KRML_MAYBE_FOR4(i,
221 0U,
222 4U,
223 1U,
224 uint32_t *os = wv_a4;
225 uint32_t x1 = wv_a4[i] + y[i];
226 os[i] = x1;);
227 uint32_t *wv_a5 = wv + d10 * 4U;
228 uint32_t *wv_b5 = wv + a * 4U;
229 KRML_MAYBE_FOR4(i,
230 0U,
231 4U,
232 1U,
233 uint32_t *os = wv_a5;
234 uint32_t x1 = wv_a5[i] ^ wv_b5[i];
235 os[i] = x1;);
236 uint32_t *r13 = wv_a5;
237 KRML_MAYBE_FOR4(i,
238 0U,
239 4U,
240 1U,
241 uint32_t *os = r13;
242 uint32_t x1 = r13[i];
243 uint32_t x10 = x1 >> 8U | x1 << 24U;
244 os[i] = x10;);
245 uint32_t *wv_a6 = wv + c0 * 4U;
246 uint32_t *wv_b6 = wv + d10 * 4U;
247 KRML_MAYBE_FOR4(i,
248 0U,
249 4U,
250 1U,
251 uint32_t *os = wv_a6;
252 uint32_t x1 = wv_a6[i] + wv_b6[i];
253 os[i] = x1;);
254 uint32_t *wv_a7 = wv + b0 * 4U;
255 uint32_t *wv_b7 = wv + c0 * 4U;
256 KRML_MAYBE_FOR4(i,
257 0U,
258 4U,
259 1U,
260 uint32_t *os = wv_a7;
261 uint32_t x1 = wv_a7[i] ^ wv_b7[i];
262 os[i] = x1;);
263 uint32_t *r14 = wv_a7;
264 KRML_MAYBE_FOR4(i,
265 0U,
266 4U,
267 1U,
268 uint32_t *os = r14;
269 uint32_t x1 = r14[i];
270 uint32_t x10 = x1 >> 7U | x1 << 25U;
271 os[i] = x10;);
272 uint32_t *r15 = wv + 4U;
273 uint32_t *r21 = wv + 8U;
274 uint32_t *r31 = wv + 12U;
275 uint32_t *r110 = r15;
276 uint32_t x00 = r110[1U];
277 uint32_t x10 = r110[2U];
278 uint32_t x20 = r110[3U];
279 uint32_t x30 = r110[0U];
280 r110[0U] = x00;
281 r110[1U] = x10;
282 r110[2U] = x20;
283 r110[3U] = x30;
284 uint32_t *r111 = r21;
285 uint32_t x01 = r111[2U];
286 uint32_t x11 = r111[3U];
287 uint32_t x21 = r111[0U];
288 uint32_t x31 = r111[1U];
289 r111[0U] = x01;
290 r111[1U] = x11;
291 r111[2U] = x21;
292 r111[3U] = x31;
293 uint32_t *r112 = r31;
294 uint32_t x02 = r112[3U];
295 uint32_t x12 = r112[0U];
296 uint32_t x22 = r112[1U];
297 uint32_t x32 = r112[2U];
298 r112[0U] = x02;
299 r112[1U] = x12;
300 r112[2U] = x22;
301 r112[3U] = x32;
302 uint32_t a0 = 0U;
303 uint32_t b = 1U;
304 uint32_t c = 2U;
305 uint32_t d1 = 3U;
306 uint32_t *wv_a = wv + a0 * 4U;
307 uint32_t *wv_b8 = wv + b * 4U;
308 KRML_MAYBE_FOR4(i,
309 0U,
310 4U,
311 1U,
312 uint32_t *os = wv_a;
313 uint32_t x1 = wv_a[i] + wv_b8[i];
314 os[i] = x1;);
315 KRML_MAYBE_FOR4(i,
316 0U,
317 4U,
318 1U,
319 uint32_t *os = wv_a;
320 uint32_t x1 = wv_a[i] + z[i];
321 os[i] = x1;);
322 uint32_t *wv_a8 = wv + d1 * 4U;
323 uint32_t *wv_b9 = wv + a0 * 4U;
324 KRML_MAYBE_FOR4(i,
325 0U,
326 4U,
327 1U,
328 uint32_t *os = wv_a8;
329 uint32_t x1 = wv_a8[i] ^ wv_b9[i];
330 os[i] = x1;);
331 uint32_t *r16 = wv_a8;
332 KRML_MAYBE_FOR4(i,
333 0U,
334 4U,
335 1U,
336 uint32_t *os = r16;
337 uint32_t x1 = r16[i];
338 uint32_t x13 = x1 >> 16U | x1 << 16U;
339 os[i] = x13;);
340 uint32_t *wv_a9 = wv + c * 4U;
341 uint32_t *wv_b10 = wv + d1 * 4U;
342 KRML_MAYBE_FOR4(i,
343 0U,
344 4U,
345 1U,
346 uint32_t *os = wv_a9;
347 uint32_t x1 = wv_a9[i] + wv_b10[i];
348 os[i] = x1;);
349 uint32_t *wv_a10 = wv + b * 4U;
350 uint32_t *wv_b11 = wv + c * 4U;
351 KRML_MAYBE_FOR4(i,
352 0U,
353 4U,
354 1U,
355 uint32_t *os = wv_a10;
356 uint32_t x1 = wv_a10[i] ^ wv_b11[i];
357 os[i] = x1;);
358 uint32_t *r17 = wv_a10;
359 KRML_MAYBE_FOR4(i,
360 0U,
361 4U,
362 1U,
363 uint32_t *os = r17;
364 uint32_t x1 = r17[i];
365 uint32_t x13 = x1 >> 12U | x1 << 20U;
366 os[i] = x13;);
367 uint32_t *wv_a11 = wv + a0 * 4U;
368 uint32_t *wv_b12 = wv + b * 4U;
369 KRML_MAYBE_FOR4(i,
370 0U,
371 4U,
372 1U,
373 uint32_t *os = wv_a11;
374 uint32_t x1 = wv_a11[i] + wv_b12[i];
375 os[i] = x1;);
376 KRML_MAYBE_FOR4(i,
377 0U,
378 4U,
379 1U,
380 uint32_t *os = wv_a11;
381 uint32_t x1 = wv_a11[i] + w[i];
382 os[i] = x1;);
383 uint32_t *wv_a12 = wv + d1 * 4U;
384 uint32_t *wv_b13 = wv + a0 * 4U;
385 KRML_MAYBE_FOR4(i,
386 0U,
387 4U,
388 1U,
389 uint32_t *os = wv_a12;
390 uint32_t x1 = wv_a12[i] ^ wv_b13[i];
391 os[i] = x1;);
392 uint32_t *r18 = wv_a12;
393 KRML_MAYBE_FOR4(i,
394 0U,
395 4U,
396 1U,
397 uint32_t *os = r18;
398 uint32_t x1 = r18[i];
399 uint32_t x13 = x1 >> 8U | x1 << 24U;
400 os[i] = x13;);
401 uint32_t *wv_a13 = wv + c * 4U;
402 uint32_t *wv_b14 = wv + d1 * 4U;
403 KRML_MAYBE_FOR4(i,
404 0U,
405 4U,
406 1U,
407 uint32_t *os = wv_a13;
408 uint32_t x1 = wv_a13[i] + wv_b14[i];
409 os[i] = x1;);
410 uint32_t *wv_a14 = wv + b * 4U;
411 uint32_t *wv_b = wv + c * 4U;
412 KRML_MAYBE_FOR4(i,
413 0U,
414 4U,
415 1U,
416 uint32_t *os = wv_a14;
417 uint32_t x1 = wv_a14[i] ^ wv_b[i];
418 os[i] = x1;);
419 uint32_t *r19 = wv_a14;
420 KRML_MAYBE_FOR4(i,
421 0U,
422 4U,
423 1U,
424 uint32_t *os = r19;
425 uint32_t x1 = r19[i];
426 uint32_t x13 = x1 >> 7U | x1 << 25U;
427 os[i] = x13;);
428 uint32_t *r113 = wv + 4U;
429 uint32_t *r2 = wv + 8U;
430 uint32_t *r3 = wv + 12U;
431 uint32_t *r11 = r113;
432 uint32_t x03 = r11[3U];
433 uint32_t x13 = r11[0U];
434 uint32_t x23 = r11[1U];
435 uint32_t x33 = r11[2U];
436 r11[0U] = x03;
437 r11[1U] = x13;
438 r11[2U] = x23;
439 r11[3U] = x33;
440 uint32_t *r114 = r2;
441 uint32_t x04 = r114[2U];
442 uint32_t x14 = r114[3U];
443 uint32_t x24 = r114[0U];
444 uint32_t x34 = r114[1U];
445 r114[0U] = x04;
446 r114[1U] = x14;
447 r114[2U] = x24;
448 r114[3U] = x34;
449 uint32_t *r115 = r3;
450 uint32_t x0 = r115[1U];
451 uint32_t x1 = r115[2U];
452 uint32_t x2 = r115[3U];
453 uint32_t x3 = r115[0U];
454 r115[0U] = x0;
455 r115[1U] = x1;
456 r115[2U] = x2;
457 r115[3U] = x3;);
458 uint32_t *s0 = hash;
459 uint32_t *s1 = hash + 4U;
460 uint32_t *r0 = wv;
461 uint32_t *r1 = wv + 4U;
462 uint32_t *r2 = wv + 8U;
463 uint32_t *r3 = wv + 12U;
464 KRML_MAYBE_FOR4(i,
465 0U,
466 4U,
467 1U,
468 uint32_t *os = s0;
469 uint32_t x = s0[i] ^ r0[i];
470 os[i] = x;);
471 KRML_MAYBE_FOR4(i,
472 0U,
473 4U,
474 1U,
475 uint32_t *os = s0;
476 uint32_t x = s0[i] ^ r2[i];
477 os[i] = x;);
478 KRML_MAYBE_FOR4(i,
479 0U,
480 4U,
481 1U,
482 uint32_t *os = s1;
483 uint32_t x = s1[i] ^ r1[i];
484 os[i] = x;);
485 KRML_MAYBE_FOR4(i,
486 0U,
487 4U,
488 1U,
489 uint32_t *os = s1;
490 uint32_t x = s1[i] ^ r3[i];
491 os[i] = x;);
492 }
493
494 void Hacl_Hash_Blake2s_init(uint32_t *hash, uint32_t kk, uint32_t nn)
495 {
496 uint8_t salt[8U] = { 0U };
497 uint8_t personal[8U] = { 0U };
498 Hacl_Hash_Blake2b_blake2_params
499 p =
500 {
501 .digest_length = 32U, .key_length = 0U, .fanout = 1U, .depth = 1U, .leaf_length = 0U,
502 .node_offset = 0ULL, .node_depth = 0U, .inner_length = 0U, .salt = salt, .personal = personal
503 };
504 uint32_t tmp[8U] = { 0U };
505 uint32_t *r0 = hash;
506 uint32_t *r1 = hash + 4U;
507 uint32_t *r2 = hash + 8U;
508 uint32_t *r3 = hash + 12U;
509 uint32_t iv0 = Hacl_Hash_Blake2b_ivTable_S[0U];
510 uint32_t iv1 = Hacl_Hash_Blake2b_ivTable_S[1U];
511 uint32_t iv2 = Hacl_Hash_Blake2b_ivTable_S[2U];
512 uint32_t iv3 = Hacl_Hash_Blake2b_ivTable_S[3U];
513 uint32_t iv4 = Hacl_Hash_Blake2b_ivTable_S[4U];
514 uint32_t iv5 = Hacl_Hash_Blake2b_ivTable_S[5U];
515 uint32_t iv6 = Hacl_Hash_Blake2b_ivTable_S[6U];
516 uint32_t iv7 = Hacl_Hash_Blake2b_ivTable_S[7U];
517 r2[0U] = iv0;
518 r2[1U] = iv1;
519 r2[2U] = iv2;
520 r2[3U] = iv3;
521 r3[0U] = iv4;
522 r3[1U] = iv5;
523 r3[2U] = iv6;
524 r3[3U] = iv7;
525 KRML_MAYBE_FOR2(i,
526 0U,
527 2U,
528 1U,
529 uint32_t *os = tmp + 4U;
530 uint8_t *bj = p.salt + i * 4U;
531 uint32_t u = load32_le(bj);
532 uint32_t r = u;
533 uint32_t x = r;
534 os[i] = x;);
535 KRML_MAYBE_FOR2(i,
536 0U,
537 2U,
538 1U,
539 uint32_t *os = tmp + 6U;
540 uint8_t *bj = p.personal + i * 4U;
541 uint32_t u = load32_le(bj);
542 uint32_t r = u;
543 uint32_t x = r;
544 os[i] = x;);
545 tmp[0U] =
546 (uint32_t)(uint8_t)nn ^
547 ((uint32_t)(uint8_t)kk << 8U ^ ((uint32_t)p.fanout << 16U ^ (uint32_t)p.depth << 24U));
548 tmp[1U] = p.leaf_length;
549 tmp[2U] = (uint32_t)p.node_offset;
550 tmp[3U] =
551 (uint32_t)(p.node_offset >> 32U) ^
552 ((uint32_t)p.node_depth << 16U ^ (uint32_t)p.inner_length << 24U);
553 uint32_t tmp0 = tmp[0U];
554 uint32_t tmp1 = tmp[1U];
555 uint32_t tmp2 = tmp[2U];
556 uint32_t tmp3 = tmp[3U];
557 uint32_t tmp4 = tmp[4U];
558 uint32_t tmp5 = tmp[5U];
559 uint32_t tmp6 = tmp[6U];
560 uint32_t tmp7 = tmp[7U];
561 uint32_t iv0_ = iv0 ^ tmp0;
562 uint32_t iv1_ = iv1 ^ tmp1;
563 uint32_t iv2_ = iv2 ^ tmp2;
564 uint32_t iv3_ = iv3 ^ tmp3;
565 uint32_t iv4_ = iv4 ^ tmp4;
566 uint32_t iv5_ = iv5 ^ tmp5;
567 uint32_t iv6_ = iv6 ^ tmp6;
568 uint32_t iv7_ = iv7 ^ tmp7;
569 r0[0U] = iv0_;
570 r0[1U] = iv1_;
571 r0[2U] = iv2_;
572 r0[3U] = iv3_;
573 r1[0U] = iv4_;
574 r1[1U] = iv5_;
575 r1[2U] = iv6_;
576 r1[3U] = iv7_;
577 }
578
579 static void update_key(uint32_t *wv, uint32_t *hash, uint32_t kk, uint8_t *k, uint32_t ll)
580 {
581 uint64_t lb = (uint64_t)64U;
582 uint8_t b[64U] = { 0U };
583 memcpy(b, k, kk * sizeof (uint8_t));
584 if (ll == 0U)
585 {
586 update_block(wv, hash, true, false, lb, b);
587 }
588 else
589 {
590 update_block(wv, hash, false, false, lb, b);
591 }
592 Lib_Memzero0_memzero(b, 64U, uint8_t, void *);
593 }
594
595 void
596 Hacl_Hash_Blake2s_update_multi(
597 uint32_t len,
598 uint32_t *wv,
599 uint32_t *hash,
600 uint64_t prev,
601 uint8_t *blocks,
602 uint32_t nb
603 )
604 {
605 KRML_MAYBE_UNUSED_VAR(len);
606 for (uint32_t i = 0U; i < nb; i++)
607 {
608 uint64_t totlen = prev + (uint64_t)((i + 1U) * 64U);
609 uint8_t *b = blocks + i * 64U;
610 update_block(wv, hash, false, false, totlen, b);
611 }
612 }
613
614 void
615 Hacl_Hash_Blake2s_update_last(
616 uint32_t len,
617 uint32_t *wv,
618 uint32_t *hash,
619 bool last_node,
620 uint64_t prev,
621 uint32_t rem,
622 uint8_t *d
623 )
624 {
625 uint8_t b[64U] = { 0U };
626 uint8_t *last = d + len - rem;
627 memcpy(b, last, rem * sizeof (uint8_t));
628 uint64_t totlen = prev + (uint64_t)len;
629 update_block(wv, hash, true, last_node, totlen, b);
630 Lib_Memzero0_memzero(b, 64U, uint8_t, void *);
631 }
632
633 static void
634 update_blocks(uint32_t len, uint32_t *wv, uint32_t *hash, uint64_t prev, uint8_t *blocks)
635 {
636 uint32_t nb0 = len / 64U;
637 uint32_t rem0 = len % 64U;
638 uint32_t nb;
639 if (rem0 == 0U && nb0 > 0U)
640 {
641 nb = nb0 - 1U;
642 }
643 else
644 {
645 nb = nb0;
646 }
647 uint32_t rem;
648 if (rem0 == 0U && nb0 > 0U)
649 {
650 rem = 64U;
651 }
652 else
653 {
654 rem = rem0;
655 }
656 Hacl_Hash_Blake2s_update_multi(len, wv, hash, prev, blocks, nb);
657 Hacl_Hash_Blake2s_update_last(len, wv, hash, false, prev, rem, blocks);
658 }
659
660 static inline void
661 update(uint32_t *wv, uint32_t *hash, uint32_t kk, uint8_t *k, uint32_t ll, uint8_t *d)
662 {
663 uint64_t lb = (uint64_t)64U;
664 if (kk > 0U)
665 {
666 update_key(wv, hash, kk, k, ll);
667 if (!(ll == 0U))
668 {
669 update_blocks(ll, wv, hash, lb, d);
670 return;
671 }
672 return;
673 }
674 update_blocks(ll, wv, hash, (uint64_t)0U, d);
675 }
676
677 void Hacl_Hash_Blake2s_finish(uint32_t nn, uint8_t *output, uint32_t *hash)
678 {
679 uint8_t b[32U] = { 0U };
680 uint8_t *first = b;
681 uint8_t *second = b + 16U;
682 uint32_t *row0 = hash;
683 uint32_t *row1 = hash + 4U;
684 KRML_MAYBE_FOR4(i, 0U, 4U, 1U, store32_le(first + i * 4U, row0[i]););
685 KRML_MAYBE_FOR4(i, 0U, 4U, 1U, store32_le(second + i * 4U, row1[i]););
686 uint8_t *final = b;
687 memcpy(output, final, nn * sizeof (uint8_t));
688 Lib_Memzero0_memzero(b, 32U, uint8_t, void *);
689 }
690
691 typedef struct option___uint8_t___uint8_t___bool_____uint32_t_____uint32_t____s
692 {
693 Hacl_Streaming_Types_optional tag;
694 Hacl_Hash_Blake2s_block_state_t v;
695 }
696 option___uint8_t___uint8_t___bool_____uint32_t_____uint32_t___;
697
698 static Hacl_Hash_Blake2s_state_t
699 *malloc_raw(Hacl_Hash_Blake2b_index kk, Hacl_Hash_Blake2b_params_and_key key)
700 {
701 uint8_t *buf = (uint8_t *)KRML_HOST_CALLOC(64U, sizeof (uint8_t));
702 if (buf == NULL)
703 {
704 return NULL;
705 }
706 uint8_t *buf1 = buf;
707 uint32_t *wv0 = (uint32_t *)KRML_HOST_CALLOC(16U, sizeof (uint32_t));
708 option___uint8_t___uint8_t___bool_____uint32_t_____uint32_t___ block_state;
709 if (wv0 == NULL)
710 {
711 block_state =
712 (
713 (option___uint8_t___uint8_t___bool_____uint32_t_____uint32_t___){
714 .tag = Hacl_Streaming_Types_None
715 }
716 );
717 }
718 else
719 {
720 uint32_t *b = (uint32_t *)KRML_HOST_CALLOC(16U, sizeof (uint32_t));
721 if (b == NULL)
722 {
723 KRML_HOST_FREE(wv0);
724 block_state =
725 (
726 (option___uint8_t___uint8_t___bool_____uint32_t_____uint32_t___){
727 .tag = Hacl_Streaming_Types_None
728 }
729 );
730 }
731 else
732 {
733 block_state =
734 (
735 (option___uint8_t___uint8_t___bool_____uint32_t_____uint32_t___){
736 .tag = Hacl_Streaming_Types_Some,
737 .v = {
738 .fst = kk.key_length,
739 .snd = kk.digest_length,
740 .thd = kk.last_node,
741 .f3 = { .fst = wv0, .snd = b }
742 }
743 }
744 );
745 }
746 }
747 if (block_state.tag == Hacl_Streaming_Types_None)
748 {
749 KRML_HOST_FREE(buf1);
750 return NULL;
751 }
752 if (block_state.tag == Hacl_Streaming_Types_Some)
753 {
754 Hacl_Hash_Blake2s_block_state_t block_state1 = block_state.v;
755 Hacl_Streaming_Types_optional k_ = Hacl_Streaming_Types_Some;
756 switch (k_)
757 {
758 case Hacl_Streaming_Types_None:
759 {
760 return NULL;
761 }
762 case Hacl_Streaming_Types_Some:
763 {
764 uint8_t kk10 = kk.key_length;
765 uint32_t ite;
766 if (kk10 != 0U)
767 {
768 ite = 64U;
769 }
770 else
771 {
772 ite = 0U;
773 }
774 Hacl_Hash_Blake2s_state_t
775 s = { .block_state = block_state1, .buf = buf1, .total_len = (uint64_t)ite };
776 Hacl_Hash_Blake2s_state_t
777 *p = (Hacl_Hash_Blake2s_state_t *)KRML_HOST_MALLOC(sizeof (Hacl_Hash_Blake2s_state_t));
778 if (p != NULL)
779 {
780 p[0U] = s;
781 }
782 if (p == NULL)
783 {
784 uint32_t *b = block_state1.f3.snd;
785 uint32_t *wv = block_state1.f3.fst;
786 KRML_HOST_FREE(wv);
787 KRML_HOST_FREE(b);
788 KRML_HOST_FREE(buf1);
789 return NULL;
790 }
791 Hacl_Hash_Blake2b_blake2_params *p1 = key.fst;
792 uint8_t kk1 = p1->key_length;
793 uint8_t nn = p1->digest_length;
794 bool last_node = block_state1.thd;
795 Hacl_Hash_Blake2b_index
796 i = { .key_length = kk1, .digest_length = nn, .last_node = last_node };
797 uint32_t *h = block_state1.f3.snd;
798 uint32_t kk2 = (uint32_t)i.key_length;
799 uint8_t *k_2 = key.snd;
800 if (!(kk2 == 0U))
801 {
802 uint8_t *sub_b = buf1 + kk2;
803 memset(sub_b, 0U, (64U - kk2) * sizeof (uint8_t));
804 memcpy(buf1, k_2, kk2 * sizeof (uint8_t));
805 }
806 Hacl_Hash_Blake2b_blake2_params pv = p1[0U];
807 uint32_t tmp[8U] = { 0U };
808 uint32_t *r0 = h;
809 uint32_t *r1 = h + 4U;
810 uint32_t *r2 = h + 8U;
811 uint32_t *r3 = h + 12U;
812 uint32_t iv0 = Hacl_Hash_Blake2b_ivTable_S[0U];
813 uint32_t iv1 = Hacl_Hash_Blake2b_ivTable_S[1U];
814 uint32_t iv2 = Hacl_Hash_Blake2b_ivTable_S[2U];
815 uint32_t iv3 = Hacl_Hash_Blake2b_ivTable_S[3U];
816 uint32_t iv4 = Hacl_Hash_Blake2b_ivTable_S[4U];
817 uint32_t iv5 = Hacl_Hash_Blake2b_ivTable_S[5U];
818 uint32_t iv6 = Hacl_Hash_Blake2b_ivTable_S[6U];
819 uint32_t iv7 = Hacl_Hash_Blake2b_ivTable_S[7U];
820 r2[0U] = iv0;
821 r2[1U] = iv1;
822 r2[2U] = iv2;
823 r2[3U] = iv3;
824 r3[0U] = iv4;
825 r3[1U] = iv5;
826 r3[2U] = iv6;
827 r3[3U] = iv7;
828 KRML_MAYBE_FOR2(i0,
829 0U,
830 2U,
831 1U,
832 uint32_t *os = tmp + 4U;
833 uint8_t *bj = pv.salt + i0 * 4U;
834 uint32_t u = load32_le(bj);
835 uint32_t r4 = u;
836 uint32_t x = r4;
837 os[i0] = x;);
838 KRML_MAYBE_FOR2(i0,
839 0U,
840 2U,
841 1U,
842 uint32_t *os = tmp + 6U;
843 uint8_t *bj = pv.personal + i0 * 4U;
844 uint32_t u = load32_le(bj);
845 uint32_t r4 = u;
846 uint32_t x = r4;
847 os[i0] = x;);
848 tmp[0U] =
849 (uint32_t)pv.digest_length ^
850 ((uint32_t)pv.key_length << 8U ^
851 ((uint32_t)pv.fanout << 16U ^ (uint32_t)pv.depth << 24U));
852 tmp[1U] = pv.leaf_length;
853 tmp[2U] = (uint32_t)pv.node_offset;
854 tmp[3U] =
855 (uint32_t)(pv.node_offset >> 32U) ^
856 ((uint32_t)pv.node_depth << 16U ^ (uint32_t)pv.inner_length << 24U);
857 uint32_t tmp0 = tmp[0U];
858 uint32_t tmp1 = tmp[1U];
859 uint32_t tmp2 = tmp[2U];
860 uint32_t tmp3 = tmp[3U];
861 uint32_t tmp4 = tmp[4U];
862 uint32_t tmp5 = tmp[5U];
863 uint32_t tmp6 = tmp[6U];
864 uint32_t tmp7 = tmp[7U];
865 uint32_t iv0_ = iv0 ^ tmp0;
866 uint32_t iv1_ = iv1 ^ tmp1;
867 uint32_t iv2_ = iv2 ^ tmp2;
868 uint32_t iv3_ = iv3 ^ tmp3;
869 uint32_t iv4_ = iv4 ^ tmp4;
870 uint32_t iv5_ = iv5 ^ tmp5;
871 uint32_t iv6_ = iv6 ^ tmp6;
872 uint32_t iv7_ = iv7 ^ tmp7;
873 r0[0U] = iv0_;
874 r0[1U] = iv1_;
875 r0[2U] = iv2_;
876 r0[3U] = iv3_;
877 r1[0U] = iv4_;
878 r1[1U] = iv5_;
879 r1[2U] = iv6_;
880 r1[3U] = iv7_;
881 return p;
882 }
883 default:
884 {
885 KRML_HOST_EPRINTF("KaRaMeL incomplete match at %s:%d\n", __FILE__, __LINE__);
886 KRML_HOST_EXIT(253U);
887 }
888 }
889 }
890 KRML_HOST_EPRINTF("KaRaMeL abort at %s:%d\n%s\n",
891 __FILE__,
892 __LINE__,
893 "unreachable (pattern matches are exhaustive in F*)");
894 KRML_HOST_EXIT(255U);
895 }
896
897 /**
898 General-purpose allocation function that gives control over all
899 Blake2 parameters, including the key. Further resettings of the state SHALL be
900 done with `reset_with_params_and_key`, and SHALL feature the exact same values
901 for the `key_length` and `digest_length` fields as passed here. In other words,
902 once you commit to a digest and key length, the only way to change these
903 parameters is to allocate a new object.
904
905 The caller must satisfy the following requirements.
906 - The length of the key k MUST match the value of the field key_length in the
907 parameters.
908 - The key_length must not exceed 32 for S, 64 for B.
909 - The digest_length must not exceed 32 for S, 64 for B.
910
911 */
912 Hacl_Hash_Blake2s_state_t
913 *Hacl_Hash_Blake2s_malloc_with_params_and_key(
914 Hacl_Hash_Blake2b_blake2_params *p,
915 bool last_node,
916 uint8_t *k
917 )
918 {
919 Hacl_Hash_Blake2b_blake2_params pv = p[0U];
920 Hacl_Hash_Blake2b_index
921 i1 = { .key_length = pv.key_length, .digest_length = pv.digest_length, .last_node = last_node };
922 return malloc_raw(i1, ((Hacl_Hash_Blake2b_params_and_key){ .fst = p, .snd = k }));
923 }
924
925 /**
926 Specialized allocation function that picks default values for all
927 parameters, except for the key_length. Further resettings of the state SHALL be
928 done with `reset_with_key`, and SHALL feature the exact same key length `kk` as
929 passed here. In other words, once you commit to a key length, the only way to
930 change this parameter is to allocate a new object.
931
932 The caller must satisfy the following requirements.
933 - The key_length must not exceed 32 for S, 64 for B.
934
935 */
936 Hacl_Hash_Blake2s_state_t *Hacl_Hash_Blake2s_malloc_with_key(uint8_t *k, uint8_t kk)
937 {
938 uint8_t nn = 32U;
939 Hacl_Hash_Blake2b_index i = { .key_length = kk, .digest_length = nn, .last_node = false };
940 uint8_t salt[8U] = { 0U };
941 uint8_t personal[8U] = { 0U };
942 Hacl_Hash_Blake2b_blake2_params
943 p =
944 {
945 .digest_length = i.digest_length, .key_length = i.key_length, .fanout = 1U, .depth = 1U,
946 .leaf_length = 0U, .node_offset = 0ULL, .node_depth = 0U, .inner_length = 0U, .salt = salt,
947 .personal = personal
948 };
949 Hacl_Hash_Blake2b_blake2_params p0 = p;
950 Hacl_Hash_Blake2s_state_t *s = Hacl_Hash_Blake2s_malloc_with_params_and_key(&p0, false, k);
951 return s;
952 }
953
954 /**
955 Specialized allocation function that picks default values for all
956 parameters, and has no key. Effectively, this is what you want if you intend to
957 use Blake2 as a hash function. Further resettings of the state SHALL be done with `reset`.
958 */
959 Hacl_Hash_Blake2s_state_t *Hacl_Hash_Blake2s_malloc(void)
960 {
961 return Hacl_Hash_Blake2s_malloc_with_key(NULL, 0U);
962 }
963
964 static Hacl_Hash_Blake2b_index index_of_state(Hacl_Hash_Blake2s_state_t *s)
965 {
966 Hacl_Hash_Blake2s_block_state_t block_state = (*s).block_state;
967 bool last_node = block_state.thd;
968 uint8_t nn = block_state.snd;
969 uint8_t kk1 = block_state.fst;
970 return
971 ((Hacl_Hash_Blake2b_index){ .key_length = kk1, .digest_length = nn, .last_node = last_node });
972 }
973
974 static void reset_raw(Hacl_Hash_Blake2s_state_t *state, Hacl_Hash_Blake2b_params_and_key key)
975 {
976 Hacl_Hash_Blake2s_state_t scrut = *state;
977 uint8_t *buf = scrut.buf;
978 Hacl_Hash_Blake2s_block_state_t block_state = scrut.block_state;
979 bool last_node0 = block_state.thd;
980 uint8_t nn0 = block_state.snd;
981 uint8_t kk10 = block_state.fst;
982 Hacl_Hash_Blake2b_index
983 i = { .key_length = kk10, .digest_length = nn0, .last_node = last_node0 };
984 KRML_MAYBE_UNUSED_VAR(i);
985 Hacl_Hash_Blake2b_blake2_params *p = key.fst;
986 uint8_t kk1 = p->key_length;
987 uint8_t nn = p->digest_length;
988 bool last_node = block_state.thd;
989 Hacl_Hash_Blake2b_index
990 i1 = { .key_length = kk1, .digest_length = nn, .last_node = last_node };
991 uint32_t *h = block_state.f3.snd;
992 uint32_t kk2 = (uint32_t)i1.key_length;
993 uint8_t *k_1 = key.snd;
994 if (!(kk2 == 0U))
995 {
996 uint8_t *sub_b = buf + kk2;
997 memset(sub_b, 0U, (64U - kk2) * sizeof (uint8_t));
998 memcpy(buf, k_1, kk2 * sizeof (uint8_t));
999 }
1000 Hacl_Hash_Blake2b_blake2_params pv = p[0U];
1001 uint32_t tmp[8U] = { 0U };
1002 uint32_t *r0 = h;
1003 uint32_t *r1 = h + 4U;
1004 uint32_t *r2 = h + 8U;
1005 uint32_t *r3 = h + 12U;
1006 uint32_t iv0 = Hacl_Hash_Blake2b_ivTable_S[0U];
1007 uint32_t iv1 = Hacl_Hash_Blake2b_ivTable_S[1U];
1008 uint32_t iv2 = Hacl_Hash_Blake2b_ivTable_S[2U];
1009 uint32_t iv3 = Hacl_Hash_Blake2b_ivTable_S[3U];
1010 uint32_t iv4 = Hacl_Hash_Blake2b_ivTable_S[4U];
1011 uint32_t iv5 = Hacl_Hash_Blake2b_ivTable_S[5U];
1012 uint32_t iv6 = Hacl_Hash_Blake2b_ivTable_S[6U];
1013 uint32_t iv7 = Hacl_Hash_Blake2b_ivTable_S[7U];
1014 r2[0U] = iv0;
1015 r2[1U] = iv1;
1016 r2[2U] = iv2;
1017 r2[3U] = iv3;
1018 r3[0U] = iv4;
1019 r3[1U] = iv5;
1020 r3[2U] = iv6;
1021 r3[3U] = iv7;
1022 KRML_MAYBE_FOR2(i0,
1023 0U,
1024 2U,
1025 1U,
1026 uint32_t *os = tmp + 4U;
1027 uint8_t *bj = pv.salt + i0 * 4U;
1028 uint32_t u = load32_le(bj);
1029 uint32_t r = u;
1030 uint32_t x = r;
1031 os[i0] = x;);
1032 KRML_MAYBE_FOR2(i0,
1033 0U,
1034 2U,
1035 1U,
1036 uint32_t *os = tmp + 6U;
1037 uint8_t *bj = pv.personal + i0 * 4U;
1038 uint32_t u = load32_le(bj);
1039 uint32_t r = u;
1040 uint32_t x = r;
1041 os[i0] = x;);
1042 tmp[0U] =
1043 (uint32_t)pv.digest_length ^
1044 ((uint32_t)pv.key_length << 8U ^ ((uint32_t)pv.fanout << 16U ^ (uint32_t)pv.depth << 24U));
1045 tmp[1U] = pv.leaf_length;
1046 tmp[2U] = (uint32_t)pv.node_offset;
1047 tmp[3U] =
1048 (uint32_t)(pv.node_offset >> 32U) ^
1049 ((uint32_t)pv.node_depth << 16U ^ (uint32_t)pv.inner_length << 24U);
1050 uint32_t tmp0 = tmp[0U];
1051 uint32_t tmp1 = tmp[1U];
1052 uint32_t tmp2 = tmp[2U];
1053 uint32_t tmp3 = tmp[3U];
1054 uint32_t tmp4 = tmp[4U];
1055 uint32_t tmp5 = tmp[5U];
1056 uint32_t tmp6 = tmp[6U];
1057 uint32_t tmp7 = tmp[7U];
1058 uint32_t iv0_ = iv0 ^ tmp0;
1059 uint32_t iv1_ = iv1 ^ tmp1;
1060 uint32_t iv2_ = iv2 ^ tmp2;
1061 uint32_t iv3_ = iv3 ^ tmp3;
1062 uint32_t iv4_ = iv4 ^ tmp4;
1063 uint32_t iv5_ = iv5 ^ tmp5;
1064 uint32_t iv6_ = iv6 ^ tmp6;
1065 uint32_t iv7_ = iv7 ^ tmp7;
1066 r0[0U] = iv0_;
1067 r0[1U] = iv1_;
1068 r0[2U] = iv2_;
1069 r0[3U] = iv3_;
1070 r1[0U] = iv4_;
1071 r1[1U] = iv5_;
1072 r1[2U] = iv6_;
1073 r1[3U] = iv7_;
1074 uint8_t kk11 = i.key_length;
1075 uint32_t ite;
1076 if (kk11 != 0U)
1077 {
1078 ite = 64U;
1079 }
1080 else
1081 {
1082 ite = 0U;
1083 }
1084 Hacl_Hash_Blake2s_state_t
1085 tmp8 = { .block_state = block_state, .buf = buf, .total_len = (uint64_t)ite };
1086 state[0U] = tmp8;
1087 }
1088
1089 /**
1090 General-purpose re-initialization function with parameters and
1091 key. You cannot change digest_length, key_length, or last_node, meaning those values in
1092 the parameters object must be the same as originally decided via one of the
1093 malloc functions. All other values of the parameter can be changed. The behavior
1094 is unspecified if you violate this precondition.
1095 */
1096 void
1097 Hacl_Hash_Blake2s_reset_with_key_and_params(
1098 Hacl_Hash_Blake2s_state_t *s,
1099 Hacl_Hash_Blake2b_blake2_params *p,
1100 uint8_t *k
1101 )
1102 {
1103 Hacl_Hash_Blake2b_index i1 = index_of_state(s);
1104 KRML_MAYBE_UNUSED_VAR(i1);
1105 reset_raw(s, ((Hacl_Hash_Blake2b_params_and_key){ .fst = p, .snd = k }));
1106 }
1107
1108 /**
1109 Specialized-purpose re-initialization function with no parameters,
1110 and a key. The key length must be the same as originally decided via your choice
1111 of malloc function. All other parameters are reset to their default values. The
1112 original call to malloc MUST have set digest_length to the default value. The
1113 behavior is unspecified if you violate this precondition.
1114 */
1115 void Hacl_Hash_Blake2s_reset_with_key(Hacl_Hash_Blake2s_state_t *s, uint8_t *k)
1116 {
1117 Hacl_Hash_Blake2b_index idx = index_of_state(s);
1118 uint8_t salt[8U] = { 0U };
1119 uint8_t personal[8U] = { 0U };
1120 Hacl_Hash_Blake2b_blake2_params
1121 p =
1122 {
1123 .digest_length = idx.digest_length, .key_length = idx.key_length, .fanout = 1U, .depth = 1U,
1124 .leaf_length = 0U, .node_offset = 0ULL, .node_depth = 0U, .inner_length = 0U, .salt = salt,
1125 .personal = personal
1126 };
1127 Hacl_Hash_Blake2b_blake2_params p0 = p;
1128 reset_raw(s, ((Hacl_Hash_Blake2b_params_and_key){ .fst = &p0, .snd = k }));
1129 }
1130
1131 /**
1132 Specialized-purpose re-initialization function with no parameters
1133 and no key. This is what you want if you intend to use Blake2 as a hash
1134 function. The key length and digest length must have been set to their
1135 respective default values via your choice of malloc function (always true if you
1136 used `malloc`). All other parameters are reset to their default values. The
1137 behavior is unspecified if you violate this precondition.
1138 */
1139 void Hacl_Hash_Blake2s_reset(Hacl_Hash_Blake2s_state_t *s)
1140 {
1141 Hacl_Hash_Blake2s_reset_with_key(s, NULL);
1142 }
1143
1144 /**
1145 Update function; 0 = success, 1 = max length exceeded
1146 */
1147 Hacl_Streaming_Types_error_code
1148 Hacl_Hash_Blake2s_update(Hacl_Hash_Blake2s_state_t *state, uint8_t *chunk, uint32_t chunk_len)
1149 {
1150 Hacl_Hash_Blake2s_state_t s = *state;
1151 uint64_t total_len = s.total_len;
1152 if ((uint64_t)chunk_len > 0xffffffffffffffffULL - total_len)
1153 {
1154 return Hacl_Streaming_Types_MaximumLengthExceeded;
1155 }
1156 uint32_t sz;
1157 if (total_len % (uint64_t)64U == 0ULL && total_len > 0ULL)
1158 {
1159 sz = 64U;
1160 }
1161 else
1162 {
1163 sz = (uint32_t)(total_len % (uint64_t)64U);
1164 }
1165 if (chunk_len <= 64U - sz)
1166 {
1167 Hacl_Hash_Blake2s_state_t s1 = *state;
1168 Hacl_Hash_Blake2s_block_state_t block_state1 = s1.block_state;
1169 uint8_t *buf = s1.buf;
1170 uint64_t total_len1 = s1.total_len;
1171 uint32_t sz1;
1172 if (total_len1 % (uint64_t)64U == 0ULL && total_len1 > 0ULL)
1173 {
1174 sz1 = 64U;
1175 }
1176 else
1177 {
1178 sz1 = (uint32_t)(total_len1 % (uint64_t)64U);
1179 }
1180 uint8_t *buf2 = buf + sz1;
1181 memcpy(buf2, chunk, chunk_len * sizeof (uint8_t));
1182 uint64_t total_len2 = total_len1 + (uint64_t)chunk_len;
1183 *state =
1184 (
1185 (Hacl_Hash_Blake2s_state_t){
1186 .block_state = block_state1,
1187 .buf = buf,
1188 .total_len = total_len2
1189 }
1190 );
1191 }
1192 else if (sz == 0U)
1193 {
1194 Hacl_Hash_Blake2s_state_t s1 = *state;
1195 Hacl_Hash_Blake2s_block_state_t block_state1 = s1.block_state;
1196 uint8_t *buf = s1.buf;
1197 uint64_t total_len1 = s1.total_len;
1198 uint32_t sz1;
1199 if (total_len1 % (uint64_t)64U == 0ULL && total_len1 > 0ULL)
1200 {
1201 sz1 = 64U;
1202 }
1203 else
1204 {
1205 sz1 = (uint32_t)(total_len1 % (uint64_t)64U);
1206 }
1207 if (!(sz1 == 0U))
1208 {
1209 uint64_t prevlen = total_len1 - (uint64_t)sz1;
1210 K____uint32_t___uint32_t_ acc = block_state1.f3;
1211 uint32_t *wv = acc.fst;
1212 uint32_t *hash = acc.snd;
1213 uint32_t nb = 1U;
1214 Hacl_Hash_Blake2s_update_multi(64U, wv, hash, prevlen, buf, nb);
1215 }
1216 uint32_t ite;
1217 if ((uint64_t)chunk_len % (uint64_t)64U == 0ULL && (uint64_t)chunk_len > 0ULL)
1218 {
1219 ite = 64U;
1220 }
1221 else
1222 {
1223 ite = (uint32_t)((uint64_t)chunk_len % (uint64_t)64U);
1224 }
1225 uint32_t n_blocks = (chunk_len - ite) / 64U;
1226 uint32_t data1_len = n_blocks * 64U;
1227 uint32_t data2_len = chunk_len - data1_len;
1228 uint8_t *data1 = chunk;
1229 uint8_t *data2 = chunk + data1_len;
1230 K____uint32_t___uint32_t_ acc = block_state1.f3;
1231 uint32_t *wv = acc.fst;
1232 uint32_t *hash = acc.snd;
1233 uint32_t nb = data1_len / 64U;
1234 Hacl_Hash_Blake2s_update_multi(data1_len, wv, hash, total_len1, data1, nb);
1235 uint8_t *dst = buf;
1236 memcpy(dst, data2, data2_len * sizeof (uint8_t));
1237 *state =
1238 (
1239 (Hacl_Hash_Blake2s_state_t){
1240 .block_state = block_state1,
1241 .buf = buf,
1242 .total_len = total_len1 + (uint64_t)chunk_len
1243 }
1244 );
1245 }
1246 else
1247 {
1248 uint32_t diff = 64U - sz;
1249 uint8_t *chunk1 = chunk;
1250 uint8_t *chunk2 = chunk + diff;
1251 Hacl_Hash_Blake2s_state_t s1 = *state;
1252 Hacl_Hash_Blake2s_block_state_t block_state10 = s1.block_state;
1253 uint8_t *buf0 = s1.buf;
1254 uint64_t total_len10 = s1.total_len;
1255 uint32_t sz10;
1256 if (total_len10 % (uint64_t)64U == 0ULL && total_len10 > 0ULL)
1257 {
1258 sz10 = 64U;
1259 }
1260 else
1261 {
1262 sz10 = (uint32_t)(total_len10 % (uint64_t)64U);
1263 }
1264 uint8_t *buf2 = buf0 + sz10;
1265 memcpy(buf2, chunk1, diff * sizeof (uint8_t));
1266 uint64_t total_len2 = total_len10 + (uint64_t)diff;
1267 *state =
1268 (
1269 (Hacl_Hash_Blake2s_state_t){
1270 .block_state = block_state10,
1271 .buf = buf0,
1272 .total_len = total_len2
1273 }
1274 );
1275 Hacl_Hash_Blake2s_state_t s10 = *state;
1276 Hacl_Hash_Blake2s_block_state_t block_state1 = s10.block_state;
1277 uint8_t *buf = s10.buf;
1278 uint64_t total_len1 = s10.total_len;
1279 uint32_t sz1;
1280 if (total_len1 % (uint64_t)64U == 0ULL && total_len1 > 0ULL)
1281 {
1282 sz1 = 64U;
1283 }
1284 else
1285 {
1286 sz1 = (uint32_t)(total_len1 % (uint64_t)64U);
1287 }
1288 if (!(sz1 == 0U))
1289 {
1290 uint64_t prevlen = total_len1 - (uint64_t)sz1;
1291 K____uint32_t___uint32_t_ acc = block_state1.f3;
1292 uint32_t *wv = acc.fst;
1293 uint32_t *hash = acc.snd;
1294 uint32_t nb = 1U;
1295 Hacl_Hash_Blake2s_update_multi(64U, wv, hash, prevlen, buf, nb);
1296 }
1297 uint32_t ite;
1298 if
1299 ((uint64_t)(chunk_len - diff) % (uint64_t)64U == 0ULL && (uint64_t)(chunk_len - diff) > 0ULL)
1300 {
1301 ite = 64U;
1302 }
1303 else
1304 {
1305 ite = (uint32_t)((uint64_t)(chunk_len - diff) % (uint64_t)64U);
1306 }
1307 uint32_t n_blocks = (chunk_len - diff - ite) / 64U;
1308 uint32_t data1_len = n_blocks * 64U;
1309 uint32_t data2_len = chunk_len - diff - data1_len;
1310 uint8_t *data1 = chunk2;
1311 uint8_t *data2 = chunk2 + data1_len;
1312 K____uint32_t___uint32_t_ acc = block_state1.f3;
1313 uint32_t *wv = acc.fst;
1314 uint32_t *hash = acc.snd;
1315 uint32_t nb = data1_len / 64U;
1316 Hacl_Hash_Blake2s_update_multi(data1_len, wv, hash, total_len1, data1, nb);
1317 uint8_t *dst = buf;
1318 memcpy(dst, data2, data2_len * sizeof (uint8_t));
1319 *state =
1320 (
1321 (Hacl_Hash_Blake2s_state_t){
1322 .block_state = block_state1,
1323 .buf = buf,
1324 .total_len = total_len1 + (uint64_t)(chunk_len - diff)
1325 }
1326 );
1327 }
1328 return Hacl_Streaming_Types_Success;
1329 }
1330
1331 /**
1332 Digest function. This function expects the `output` array to hold
1333 at least `digest_length` bytes, where `digest_length` was determined by your
1334 choice of `malloc` function. Concretely, if you used `malloc` or
1335 `malloc_with_key`, then the expected length is 32 for S, or 64 for B (default
1336 digest length). If you used `malloc_with_params_and_key`, then the expected
1337 length is whatever you chose for the `digest_length` field of your parameters.
1338 For convenience, this function returns `digest_length`. When in doubt, callers
1339 can pass an array of size HACL_BLAKE2S_32_OUT_BYTES, then use the return value
1340 to see how many bytes were actually written.
1341 */
1342 uint8_t Hacl_Hash_Blake2s_digest(Hacl_Hash_Blake2s_state_t *s, uint8_t *dst)
1343 {
1344 Hacl_Hash_Blake2s_block_state_t block_state0 = (*s).block_state;
1345 bool last_node0 = block_state0.thd;
1346 uint8_t nn0 = block_state0.snd;
1347 uint8_t kk0 = block_state0.fst;
1348 Hacl_Hash_Blake2b_index
1349 i1 = { .key_length = kk0, .digest_length = nn0, .last_node = last_node0 };
1350 Hacl_Hash_Blake2s_state_t scrut = *s;
1351 Hacl_Hash_Blake2s_block_state_t block_state = scrut.block_state;
1352 uint8_t *buf_ = scrut.buf;
1353 uint64_t total_len = scrut.total_len;
1354 uint32_t r;
1355 if (total_len % (uint64_t)64U == 0ULL && total_len > 0ULL)
1356 {
1357 r = 64U;
1358 }
1359 else
1360 {
1361 r = (uint32_t)(total_len % (uint64_t)64U);
1362 }
1363 uint8_t *buf_1 = buf_;
1364 uint32_t wv0[16U] = { 0U };
1365 uint32_t b[16U] = { 0U };
1366 Hacl_Hash_Blake2s_block_state_t
1367 tmp_block_state =
1368 {
1369 .fst = i1.key_length,
1370 .snd = i1.digest_length,
1371 .thd = i1.last_node,
1372 .f3 = { .fst = wv0, .snd = b }
1373 };
1374 uint32_t *src_b = block_state.f3.snd;
1375 uint32_t *dst_b = tmp_block_state.f3.snd;
1376 memcpy(dst_b, src_b, 16U * sizeof (uint32_t));
1377 uint64_t prev_len = total_len - (uint64_t)r;
1378 uint32_t ite;
1379 if (r % 64U == 0U && r > 0U)
1380 {
1381 ite = 64U;
1382 }
1383 else
1384 {
1385 ite = r % 64U;
1386 }
1387 uint8_t *buf_last = buf_1 + r - ite;
1388 uint8_t *buf_multi = buf_1;
1389 K____uint32_t___uint32_t_ acc0 = tmp_block_state.f3;
1390 uint32_t *wv1 = acc0.fst;
1391 uint32_t *hash0 = acc0.snd;
1392 uint32_t nb = 0U;
1393 Hacl_Hash_Blake2s_update_multi(0U, wv1, hash0, prev_len, buf_multi, nb);
1394 uint64_t prev_len_last = total_len - (uint64_t)r;
1395 K____uint32_t___uint32_t_ acc = tmp_block_state.f3;
1396 bool last_node1 = tmp_block_state.thd;
1397 uint32_t *wv = acc.fst;
1398 uint32_t *hash = acc.snd;
1399 Hacl_Hash_Blake2s_update_last(r, wv, hash, last_node1, prev_len_last, r, buf_last);
1400 uint8_t nn1 = tmp_block_state.snd;
1401 Hacl_Hash_Blake2s_finish((uint32_t)nn1, dst, tmp_block_state.f3.snd);
1402 Hacl_Hash_Blake2s_block_state_t block_state1 = (*s).block_state;
1403 bool last_node = block_state1.thd;
1404 uint8_t nn = block_state1.snd;
1405 uint8_t kk = block_state1.fst;
1406 return
1407 ((Hacl_Hash_Blake2b_index){ .key_length = kk, .digest_length = nn, .last_node = last_node }).digest_length;
1408 }
1409
1410 Hacl_Hash_Blake2b_index Hacl_Hash_Blake2s_info(Hacl_Hash_Blake2s_state_t *s)
1411 {
1412 Hacl_Hash_Blake2s_block_state_t block_state = (*s).block_state;
1413 bool last_node = block_state.thd;
1414 uint8_t nn = block_state.snd;
1415 uint8_t kk = block_state.fst;
1416 return
1417 ((Hacl_Hash_Blake2b_index){ .key_length = kk, .digest_length = nn, .last_node = last_node });
1418 }
1419
1420 /**
1421 Free state function when there is no key
1422 */
1423 void Hacl_Hash_Blake2s_free(Hacl_Hash_Blake2s_state_t *state)
1424 {
1425 Hacl_Hash_Blake2s_state_t scrut = *state;
1426 uint8_t *buf = scrut.buf;
1427 Hacl_Hash_Blake2s_block_state_t block_state = scrut.block_state;
1428 uint32_t *b = block_state.f3.snd;
1429 uint32_t *wv = block_state.f3.fst;
1430 KRML_HOST_FREE(wv);
1431 KRML_HOST_FREE(b);
1432 KRML_HOST_FREE(buf);
1433 KRML_HOST_FREE(state);
1434 }
1435
1436 /**
1437 Copying. This preserves all parameters.
1438 */
1439 Hacl_Hash_Blake2s_state_t *Hacl_Hash_Blake2s_copy(Hacl_Hash_Blake2s_state_t *state)
1440 {
1441 Hacl_Hash_Blake2s_state_t scrut = *state;
1442 Hacl_Hash_Blake2s_block_state_t block_state0 = scrut.block_state;
1443 uint8_t *buf0 = scrut.buf;
1444 uint64_t total_len0 = scrut.total_len;
1445 bool last_node = block_state0.thd;
1446 uint8_t nn = block_state0.snd;
1447 uint8_t kk1 = block_state0.fst;
1448 Hacl_Hash_Blake2b_index i = { .key_length = kk1, .digest_length = nn, .last_node = last_node };
1449 uint8_t *buf = (uint8_t *)KRML_HOST_CALLOC(64U, sizeof (uint8_t));
1450 if (buf == NULL)
1451 {
1452 return NULL;
1453 }
1454 memcpy(buf, buf0, 64U * sizeof (uint8_t));
1455 uint32_t *wv0 = (uint32_t *)KRML_HOST_CALLOC(16U, sizeof (uint32_t));
1456 option___uint8_t___uint8_t___bool_____uint32_t_____uint32_t___ block_state;
1457 if (wv0 == NULL)
1458 {
1459 block_state =
1460 (
1461 (option___uint8_t___uint8_t___bool_____uint32_t_____uint32_t___){
1462 .tag = Hacl_Streaming_Types_None
1463 }
1464 );
1465 }
1466 else
1467 {
1468 uint32_t *b = (uint32_t *)KRML_HOST_CALLOC(16U, sizeof (uint32_t));
1469 if (b == NULL)
1470 {
1471 KRML_HOST_FREE(wv0);
1472 block_state =
1473 (
1474 (option___uint8_t___uint8_t___bool_____uint32_t_____uint32_t___){
1475 .tag = Hacl_Streaming_Types_None
1476 }
1477 );
1478 }
1479 else
1480 {
1481 block_state =
1482 (
1483 (option___uint8_t___uint8_t___bool_____uint32_t_____uint32_t___){
1484 .tag = Hacl_Streaming_Types_Some,
1485 .v = {
1486 .fst = i.key_length,
1487 .snd = i.digest_length,
1488 .thd = i.last_node,
1489 .f3 = { .fst = wv0, .snd = b }
1490 }
1491 }
1492 );
1493 }
1494 }
1495 if (block_state.tag == Hacl_Streaming_Types_None)
1496 {
1497 KRML_HOST_FREE(buf);
1498 return NULL;
1499 }
1500 if (block_state.tag == Hacl_Streaming_Types_Some)
1501 {
1502 Hacl_Hash_Blake2s_block_state_t block_state1 = block_state.v;
1503 uint32_t *src_b = block_state0.f3.snd;
1504 uint32_t *dst_b = block_state1.f3.snd;
1505 memcpy(dst_b, src_b, 16U * sizeof (uint32_t));
1506 Hacl_Streaming_Types_optional k_ = Hacl_Streaming_Types_Some;
1507 switch (k_)
1508 {
1509 case Hacl_Streaming_Types_None:
1510 {
1511 return NULL;
1512 }
1513 case Hacl_Streaming_Types_Some:
1514 {
1515 Hacl_Hash_Blake2s_state_t
1516 s = { .block_state = block_state1, .buf = buf, .total_len = total_len0 };
1517 Hacl_Hash_Blake2s_state_t
1518 *p = (Hacl_Hash_Blake2s_state_t *)KRML_HOST_MALLOC(sizeof (Hacl_Hash_Blake2s_state_t));
1519 if (p != NULL)
1520 {
1521 p[0U] = s;
1522 }
1523 if (p == NULL)
1524 {
1525 uint32_t *b = block_state1.f3.snd;
1526 uint32_t *wv = block_state1.f3.fst;
1527 KRML_HOST_FREE(wv);
1528 KRML_HOST_FREE(b);
1529 KRML_HOST_FREE(buf);
1530 return NULL;
1531 }
1532 return p;
1533 }
1534 default:
1535 {
1536 KRML_HOST_EPRINTF("KaRaMeL incomplete match at %s:%d\n", __FILE__, __LINE__);
1537 KRML_HOST_EXIT(253U);
1538 }
1539 }
1540 }
1541 KRML_HOST_EPRINTF("KaRaMeL abort at %s:%d\n%s\n",
1542 __FILE__,
1543 __LINE__,
1544 "unreachable (pattern matches are exhaustive in F*)");
1545 KRML_HOST_EXIT(255U);
1546 }
1547
1548 /**
1549 Write the BLAKE2s digest of message `input` using key `key` into `output`.
1550
1551 @param output Pointer to `output_len` bytes of memory where the digest is written to.
1552 @param output_len Length of the to-be-generated digest with 1 <= `output_len` <= 64.
1553 @param input Pointer to `input_len` bytes of memory where the input message is read from.
1554 @param input_len Length of the input message.
1555 @param key Pointer to `key_len` bytes of memory where the key is read from.
1556 @param key_len Length of the key. Can be 0.
1557 */
1558 void
1559 Hacl_Hash_Blake2s_hash_with_key(
1560 uint8_t *output,
1561 uint32_t output_len,
1562 uint8_t *input,
1563 uint32_t input_len,
1564 uint8_t *key,
1565 uint32_t key_len
1566 )
1567 {
1568 uint32_t b[16U] = { 0U };
1569 uint32_t b1[16U] = { 0U };
1570 Hacl_Hash_Blake2s_init(b, key_len, output_len);
1571 update(b1, b, key_len, key, input_len, input);
1572 Hacl_Hash_Blake2s_finish(output_len, output, b);
1573 Lib_Memzero0_memzero(b1, 16U, uint32_t, void *);
1574 Lib_Memzero0_memzero(b, 16U, uint32_t, void *);
1575 }
1576
1577 /**
1578 Write the BLAKE2s digest of message `input` using key `key` and
1579 parameters `params` into `output`. The `key` array must be of length
1580 `params.key_length`. The `output` array must be of length
1581 `params.digest_length`.
1582 */
1583 void
1584 Hacl_Hash_Blake2s_hash_with_key_and_params(
1585 uint8_t *output,
1586 uint8_t *input,
1587 uint32_t input_len,
1588 Hacl_Hash_Blake2b_blake2_params params,
1589 uint8_t *key
1590 )
1591 {
1592 uint32_t b[16U] = { 0U };
1593 uint32_t b1[16U] = { 0U };
1594 uint32_t tmp[8U] = { 0U };
1595 uint32_t *r0 = b;
1596 uint32_t *r1 = b + 4U;
1597 uint32_t *r2 = b + 8U;
1598 uint32_t *r3 = b + 12U;
1599 uint32_t iv0 = Hacl_Hash_Blake2b_ivTable_S[0U];
1600 uint32_t iv1 = Hacl_Hash_Blake2b_ivTable_S[1U];
1601 uint32_t iv2 = Hacl_Hash_Blake2b_ivTable_S[2U];
1602 uint32_t iv3 = Hacl_Hash_Blake2b_ivTable_S[3U];
1603 uint32_t iv4 = Hacl_Hash_Blake2b_ivTable_S[4U];
1604 uint32_t iv5 = Hacl_Hash_Blake2b_ivTable_S[5U];
1605 uint32_t iv6 = Hacl_Hash_Blake2b_ivTable_S[6U];
1606 uint32_t iv7 = Hacl_Hash_Blake2b_ivTable_S[7U];
1607 r2[0U] = iv0;
1608 r2[1U] = iv1;
1609 r2[2U] = iv2;
1610 r2[3U] = iv3;
1611 r3[0U] = iv4;
1612 r3[1U] = iv5;
1613 r3[2U] = iv6;
1614 r3[3U] = iv7;
1615 KRML_MAYBE_FOR2(i,
1616 0U,
1617 2U,
1618 1U,
1619 uint32_t *os = tmp + 4U;
1620 uint8_t *bj = params.salt + i * 4U;
1621 uint32_t u = load32_le(bj);
1622 uint32_t r = u;
1623 uint32_t x = r;
1624 os[i] = x;);
1625 KRML_MAYBE_FOR2(i,
1626 0U,
1627 2U,
1628 1U,
1629 uint32_t *os = tmp + 6U;
1630 uint8_t *bj = params.personal + i * 4U;
1631 uint32_t u = load32_le(bj);
1632 uint32_t r = u;
1633 uint32_t x = r;
1634 os[i] = x;);
1635 tmp[0U] =
1636 (uint32_t)params.digest_length ^
1637 ((uint32_t)params.key_length << 8U ^
1638 ((uint32_t)params.fanout << 16U ^ (uint32_t)params.depth << 24U));
1639 tmp[1U] = params.leaf_length;
1640 tmp[2U] = (uint32_t)params.node_offset;
1641 tmp[3U] =
1642 (uint32_t)(params.node_offset >> 32U) ^
1643 ((uint32_t)params.node_depth << 16U ^ (uint32_t)params.inner_length << 24U);
1644 uint32_t tmp0 = tmp[0U];
1645 uint32_t tmp1 = tmp[1U];
1646 uint32_t tmp2 = tmp[2U];
1647 uint32_t tmp3 = tmp[3U];
1648 uint32_t tmp4 = tmp[4U];
1649 uint32_t tmp5 = tmp[5U];
1650 uint32_t tmp6 = tmp[6U];
1651 uint32_t tmp7 = tmp[7U];
1652 uint32_t iv0_ = iv0 ^ tmp0;
1653 uint32_t iv1_ = iv1 ^ tmp1;
1654 uint32_t iv2_ = iv2 ^ tmp2;
1655 uint32_t iv3_ = iv3 ^ tmp3;
1656 uint32_t iv4_ = iv4 ^ tmp4;
1657 uint32_t iv5_ = iv5 ^ tmp5;
1658 uint32_t iv6_ = iv6 ^ tmp6;
1659 uint32_t iv7_ = iv7 ^ tmp7;
1660 r0[0U] = iv0_;
1661 r0[1U] = iv1_;
1662 r0[2U] = iv2_;
1663 r0[3U] = iv3_;
1664 r1[0U] = iv4_;
1665 r1[1U] = iv5_;
1666 r1[2U] = iv6_;
1667 r1[3U] = iv7_;
1668 update(b1, b, (uint32_t)params.key_length, key, input_len, input);
1669 Hacl_Hash_Blake2s_finish((uint32_t)params.digest_length, output, b);
1670 Lib_Memzero0_memzero(b1, 16U, uint32_t, void *);
1671 Lib_Memzero0_memzero(b, 16U, uint32_t, void *);
1672 }
1673