From 10acc912fde4e784891db9ae0cf784f5eaad5461 Mon Sep 17 00:00:00 2001 From: Hacl Bot <hacl-star@mailo.com> Date: Sat, 9 Dec 2023 22:46:23 +0000 Subject: [PATCH] [CI] update code --- include/internal/Hacl_Hash_Blake2b.h | 32 ++++++++ include/internal/Hacl_Hash_Blake2b_Simd256.h | 1 + include/internal/Hacl_Hash_Blake2s.h | 1 + include/internal/Hacl_Hash_Blake2s_Simd128.h | 1 + include/msvc/internal/Hacl_Hash_Blake2b.h | 32 ++++++++ .../msvc/internal/Hacl_Hash_Blake2b_Simd256.h | 1 + include/msvc/internal/Hacl_Hash_Blake2s.h | 1 + .../msvc/internal/Hacl_Hash_Blake2s_Simd128.h | 1 + ocaml/lib/Hacl_Hash_Blake2b_bindings.ml | 56 ++++++++++++++ src/Hacl_Hash_Blake2b.c | 71 +++++++++++++++--- src/Hacl_Hash_Blake2b_Simd256.c | 62 ++++++++++++++- src/Hacl_Hash_Blake2s.c | 69 ++++++++++++++--- src/Hacl_Hash_Blake2s_Simd128.c | 59 ++++++++++++++- src/msvc/Hacl_Hash_Blake2b.c | 71 +++++++++++++++--- src/msvc/Hacl_Hash_Blake2b_Simd256.c | 62 ++++++++++++++- src/msvc/Hacl_Hash_Blake2s.c | 69 ++++++++++++++--- src/msvc/Hacl_Hash_Blake2s_Simd128.c | 59 ++++++++++++++- src/wasm/EverCrypt_Hash.wasm | Bin 49305 -> 48469 bytes .../Hacl_AEAD_Chacha20Poly1305_Simd256.wasm | Bin 1910 -> 1910 bytes src/wasm/Hacl_Ed25519_PrecompTable.wasm | Bin 16451 -> 16451 bytes src/wasm/Hacl_HMAC.wasm | Bin 29754 -> 28160 bytes src/wasm/Hacl_HMAC_DRBG.wasm | Bin 25396 -> 25396 bytes src/wasm/Hacl_Hash_Blake2b.wasm | Bin 15858 -> 16141 bytes src/wasm/Hacl_Hash_Blake2b_Simd256.wasm | Bin 6794 -> 7187 bytes src/wasm/Hacl_Hash_Blake2s.wasm | Bin 14005 -> 14331 bytes src/wasm/Hacl_Hash_Blake2s_Simd128.wasm | Bin 5638 -> 6030 bytes src/wasm/Hacl_SHA2_Vec128.wasm | Bin 5687 -> 5687 bytes src/wasm/INFO.txt | 2 +- src/wasm/layouts.json | 2 +- 29 files changed, 598 insertions(+), 54 deletions(-) diff --git a/include/internal/Hacl_Hash_Blake2b.h b/include/internal/Hacl_Hash_Blake2b.h index 21689d60..7d07e50b 100644 --- a/include/internal/Hacl_Hash_Blake2b.h +++ b/include/internal/Hacl_Hash_Blake2b.h @@ -38,6 +38,38 @@ extern "C" { #include "internal/Hacl_Impl_Blake2_Constants.h" #include "../Hacl_Hash_Blake2b.h" +typedef struct Hacl_Hash_Blake2s_blake2s_params_s +{ + uint8_t digest_length; + uint8_t key_length; + uint8_t fanout; + uint8_t depth; + uint32_t leaf_length; + uint32_t node_offset; + uint16_t xof_length; + uint8_t node_depth; + uint8_t inner_length; + uint8_t *salt; + uint8_t *personal; +} +Hacl_Hash_Blake2s_blake2s_params; + +typedef struct Hacl_Hash_Blake2s_blake2b_params_s +{ + uint8_t digest_length1; + uint8_t key_length1; + uint8_t fanout1; + uint8_t depth1; + uint32_t leaf_length1; + uint32_t node_offset1; + uint32_t xof_length1; + uint8_t node_depth1; + uint8_t inner_length1; + uint8_t *salt1; + uint8_t *personal1; +} +Hacl_Hash_Blake2s_blake2b_params; + void Hacl_Hash_Blake2b_init(uint64_t *hash, uint32_t kk, uint32_t nn); void diff --git a/include/internal/Hacl_Hash_Blake2b_Simd256.h b/include/internal/Hacl_Hash_Blake2b_Simd256.h index 4cc07869..4dd986b2 100644 --- a/include/internal/Hacl_Hash_Blake2b_Simd256.h +++ b/include/internal/Hacl_Hash_Blake2b_Simd256.h @@ -36,6 +36,7 @@ extern "C" { #include "krml/internal/target.h" #include "internal/Hacl_Impl_Blake2_Constants.h" +#include "internal/Hacl_Hash_Blake2b.h" #include "../Hacl_Hash_Blake2b_Simd256.h" #include "libintvector.h" diff --git a/include/internal/Hacl_Hash_Blake2s.h b/include/internal/Hacl_Hash_Blake2s.h index f814aa95..eccd92de 100644 --- a/include/internal/Hacl_Hash_Blake2s.h +++ b/include/internal/Hacl_Hash_Blake2s.h @@ -36,6 +36,7 @@ extern "C" { #include "krml/internal/target.h" #include "internal/Hacl_Impl_Blake2_Constants.h" +#include "internal/Hacl_Hash_Blake2b.h" #include "../Hacl_Hash_Blake2s.h" void Hacl_Hash_Blake2s_init(uint32_t *hash, uint32_t kk, uint32_t nn); diff --git a/include/internal/Hacl_Hash_Blake2s_Simd128.h b/include/internal/Hacl_Hash_Blake2s_Simd128.h index 0589aec5..2c422949 100644 --- a/include/internal/Hacl_Hash_Blake2s_Simd128.h +++ b/include/internal/Hacl_Hash_Blake2s_Simd128.h @@ -36,6 +36,7 @@ extern "C" { #include "krml/internal/target.h" #include "internal/Hacl_Impl_Blake2_Constants.h" +#include "internal/Hacl_Hash_Blake2b.h" #include "../Hacl_Hash_Blake2s_Simd128.h" #include "libintvector.h" diff --git a/include/msvc/internal/Hacl_Hash_Blake2b.h b/include/msvc/internal/Hacl_Hash_Blake2b.h index 21689d60..7d07e50b 100644 --- a/include/msvc/internal/Hacl_Hash_Blake2b.h +++ b/include/msvc/internal/Hacl_Hash_Blake2b.h @@ -38,6 +38,38 @@ extern "C" { #include "internal/Hacl_Impl_Blake2_Constants.h" #include "../Hacl_Hash_Blake2b.h" +typedef struct Hacl_Hash_Blake2s_blake2s_params_s +{ + uint8_t digest_length; + uint8_t key_length; + uint8_t fanout; + uint8_t depth; + uint32_t leaf_length; + uint32_t node_offset; + uint16_t xof_length; + uint8_t node_depth; + uint8_t inner_length; + uint8_t *salt; + uint8_t *personal; +} +Hacl_Hash_Blake2s_blake2s_params; + +typedef struct Hacl_Hash_Blake2s_blake2b_params_s +{ + uint8_t digest_length1; + uint8_t key_length1; + uint8_t fanout1; + uint8_t depth1; + uint32_t leaf_length1; + uint32_t node_offset1; + uint32_t xof_length1; + uint8_t node_depth1; + uint8_t inner_length1; + uint8_t *salt1; + uint8_t *personal1; +} +Hacl_Hash_Blake2s_blake2b_params; + void Hacl_Hash_Blake2b_init(uint64_t *hash, uint32_t kk, uint32_t nn); void diff --git a/include/msvc/internal/Hacl_Hash_Blake2b_Simd256.h b/include/msvc/internal/Hacl_Hash_Blake2b_Simd256.h index 4cc07869..4dd986b2 100644 --- a/include/msvc/internal/Hacl_Hash_Blake2b_Simd256.h +++ b/include/msvc/internal/Hacl_Hash_Blake2b_Simd256.h @@ -36,6 +36,7 @@ extern "C" { #include "krml/internal/target.h" #include "internal/Hacl_Impl_Blake2_Constants.h" +#include "internal/Hacl_Hash_Blake2b.h" #include "../Hacl_Hash_Blake2b_Simd256.h" #include "libintvector.h" diff --git a/include/msvc/internal/Hacl_Hash_Blake2s.h b/include/msvc/internal/Hacl_Hash_Blake2s.h index f814aa95..eccd92de 100644 --- a/include/msvc/internal/Hacl_Hash_Blake2s.h +++ b/include/msvc/internal/Hacl_Hash_Blake2s.h @@ -36,6 +36,7 @@ extern "C" { #include "krml/internal/target.h" #include "internal/Hacl_Impl_Blake2_Constants.h" +#include "internal/Hacl_Hash_Blake2b.h" #include "../Hacl_Hash_Blake2s.h" void Hacl_Hash_Blake2s_init(uint32_t *hash, uint32_t kk, uint32_t nn); diff --git a/include/msvc/internal/Hacl_Hash_Blake2s_Simd128.h b/include/msvc/internal/Hacl_Hash_Blake2s_Simd128.h index 0589aec5..2c422949 100644 --- a/include/msvc/internal/Hacl_Hash_Blake2s_Simd128.h +++ b/include/msvc/internal/Hacl_Hash_Blake2s_Simd128.h @@ -36,6 +36,7 @@ extern "C" { #include "krml/internal/target.h" #include "internal/Hacl_Impl_Blake2_Constants.h" +#include "internal/Hacl_Hash_Blake2b.h" #include "../Hacl_Hash_Blake2s_Simd128.h" #include "libintvector.h" diff --git a/ocaml/lib/Hacl_Hash_Blake2b_bindings.ml b/ocaml/lib/Hacl_Hash_Blake2b_bindings.ml index 75c75e90..4c32a894 100644 --- a/ocaml/lib/Hacl_Hash_Blake2b_bindings.ml +++ b/ocaml/lib/Hacl_Hash_Blake2b_bindings.ml @@ -5,6 +5,62 @@ module Bindings(F:Cstubs.FOREIGN) = module Hacl_Streaming_Types_applied = (Hacl_Streaming_Types_bindings.Bindings)(Hacl_Streaming_Types_stubs) open Hacl_Streaming_Types_applied + type hacl_Hash_Blake2s_blake2s_params = + [ `hacl_Hash_Blake2s_blake2s_params ] structure + let (hacl_Hash_Blake2s_blake2s_params : + [ `hacl_Hash_Blake2s_blake2s_params ] structure typ) = + structure "Hacl_Hash_Blake2s_blake2s_params_s" + let hacl_Hash_Blake2s_blake2s_params_digest_length = + field hacl_Hash_Blake2s_blake2s_params "digest_length" uint8_t + let hacl_Hash_Blake2s_blake2s_params_key_length = + field hacl_Hash_Blake2s_blake2s_params "key_length" uint8_t + let hacl_Hash_Blake2s_blake2s_params_fanout = + field hacl_Hash_Blake2s_blake2s_params "fanout" uint8_t + let hacl_Hash_Blake2s_blake2s_params_depth = + field hacl_Hash_Blake2s_blake2s_params "depth" uint8_t + let hacl_Hash_Blake2s_blake2s_params_leaf_length = + field hacl_Hash_Blake2s_blake2s_params "leaf_length" uint32_t + let hacl_Hash_Blake2s_blake2s_params_node_offset = + field hacl_Hash_Blake2s_blake2s_params "node_offset" uint32_t + let hacl_Hash_Blake2s_blake2s_params_xof_length = + field hacl_Hash_Blake2s_blake2s_params "xof_length" uint16_t + let hacl_Hash_Blake2s_blake2s_params_node_depth = + field hacl_Hash_Blake2s_blake2s_params "node_depth" uint8_t + let hacl_Hash_Blake2s_blake2s_params_inner_length = + field hacl_Hash_Blake2s_blake2s_params "inner_length" uint8_t + let hacl_Hash_Blake2s_blake2s_params_salt = + field hacl_Hash_Blake2s_blake2s_params "salt" (ptr uint8_t) + let hacl_Hash_Blake2s_blake2s_params_personal = + field hacl_Hash_Blake2s_blake2s_params "personal" (ptr uint8_t) + let _ = seal hacl_Hash_Blake2s_blake2s_params + type hacl_Hash_Blake2s_blake2b_params = + [ `hacl_Hash_Blake2s_blake2b_params ] structure + let (hacl_Hash_Blake2s_blake2b_params : + [ `hacl_Hash_Blake2s_blake2b_params ] structure typ) = + structure "Hacl_Hash_Blake2s_blake2b_params_s" + let hacl_Hash_Blake2s_blake2b_params_digest_length1 = + field hacl_Hash_Blake2s_blake2b_params "digest_length1" uint8_t + let hacl_Hash_Blake2s_blake2b_params_key_length1 = + field hacl_Hash_Blake2s_blake2b_params "key_length1" uint8_t + let hacl_Hash_Blake2s_blake2b_params_fanout1 = + field hacl_Hash_Blake2s_blake2b_params "fanout1" uint8_t + let hacl_Hash_Blake2s_blake2b_params_depth1 = + field hacl_Hash_Blake2s_blake2b_params "depth1" uint8_t + let hacl_Hash_Blake2s_blake2b_params_leaf_length1 = + field hacl_Hash_Blake2s_blake2b_params "leaf_length1" uint32_t + let hacl_Hash_Blake2s_blake2b_params_node_offset1 = + field hacl_Hash_Blake2s_blake2b_params "node_offset1" uint32_t + let hacl_Hash_Blake2s_blake2b_params_xof_length1 = + field hacl_Hash_Blake2s_blake2b_params "xof_length1" uint32_t + let hacl_Hash_Blake2s_blake2b_params_node_depth1 = + field hacl_Hash_Blake2s_blake2b_params "node_depth1" uint8_t + let hacl_Hash_Blake2s_blake2b_params_inner_length1 = + field hacl_Hash_Blake2s_blake2b_params "inner_length1" uint8_t + let hacl_Hash_Blake2s_blake2b_params_salt1 = + field hacl_Hash_Blake2s_blake2b_params "salt1" (ptr uint8_t) + let hacl_Hash_Blake2s_blake2b_params_personal1 = + field hacl_Hash_Blake2s_blake2b_params "personal1" (ptr uint8_t) + let _ = seal hacl_Hash_Blake2s_blake2b_params let hacl_Hash_Blake2b_init = foreign "Hacl_Hash_Blake2b_init" ((ptr uint64_t) @-> (uint32_t @-> (uint32_t @-> (returning void)))) diff --git a/src/Hacl_Hash_Blake2b.c b/src/Hacl_Hash_Blake2b.c index 2dceaf4b..284da79a 100644 --- a/src/Hacl_Hash_Blake2b.c +++ b/src/Hacl_Hash_Blake2b.c @@ -474,6 +474,7 @@ update_block(uint64_t *wv, uint64_t *hash, bool flag, FStar_UInt128_uint128 totl void Hacl_Hash_Blake2b_init(uint64_t *hash, uint32_t kk, uint32_t nn) { + uint64_t tmp[8U] = { 0U }; uint64_t *r0 = hash; uint64_t *r1 = hash + 4U; uint64_t *r2 = hash + 8U; @@ -494,16 +495,68 @@ void Hacl_Hash_Blake2b_init(uint64_t *hash, uint32_t kk, uint32_t nn) r3[1U] = iv5; r3[2U] = iv6; r3[3U] = iv7; - uint64_t kk_shift_8 = (uint64_t)kk << 8U; - uint64_t iv0_ = iv0 ^ (0x01010000ULL ^ (kk_shift_8 ^ (uint64_t)nn)); + uint8_t salt[16U] = { 0U }; + uint8_t personal[16U] = { 0U }; + Hacl_Hash_Blake2s_blake2b_params + p = + { + .digest_length1 = 64U, .key_length1 = 0U, .fanout1 = 1U, .depth1 = 1U, .leaf_length1 = 0U, + .node_offset1 = 0U, .xof_length1 = 0U, .node_depth1 = 0U, .inner_length1 = 0U, .salt1 = salt, + .personal1 = personal + }; + KRML_MAYBE_FOR2(i, + 0U, + 2U, + 1U, + uint64_t *os = tmp + 4U; + uint8_t *bj = p.salt1 + i * 8U; + uint64_t u = load64_le(bj); + uint64_t r = u; + uint64_t x = r; + os[i] = x;); + KRML_MAYBE_FOR2(i, + 0U, + 2U, + 1U, + uint64_t *os = tmp + 6U; + uint8_t *bj = p.personal1 + i * 8U; + uint64_t u = load64_le(bj); + uint64_t r = u; + uint64_t x = r; + os[i] = x;); + tmp[0U] = + (uint64_t)nn + ^ + ((uint64_t)kk + << 8U + ^ ((uint64_t)p.fanout1 << 16U ^ ((uint64_t)p.depth1 << 24U ^ (uint64_t)p.leaf_length1 << 32U))); + tmp[1U] = (uint64_t)p.node_offset1 ^ (uint64_t)p.xof_length1 << 32U; + tmp[2U] = (uint64_t)p.node_depth1 ^ (uint64_t)p.inner_length1 << 8U; + tmp[3U] = 0ULL; + uint64_t tmp0 = tmp[0U]; + uint64_t tmp1 = tmp[1U]; + uint64_t tmp2 = tmp[2U]; + uint64_t tmp3 = tmp[3U]; + uint64_t tmp4 = tmp[4U]; + uint64_t tmp5 = tmp[5U]; + uint64_t tmp6 = tmp[6U]; + uint64_t tmp7 = tmp[7U]; + uint64_t iv0_ = iv0 ^ tmp0; + uint64_t iv1_ = iv1 ^ tmp1; + uint64_t iv2_ = iv2 ^ tmp2; + uint64_t iv3_ = iv3 ^ tmp3; + uint64_t iv4_ = iv4 ^ tmp4; + uint64_t iv5_ = iv5 ^ tmp5; + uint64_t iv6_ = iv6 ^ tmp6; + uint64_t iv7_ = iv7 ^ tmp7; r0[0U] = iv0_; - r0[1U] = iv1; - r0[2U] = iv2; - r0[3U] = iv3; - r1[0U] = iv4; - r1[1U] = iv5; - r1[2U] = iv6; - r1[3U] = iv7; + r0[1U] = iv1_; + r0[2U] = iv2_; + r0[3U] = iv3_; + r1[0U] = iv4_; + r1[1U] = iv5_; + r1[2U] = iv6_; + r1[3U] = iv7_; } static void update_key(uint64_t *wv, uint64_t *hash, uint32_t kk, uint8_t *k, uint32_t ll) diff --git a/src/Hacl_Hash_Blake2b_Simd256.c b/src/Hacl_Hash_Blake2b_Simd256.c index 1a5e8cf2..7a807b65 100644 --- a/src/Hacl_Hash_Blake2b_Simd256.c +++ b/src/Hacl_Hash_Blake2b_Simd256.c @@ -26,6 +26,7 @@ #include "internal/Hacl_Hash_Blake2b_Simd256.h" #include "internal/Hacl_Impl_Blake2_Constants.h" +#include "internal/Hacl_Hash_Blake2b.h" #include "lib_memzero0.h" static inline void @@ -214,6 +215,7 @@ update_block( void Hacl_Hash_Blake2b_Simd256_init(Lib_IntVector_Intrinsics_vec256 *hash, uint32_t kk, uint32_t nn) { + uint64_t tmp[8U] = { 0U }; Lib_IntVector_Intrinsics_vec256 *r0 = hash; Lib_IntVector_Intrinsics_vec256 *r1 = hash + 1U; Lib_IntVector_Intrinsics_vec256 *r2 = hash + 2U; @@ -228,10 +230,62 @@ Hacl_Hash_Blake2b_Simd256_init(Lib_IntVector_Intrinsics_vec256 *hash, uint32_t k uint64_t iv7 = Hacl_Hash_Blake2s_ivTable_B[7U]; r2[0U] = Lib_IntVector_Intrinsics_vec256_load64s(iv0, iv1, iv2, iv3); r3[0U] = Lib_IntVector_Intrinsics_vec256_load64s(iv4, iv5, iv6, iv7); - uint64_t kk_shift_8 = (uint64_t)kk << 8U; - uint64_t iv0_ = iv0 ^ (0x01010000ULL ^ (kk_shift_8 ^ (uint64_t)nn)); - r0[0U] = Lib_IntVector_Intrinsics_vec256_load64s(iv0_, iv1, iv2, iv3); - r1[0U] = Lib_IntVector_Intrinsics_vec256_load64s(iv4, iv5, iv6, iv7); + uint8_t salt[16U] = { 0U }; + uint8_t personal[16U] = { 0U }; + Hacl_Hash_Blake2s_blake2b_params + p = + { + .digest_length1 = 64U, .key_length1 = 0U, .fanout1 = 1U, .depth1 = 1U, .leaf_length1 = 0U, + .node_offset1 = 0U, .xof_length1 = 0U, .node_depth1 = 0U, .inner_length1 = 0U, .salt1 = salt, + .personal1 = personal + }; + KRML_MAYBE_FOR2(i, + 0U, + 2U, + 1U, + uint64_t *os = tmp + 4U; + uint8_t *bj = p.salt1 + i * 8U; + uint64_t u = load64_le(bj); + uint64_t r = u; + uint64_t x = r; + os[i] = x;); + KRML_MAYBE_FOR2(i, + 0U, + 2U, + 1U, + uint64_t *os = tmp + 6U; + uint8_t *bj = p.personal1 + i * 8U; + uint64_t u = load64_le(bj); + uint64_t r = u; + uint64_t x = r; + os[i] = x;); + tmp[0U] = + (uint64_t)nn + ^ + ((uint64_t)kk + << 8U + ^ ((uint64_t)p.fanout1 << 16U ^ ((uint64_t)p.depth1 << 24U ^ (uint64_t)p.leaf_length1 << 32U))); + tmp[1U] = (uint64_t)p.node_offset1 ^ (uint64_t)p.xof_length1 << 32U; + tmp[2U] = (uint64_t)p.node_depth1 ^ (uint64_t)p.inner_length1 << 8U; + tmp[3U] = 0ULL; + uint64_t tmp0 = tmp[0U]; + uint64_t tmp1 = tmp[1U]; + uint64_t tmp2 = tmp[2U]; + uint64_t tmp3 = tmp[3U]; + uint64_t tmp4 = tmp[4U]; + uint64_t tmp5 = tmp[5U]; + uint64_t tmp6 = tmp[6U]; + uint64_t tmp7 = tmp[7U]; + uint64_t iv0_ = iv0 ^ tmp0; + uint64_t iv1_ = iv1 ^ tmp1; + uint64_t iv2_ = iv2 ^ tmp2; + uint64_t iv3_ = iv3 ^ tmp3; + uint64_t iv4_ = iv4 ^ tmp4; + uint64_t iv5_ = iv5 ^ tmp5; + uint64_t iv6_ = iv6 ^ tmp6; + uint64_t iv7_ = iv7 ^ tmp7; + r0[0U] = Lib_IntVector_Intrinsics_vec256_load64s(iv0_, iv1_, iv2_, iv3_); + r1[0U] = Lib_IntVector_Intrinsics_vec256_load64s(iv4_, iv5_, iv6_, iv7_); } static void diff --git a/src/Hacl_Hash_Blake2s.c b/src/Hacl_Hash_Blake2s.c index 652c3f33..1bae785b 100644 --- a/src/Hacl_Hash_Blake2s.c +++ b/src/Hacl_Hash_Blake2s.c @@ -26,6 +26,7 @@ #include "internal/Hacl_Hash_Blake2s.h" #include "internal/Hacl_Impl_Blake2_Constants.h" +#include "internal/Hacl_Hash_Blake2b.h" #include "lib_memzero0.h" static inline void @@ -474,6 +475,7 @@ update_block(uint32_t *wv, uint32_t *hash, bool flag, uint64_t totlen, uint8_t * void Hacl_Hash_Blake2s_init(uint32_t *hash, uint32_t kk, uint32_t nn) { + uint32_t tmp[8U] = { 0U }; uint32_t *r0 = hash; uint32_t *r1 = hash + 4U; uint32_t *r2 = hash + 8U; @@ -494,16 +496,65 @@ void Hacl_Hash_Blake2s_init(uint32_t *hash, uint32_t kk, uint32_t nn) r3[1U] = iv5; r3[2U] = iv6; r3[3U] = iv7; - uint32_t kk_shift_8 = kk << 8U; - uint32_t iv0_ = iv0 ^ (0x01010000U ^ (kk_shift_8 ^ nn)); + uint8_t salt[8U] = { 0U }; + uint8_t personal[8U] = { 0U }; + Hacl_Hash_Blake2s_blake2s_params + p = + { + .digest_length = 32U, .key_length = 0U, .fanout = 1U, .depth = 1U, .leaf_length = 0U, + .node_offset = 0U, .xof_length = 0U, .node_depth = 0U, .inner_length = 0U, .salt = salt, + .personal = personal + }; + KRML_MAYBE_FOR2(i, + 0U, + 2U, + 1U, + uint32_t *os = tmp + 4U; + uint8_t *bj = p.salt + i * 4U; + uint32_t u = load32_le(bj); + uint32_t r = u; + uint32_t x = r; + os[i] = x;); + KRML_MAYBE_FOR2(i, + 0U, + 2U, + 1U, + uint32_t *os = tmp + 6U; + uint8_t *bj = p.personal + i * 4U; + uint32_t u = load32_le(bj); + uint32_t r = u; + uint32_t x = r; + os[i] = x;); + tmp[0U] = nn ^ (kk << 8U ^ ((uint32_t)p.fanout << 16U ^ (uint32_t)p.depth << 24U)); + tmp[1U] = p.leaf_length; + tmp[2U] = p.node_offset; + tmp[3U] = + (uint32_t)p.xof_length + ^ ((uint32_t)p.node_depth << 16U ^ (uint32_t)p.inner_length << 24U); + uint32_t tmp0 = tmp[0U]; + uint32_t tmp1 = tmp[1U]; + uint32_t tmp2 = tmp[2U]; + uint32_t tmp3 = tmp[3U]; + uint32_t tmp4 = tmp[4U]; + uint32_t tmp5 = tmp[5U]; + uint32_t tmp6 = tmp[6U]; + uint32_t tmp7 = tmp[7U]; + uint32_t iv0_ = iv0 ^ tmp0; + uint32_t iv1_ = iv1 ^ tmp1; + uint32_t iv2_ = iv2 ^ tmp2; + uint32_t iv3_ = iv3 ^ tmp3; + uint32_t iv4_ = iv4 ^ tmp4; + uint32_t iv5_ = iv5 ^ tmp5; + uint32_t iv6_ = iv6 ^ tmp6; + uint32_t iv7_ = iv7 ^ tmp7; r0[0U] = iv0_; - r0[1U] = iv1; - r0[2U] = iv2; - r0[3U] = iv3; - r1[0U] = iv4; - r1[1U] = iv5; - r1[2U] = iv6; - r1[3U] = iv7; + r0[1U] = iv1_; + r0[2U] = iv2_; + r0[3U] = iv3_; + r1[0U] = iv4_; + r1[1U] = iv5_; + r1[2U] = iv6_; + r1[3U] = iv7_; } static void update_key(uint32_t *wv, uint32_t *hash, uint32_t kk, uint8_t *k, uint32_t ll) diff --git a/src/Hacl_Hash_Blake2s_Simd128.c b/src/Hacl_Hash_Blake2s_Simd128.c index 73f0cccb..f0646b28 100644 --- a/src/Hacl_Hash_Blake2s_Simd128.c +++ b/src/Hacl_Hash_Blake2s_Simd128.c @@ -26,6 +26,7 @@ #include "internal/Hacl_Hash_Blake2s_Simd128.h" #include "internal/Hacl_Impl_Blake2_Constants.h" +#include "internal/Hacl_Hash_Blake2b.h" #include "lib_memzero0.h" static inline void @@ -214,6 +215,7 @@ update_block( void Hacl_Hash_Blake2s_Simd128_init(Lib_IntVector_Intrinsics_vec128 *hash, uint32_t kk, uint32_t nn) { + uint32_t tmp[8U] = { 0U }; Lib_IntVector_Intrinsics_vec128 *r0 = hash; Lib_IntVector_Intrinsics_vec128 *r1 = hash + 1U; Lib_IntVector_Intrinsics_vec128 *r2 = hash + 2U; @@ -228,10 +230,59 @@ Hacl_Hash_Blake2s_Simd128_init(Lib_IntVector_Intrinsics_vec128 *hash, uint32_t k uint32_t iv7 = Hacl_Hash_Blake2s_ivTable_S[7U]; r2[0U] = Lib_IntVector_Intrinsics_vec128_load32s(iv0, iv1, iv2, iv3); r3[0U] = Lib_IntVector_Intrinsics_vec128_load32s(iv4, iv5, iv6, iv7); - uint32_t kk_shift_8 = kk << 8U; - uint32_t iv0_ = iv0 ^ (0x01010000U ^ (kk_shift_8 ^ nn)); - r0[0U] = Lib_IntVector_Intrinsics_vec128_load32s(iv0_, iv1, iv2, iv3); - r1[0U] = Lib_IntVector_Intrinsics_vec128_load32s(iv4, iv5, iv6, iv7); + uint8_t salt[8U] = { 0U }; + uint8_t personal[8U] = { 0U }; + Hacl_Hash_Blake2s_blake2s_params + p = + { + .digest_length = 32U, .key_length = 0U, .fanout = 1U, .depth = 1U, .leaf_length = 0U, + .node_offset = 0U, .xof_length = 0U, .node_depth = 0U, .inner_length = 0U, .salt = salt, + .personal = personal + }; + KRML_MAYBE_FOR2(i, + 0U, + 2U, + 1U, + uint32_t *os = tmp + 4U; + uint8_t *bj = p.salt + i * 4U; + uint32_t u = load32_le(bj); + uint32_t r = u; + uint32_t x = r; + os[i] = x;); + KRML_MAYBE_FOR2(i, + 0U, + 2U, + 1U, + uint32_t *os = tmp + 6U; + uint8_t *bj = p.personal + i * 4U; + uint32_t u = load32_le(bj); + uint32_t r = u; + uint32_t x = r; + os[i] = x;); + tmp[0U] = nn ^ (kk << 8U ^ ((uint32_t)p.fanout << 16U ^ (uint32_t)p.depth << 24U)); + tmp[1U] = p.leaf_length; + tmp[2U] = p.node_offset; + tmp[3U] = + (uint32_t)p.xof_length + ^ ((uint32_t)p.node_depth << 16U ^ (uint32_t)p.inner_length << 24U); + uint32_t tmp0 = tmp[0U]; + uint32_t tmp1 = tmp[1U]; + uint32_t tmp2 = tmp[2U]; + uint32_t tmp3 = tmp[3U]; + uint32_t tmp4 = tmp[4U]; + uint32_t tmp5 = tmp[5U]; + uint32_t tmp6 = tmp[6U]; + uint32_t tmp7 = tmp[7U]; + uint32_t iv0_ = iv0 ^ tmp0; + uint32_t iv1_ = iv1 ^ tmp1; + uint32_t iv2_ = iv2 ^ tmp2; + uint32_t iv3_ = iv3 ^ tmp3; + uint32_t iv4_ = iv4 ^ tmp4; + uint32_t iv5_ = iv5 ^ tmp5; + uint32_t iv6_ = iv6 ^ tmp6; + uint32_t iv7_ = iv7 ^ tmp7; + r0[0U] = Lib_IntVector_Intrinsics_vec128_load32s(iv0_, iv1_, iv2_, iv3_); + r1[0U] = Lib_IntVector_Intrinsics_vec128_load32s(iv4_, iv5_, iv6_, iv7_); } static void diff --git a/src/msvc/Hacl_Hash_Blake2b.c b/src/msvc/Hacl_Hash_Blake2b.c index 2dceaf4b..284da79a 100644 --- a/src/msvc/Hacl_Hash_Blake2b.c +++ b/src/msvc/Hacl_Hash_Blake2b.c @@ -474,6 +474,7 @@ update_block(uint64_t *wv, uint64_t *hash, bool flag, FStar_UInt128_uint128 totl void Hacl_Hash_Blake2b_init(uint64_t *hash, uint32_t kk, uint32_t nn) { + uint64_t tmp[8U] = { 0U }; uint64_t *r0 = hash; uint64_t *r1 = hash + 4U; uint64_t *r2 = hash + 8U; @@ -494,16 +495,68 @@ void Hacl_Hash_Blake2b_init(uint64_t *hash, uint32_t kk, uint32_t nn) r3[1U] = iv5; r3[2U] = iv6; r3[3U] = iv7; - uint64_t kk_shift_8 = (uint64_t)kk << 8U; - uint64_t iv0_ = iv0 ^ (0x01010000ULL ^ (kk_shift_8 ^ (uint64_t)nn)); + uint8_t salt[16U] = { 0U }; + uint8_t personal[16U] = { 0U }; + Hacl_Hash_Blake2s_blake2b_params + p = + { + .digest_length1 = 64U, .key_length1 = 0U, .fanout1 = 1U, .depth1 = 1U, .leaf_length1 = 0U, + .node_offset1 = 0U, .xof_length1 = 0U, .node_depth1 = 0U, .inner_length1 = 0U, .salt1 = salt, + .personal1 = personal + }; + KRML_MAYBE_FOR2(i, + 0U, + 2U, + 1U, + uint64_t *os = tmp + 4U; + uint8_t *bj = p.salt1 + i * 8U; + uint64_t u = load64_le(bj); + uint64_t r = u; + uint64_t x = r; + os[i] = x;); + KRML_MAYBE_FOR2(i, + 0U, + 2U, + 1U, + uint64_t *os = tmp + 6U; + uint8_t *bj = p.personal1 + i * 8U; + uint64_t u = load64_le(bj); + uint64_t r = u; + uint64_t x = r; + os[i] = x;); + tmp[0U] = + (uint64_t)nn + ^ + ((uint64_t)kk + << 8U + ^ ((uint64_t)p.fanout1 << 16U ^ ((uint64_t)p.depth1 << 24U ^ (uint64_t)p.leaf_length1 << 32U))); + tmp[1U] = (uint64_t)p.node_offset1 ^ (uint64_t)p.xof_length1 << 32U; + tmp[2U] = (uint64_t)p.node_depth1 ^ (uint64_t)p.inner_length1 << 8U; + tmp[3U] = 0ULL; + uint64_t tmp0 = tmp[0U]; + uint64_t tmp1 = tmp[1U]; + uint64_t tmp2 = tmp[2U]; + uint64_t tmp3 = tmp[3U]; + uint64_t tmp4 = tmp[4U]; + uint64_t tmp5 = tmp[5U]; + uint64_t tmp6 = tmp[6U]; + uint64_t tmp7 = tmp[7U]; + uint64_t iv0_ = iv0 ^ tmp0; + uint64_t iv1_ = iv1 ^ tmp1; + uint64_t iv2_ = iv2 ^ tmp2; + uint64_t iv3_ = iv3 ^ tmp3; + uint64_t iv4_ = iv4 ^ tmp4; + uint64_t iv5_ = iv5 ^ tmp5; + uint64_t iv6_ = iv6 ^ tmp6; + uint64_t iv7_ = iv7 ^ tmp7; r0[0U] = iv0_; - r0[1U] = iv1; - r0[2U] = iv2; - r0[3U] = iv3; - r1[0U] = iv4; - r1[1U] = iv5; - r1[2U] = iv6; - r1[3U] = iv7; + r0[1U] = iv1_; + r0[2U] = iv2_; + r0[3U] = iv3_; + r1[0U] = iv4_; + r1[1U] = iv5_; + r1[2U] = iv6_; + r1[3U] = iv7_; } static void update_key(uint64_t *wv, uint64_t *hash, uint32_t kk, uint8_t *k, uint32_t ll) diff --git a/src/msvc/Hacl_Hash_Blake2b_Simd256.c b/src/msvc/Hacl_Hash_Blake2b_Simd256.c index 1a5e8cf2..7a807b65 100644 --- a/src/msvc/Hacl_Hash_Blake2b_Simd256.c +++ b/src/msvc/Hacl_Hash_Blake2b_Simd256.c @@ -26,6 +26,7 @@ #include "internal/Hacl_Hash_Blake2b_Simd256.h" #include "internal/Hacl_Impl_Blake2_Constants.h" +#include "internal/Hacl_Hash_Blake2b.h" #include "lib_memzero0.h" static inline void @@ -214,6 +215,7 @@ update_block( void Hacl_Hash_Blake2b_Simd256_init(Lib_IntVector_Intrinsics_vec256 *hash, uint32_t kk, uint32_t nn) { + uint64_t tmp[8U] = { 0U }; Lib_IntVector_Intrinsics_vec256 *r0 = hash; Lib_IntVector_Intrinsics_vec256 *r1 = hash + 1U; Lib_IntVector_Intrinsics_vec256 *r2 = hash + 2U; @@ -228,10 +230,62 @@ Hacl_Hash_Blake2b_Simd256_init(Lib_IntVector_Intrinsics_vec256 *hash, uint32_t k uint64_t iv7 = Hacl_Hash_Blake2s_ivTable_B[7U]; r2[0U] = Lib_IntVector_Intrinsics_vec256_load64s(iv0, iv1, iv2, iv3); r3[0U] = Lib_IntVector_Intrinsics_vec256_load64s(iv4, iv5, iv6, iv7); - uint64_t kk_shift_8 = (uint64_t)kk << 8U; - uint64_t iv0_ = iv0 ^ (0x01010000ULL ^ (kk_shift_8 ^ (uint64_t)nn)); - r0[0U] = Lib_IntVector_Intrinsics_vec256_load64s(iv0_, iv1, iv2, iv3); - r1[0U] = Lib_IntVector_Intrinsics_vec256_load64s(iv4, iv5, iv6, iv7); + uint8_t salt[16U] = { 0U }; + uint8_t personal[16U] = { 0U }; + Hacl_Hash_Blake2s_blake2b_params + p = + { + .digest_length1 = 64U, .key_length1 = 0U, .fanout1 = 1U, .depth1 = 1U, .leaf_length1 = 0U, + .node_offset1 = 0U, .xof_length1 = 0U, .node_depth1 = 0U, .inner_length1 = 0U, .salt1 = salt, + .personal1 = personal + }; + KRML_MAYBE_FOR2(i, + 0U, + 2U, + 1U, + uint64_t *os = tmp + 4U; + uint8_t *bj = p.salt1 + i * 8U; + uint64_t u = load64_le(bj); + uint64_t r = u; + uint64_t x = r; + os[i] = x;); + KRML_MAYBE_FOR2(i, + 0U, + 2U, + 1U, + uint64_t *os = tmp + 6U; + uint8_t *bj = p.personal1 + i * 8U; + uint64_t u = load64_le(bj); + uint64_t r = u; + uint64_t x = r; + os[i] = x;); + tmp[0U] = + (uint64_t)nn + ^ + ((uint64_t)kk + << 8U + ^ ((uint64_t)p.fanout1 << 16U ^ ((uint64_t)p.depth1 << 24U ^ (uint64_t)p.leaf_length1 << 32U))); + tmp[1U] = (uint64_t)p.node_offset1 ^ (uint64_t)p.xof_length1 << 32U; + tmp[2U] = (uint64_t)p.node_depth1 ^ (uint64_t)p.inner_length1 << 8U; + tmp[3U] = 0ULL; + uint64_t tmp0 = tmp[0U]; + uint64_t tmp1 = tmp[1U]; + uint64_t tmp2 = tmp[2U]; + uint64_t tmp3 = tmp[3U]; + uint64_t tmp4 = tmp[4U]; + uint64_t tmp5 = tmp[5U]; + uint64_t tmp6 = tmp[6U]; + uint64_t tmp7 = tmp[7U]; + uint64_t iv0_ = iv0 ^ tmp0; + uint64_t iv1_ = iv1 ^ tmp1; + uint64_t iv2_ = iv2 ^ tmp2; + uint64_t iv3_ = iv3 ^ tmp3; + uint64_t iv4_ = iv4 ^ tmp4; + uint64_t iv5_ = iv5 ^ tmp5; + uint64_t iv6_ = iv6 ^ tmp6; + uint64_t iv7_ = iv7 ^ tmp7; + r0[0U] = Lib_IntVector_Intrinsics_vec256_load64s(iv0_, iv1_, iv2_, iv3_); + r1[0U] = Lib_IntVector_Intrinsics_vec256_load64s(iv4_, iv5_, iv6_, iv7_); } static void diff --git a/src/msvc/Hacl_Hash_Blake2s.c b/src/msvc/Hacl_Hash_Blake2s.c index 652c3f33..1bae785b 100644 --- a/src/msvc/Hacl_Hash_Blake2s.c +++ b/src/msvc/Hacl_Hash_Blake2s.c @@ -26,6 +26,7 @@ #include "internal/Hacl_Hash_Blake2s.h" #include "internal/Hacl_Impl_Blake2_Constants.h" +#include "internal/Hacl_Hash_Blake2b.h" #include "lib_memzero0.h" static inline void @@ -474,6 +475,7 @@ update_block(uint32_t *wv, uint32_t *hash, bool flag, uint64_t totlen, uint8_t * void Hacl_Hash_Blake2s_init(uint32_t *hash, uint32_t kk, uint32_t nn) { + uint32_t tmp[8U] = { 0U }; uint32_t *r0 = hash; uint32_t *r1 = hash + 4U; uint32_t *r2 = hash + 8U; @@ -494,16 +496,65 @@ void Hacl_Hash_Blake2s_init(uint32_t *hash, uint32_t kk, uint32_t nn) r3[1U] = iv5; r3[2U] = iv6; r3[3U] = iv7; - uint32_t kk_shift_8 = kk << 8U; - uint32_t iv0_ = iv0 ^ (0x01010000U ^ (kk_shift_8 ^ nn)); + uint8_t salt[8U] = { 0U }; + uint8_t personal[8U] = { 0U }; + Hacl_Hash_Blake2s_blake2s_params + p = + { + .digest_length = 32U, .key_length = 0U, .fanout = 1U, .depth = 1U, .leaf_length = 0U, + .node_offset = 0U, .xof_length = 0U, .node_depth = 0U, .inner_length = 0U, .salt = salt, + .personal = personal + }; + KRML_MAYBE_FOR2(i, + 0U, + 2U, + 1U, + uint32_t *os = tmp + 4U; + uint8_t *bj = p.salt + i * 4U; + uint32_t u = load32_le(bj); + uint32_t r = u; + uint32_t x = r; + os[i] = x;); + KRML_MAYBE_FOR2(i, + 0U, + 2U, + 1U, + uint32_t *os = tmp + 6U; + uint8_t *bj = p.personal + i * 4U; + uint32_t u = load32_le(bj); + uint32_t r = u; + uint32_t x = r; + os[i] = x;); + tmp[0U] = nn ^ (kk << 8U ^ ((uint32_t)p.fanout << 16U ^ (uint32_t)p.depth << 24U)); + tmp[1U] = p.leaf_length; + tmp[2U] = p.node_offset; + tmp[3U] = + (uint32_t)p.xof_length + ^ ((uint32_t)p.node_depth << 16U ^ (uint32_t)p.inner_length << 24U); + uint32_t tmp0 = tmp[0U]; + uint32_t tmp1 = tmp[1U]; + uint32_t tmp2 = tmp[2U]; + uint32_t tmp3 = tmp[3U]; + uint32_t tmp4 = tmp[4U]; + uint32_t tmp5 = tmp[5U]; + uint32_t tmp6 = tmp[6U]; + uint32_t tmp7 = tmp[7U]; + uint32_t iv0_ = iv0 ^ tmp0; + uint32_t iv1_ = iv1 ^ tmp1; + uint32_t iv2_ = iv2 ^ tmp2; + uint32_t iv3_ = iv3 ^ tmp3; + uint32_t iv4_ = iv4 ^ tmp4; + uint32_t iv5_ = iv5 ^ tmp5; + uint32_t iv6_ = iv6 ^ tmp6; + uint32_t iv7_ = iv7 ^ tmp7; r0[0U] = iv0_; - r0[1U] = iv1; - r0[2U] = iv2; - r0[3U] = iv3; - r1[0U] = iv4; - r1[1U] = iv5; - r1[2U] = iv6; - r1[3U] = iv7; + r0[1U] = iv1_; + r0[2U] = iv2_; + r0[3U] = iv3_; + r1[0U] = iv4_; + r1[1U] = iv5_; + r1[2U] = iv6_; + r1[3U] = iv7_; } static void update_key(uint32_t *wv, uint32_t *hash, uint32_t kk, uint8_t *k, uint32_t ll) diff --git a/src/msvc/Hacl_Hash_Blake2s_Simd128.c b/src/msvc/Hacl_Hash_Blake2s_Simd128.c index 73f0cccb..f0646b28 100644 --- a/src/msvc/Hacl_Hash_Blake2s_Simd128.c +++ b/src/msvc/Hacl_Hash_Blake2s_Simd128.c @@ -26,6 +26,7 @@ #include "internal/Hacl_Hash_Blake2s_Simd128.h" #include "internal/Hacl_Impl_Blake2_Constants.h" +#include "internal/Hacl_Hash_Blake2b.h" #include "lib_memzero0.h" static inline void @@ -214,6 +215,7 @@ update_block( void Hacl_Hash_Blake2s_Simd128_init(Lib_IntVector_Intrinsics_vec128 *hash, uint32_t kk, uint32_t nn) { + uint32_t tmp[8U] = { 0U }; Lib_IntVector_Intrinsics_vec128 *r0 = hash; Lib_IntVector_Intrinsics_vec128 *r1 = hash + 1U; Lib_IntVector_Intrinsics_vec128 *r2 = hash + 2U; @@ -228,10 +230,59 @@ Hacl_Hash_Blake2s_Simd128_init(Lib_IntVector_Intrinsics_vec128 *hash, uint32_t k uint32_t iv7 = Hacl_Hash_Blake2s_ivTable_S[7U]; r2[0U] = Lib_IntVector_Intrinsics_vec128_load32s(iv0, iv1, iv2, iv3); r3[0U] = Lib_IntVector_Intrinsics_vec128_load32s(iv4, iv5, iv6, iv7); - uint32_t kk_shift_8 = kk << 8U; - uint32_t iv0_ = iv0 ^ (0x01010000U ^ (kk_shift_8 ^ nn)); - r0[0U] = Lib_IntVector_Intrinsics_vec128_load32s(iv0_, iv1, iv2, iv3); - r1[0U] = Lib_IntVector_Intrinsics_vec128_load32s(iv4, iv5, iv6, iv7); + uint8_t salt[8U] = { 0U }; + uint8_t personal[8U] = { 0U }; + Hacl_Hash_Blake2s_blake2s_params + p = + { + .digest_length = 32U, .key_length = 0U, .fanout = 1U, .depth = 1U, .leaf_length = 0U, + .node_offset = 0U, .xof_length = 0U, .node_depth = 0U, .inner_length = 0U, .salt = salt, + .personal = personal + }; + KRML_MAYBE_FOR2(i, + 0U, + 2U, + 1U, + uint32_t *os = tmp + 4U; + uint8_t *bj = p.salt + i * 4U; + uint32_t u = load32_le(bj); + uint32_t r = u; + uint32_t x = r; + os[i] = x;); + KRML_MAYBE_FOR2(i, + 0U, + 2U, + 1U, + uint32_t *os = tmp + 6U; + uint8_t *bj = p.personal + i * 4U; + uint32_t u = load32_le(bj); + uint32_t r = u; + uint32_t x = r; + os[i] = x;); + tmp[0U] = nn ^ (kk << 8U ^ ((uint32_t)p.fanout << 16U ^ (uint32_t)p.depth << 24U)); + tmp[1U] = p.leaf_length; + tmp[2U] = p.node_offset; + tmp[3U] = + (uint32_t)p.xof_length + ^ ((uint32_t)p.node_depth << 16U ^ (uint32_t)p.inner_length << 24U); + uint32_t tmp0 = tmp[0U]; + uint32_t tmp1 = tmp[1U]; + uint32_t tmp2 = tmp[2U]; + uint32_t tmp3 = tmp[3U]; + uint32_t tmp4 = tmp[4U]; + uint32_t tmp5 = tmp[5U]; + uint32_t tmp6 = tmp[6U]; + uint32_t tmp7 = tmp[7U]; + uint32_t iv0_ = iv0 ^ tmp0; + uint32_t iv1_ = iv1 ^ tmp1; + uint32_t iv2_ = iv2 ^ tmp2; + uint32_t iv3_ = iv3 ^ tmp3; + uint32_t iv4_ = iv4 ^ tmp4; + uint32_t iv5_ = iv5 ^ tmp5; + uint32_t iv6_ = iv6 ^ tmp6; + uint32_t iv7_ = iv7 ^ tmp7; + r0[0U] = Lib_IntVector_Intrinsics_vec128_load32s(iv0_, iv1_, iv2_, iv3_); + r1[0U] = Lib_IntVector_Intrinsics_vec128_load32s(iv4_, iv5_, iv6_, iv7_); } static void diff --git a/src/wasm/EverCrypt_Hash.wasm b/src/wasm/EverCrypt_Hash.wasm index 101c3f6834aed5d76bde19f1242639e8d080fc39..a5f05d9df8aef198166f523bcfafc86a034516b0 100644 GIT binary patch delta 2618 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 WhO`M6;3WL3;P`!~{*%|*O8yJ9{>>u* delta 3225 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 diff --git a/src/wasm/Hacl_AEAD_Chacha20Poly1305_Simd256.wasm b/src/wasm/Hacl_AEAD_Chacha20Poly1305_Simd256.wasm index 804858db6a6f1d2e5bcd87ce4d19d24b3ee151b1..1f8a5cdcf868a456c4d9d3172497246f4e1dcd14 100644 GIT binary patch delta 191 zcmeyy_l<9YJTr5B{X{Xji4HAXNvS3IIjP1*42%=s%d;4oF)&SD#i+>0Jn_9GS7J_P zdS1Ml2?NW-a|(>ClZ6;H8QCV=Fv>BqPp)Is-h7(Th!M#A$D|7+b(k$BIHVjIG#D5h v4=^|~=7120mnFb5xt4jEI80IiLoP;EQ9waJ0Hy##_hyy}j4Yd7SdEwfMYJnt delta 200 zcmeyy_l<9YyewlqV|@Z+9aBA!1T*0TbAA0pn~upkjGT;&lg$_v7?~!XlV>qDVql&e z&Zx=AGP#jaj*)fZIVDE6$qN{@8QCX(RNQ=;(TI_eb@D$ZT_CB$Y$?Gm<;bAHz~Fd* u!I3csgh0G30mjL-%*(`Kk^&fVF|vvR3IYN!1sJ+FvrJ%Q-0Z??!~_7Kr!6Z0 diff --git a/src/wasm/Hacl_Ed25519_PrecompTable.wasm b/src/wasm/Hacl_Ed25519_PrecompTable.wasm index 46a7380db06358dcdef5459264c6b9f1dc726630..c94538f0c5740cc5e275c8a82bc368902b64046d 100644 GIT binary patch delta 103 zcmX@yz<9WUaf19rOQDIXA`|_&Ci=&5C8d_+=cF1NF)&UnlxHzCV_=#*nNg9Ed19gD z#I>A^EEBgYFtSekt*OAq9iCX68(dmYkY7|HfW(e3DM~D0V4s}MsJ(d$W4|2$i_0N6 delta 83 zcmX@yz<9WUaf19rZ7F8v`ud5E5)=JdCq{;FCFW$N=f#_uFfdM*XH;Nhnph~$Vr;~~ mJlTO!laXa|7NZ;^D@e@HjDc-(C!;na`@~y{o3}9b+W`R5?G`8i diff --git a/src/wasm/Hacl_HMAC.wasm b/src/wasm/Hacl_HMAC.wasm index c2e51b851c0e3a3f21be3160b08d2c2ff85f9351..4837783c3caf2566c5fc53b594b01adb3cef5172 100644 GIT binary patch delta 4288 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 delta 5458 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 TDE^IRbh)mG^qKc<YwrI5EN&gr diff --git a/src/wasm/Hacl_HMAC_DRBG.wasm b/src/wasm/Hacl_HMAC_DRBG.wasm index c1cb2fd3971da9dc9404845d34abd70b20e02953..f536237d257cab3f5b8333ade11525929c819beb 100644 GIT binary patch delta 1155 zcmdmTjB(2`#tBkN%=Pv4jP(hOV4{wx9>zonPV^I-7|l5`dii8kMo~tl$#IMdjLehk z88sPMCZAx`W@MeXL7v6XjDc<921%~OoXqsRcrz0Q_Q@+5<#;$aJra|1;yrvFoy8^> zFo|v!VG?HMV^vgeJiy?{m;*!t%#%%7Gk94QB^(XlBCEh60*(rB5qUO{8V*MhxX2W? zE}%h<$Oh@KgA`dJ8MF{AVu)mr7zap=CXzwj963P${NPYzWS=a>d5Dp9@?B18M)u7= zIcu3DSfv~pG#D5ZwlYF22J^B6*f;m_{APs99!8g4$oGj6ZqNn+2PPorqmUTTR1V>H z2z`^#_3?>5L+BF}H)IlrIUpF#{z%DfAe92rqCi8{q&Fe7eU(Adri7-=R(=~J+)QYI z!~Mji2zK>fB?+LJV#>J)hxVg8bhgTSgzQ{&*+ps}LGFPVv{u6z#QCTRaw)skDun%| zXpTFfy$hjjjxJc+13i$oZ+fdhG7Akrob3i15Xu^joDl|!qZxSH7|AwOG|4%p5lm97 zil><&F?^C4O`gv}10??vD*qf^KEP@ZGtf=EcA(Hwv(o^@vA+X|li{!o#Nl@aaWtG2 zLB?ETf>?8f3C)^h*VQ0n_&vdjJ;92XLG4_EZfCOh0+3-#86k!(Mh|#dKShwu_5mQn zA_7)30~LRTD*lY2I0T|N46Hb88c65+2v8zri@XYqT}1<kEqZ7!{v4&r43tfR$R?o4 cn#5gYlw?(GfZAGzCasiE&&0?vc~R0N0BeEz^Z)<= delta 1156 zcmdmTjB(2`#tBlqjP;E53C#8NAc}FKtmMQXp^4F)6Qh?;+#}3lXvV-a@tYze^TZ93 zlTR~pGO|pTU{qjaoovadsldh^o>-h4Tv||&UsNK1#Evg1N-SVtpPbC7&BMXzk(itl z@8Rp{EH=4-Np!OalQ1(MhoXYx0R~6L93T>4oovdQ!ONj2;b;ICSp^mma8!Vc$g_de za5##<MW(QI0S$6QHb{pZq{tG<poL%&LnMR5I6!JNkqqkQ$N_rk2Ztiids3W-7&#{2 z<&<V*+5D5UmPvv`%8@~Xfk9y_BgA4bFH3-Bb05!dM!4)@blHV`pBUi=Z4hu^0&+eI zi2+UJ5PpZyHwj%IpXf7$K0$FqCUKYpg3;`cl-veVDIhHhG*nG`6GGcp86<5=XxeP$ zw=u%aga)`H$cG?5aVdgb{Z~l>Xr`EQF2bSx=nkE&@*W{O7hQId+DDLkAO@|~a0YQc zYJyzKuC)qbe<_;dPH68!Xq%%8*7iUTr0tvDDv-=V0}yAs!3Kn~Mk8m0f#PTe-Zn<E zO%+XYj%fsw6o=wzW=C)gpJYap=d;iN$-jikKS!4ju-d~6bQ7-~D74h<G(d6e?*QUt zI4lEk_?<x<4QEA=G1r(N)?8sivnJVfHOLr#Pq1Q7u;OJ<JC~r_ne4p)WY|(hh+&J- z176lo5oEJ{0LZY2fYr=E#b2R{KVv8kfhZ0GD-N3m()m6Dlt|ekuL5IN(EwtL9-50k nM`<zxWs@MX323q=aaS27ITRb9w$`CZD<#x3F|toylr#wd;dB09 diff --git a/src/wasm/Hacl_Hash_Blake2b.wasm b/src/wasm/Hacl_Hash_Blake2b.wasm index 8882f5e8e067fb9b2b6200202086898da5be147b..e158bcd8aac1e1d388d9c8c80ac7d80e0b477863 100644 GIT binary patch delta 2111 zcmZuxOK%%h6uvWKC*zs1J$}R<J5KzaxFL31w@KRCN&3o-5Gs#~4LguRfFR<eESj(Y zL>v$<Qbm!f`2nauzzY;qHb@kS9{?McKv^RpkSeh$;v7419FZu}neRNl^YFRn?+@?o zCe_;ZEkh|~JotETPX+gr&l=WOH#bcE#UA6h>%|jEKb6j8$8!0R&qQammEJSl(R-gT zaB?@+-rQQfv9|rr>dMyI=KA~_s~hib>?m(C{MRgu-g<9qXG0~zr)Jqmh7(q?l+OP@ z;`aLX`i{y391@r+8{V>t#jz8Z-@d)Ru5#f6i?aFHTWdROtJ@nNtXrmY_lXp{|FiXb zF!Ie^{vHc|nnA_bb=%gi)z0i{RaJ^cwM{l`f3(=c+SW$+V6NDXA-1BLN`V!dWLwMp zp<awE_q-5eWN)<)tEnL;ttd((h+?FnlxIW@*F}sRC~~26L>pTYL>>cX?SnW2?+_&P zpHCk?`N(&uokWtk$scG^NY#{0>474HOilTe9Vo^yR#O4x28ulLH3bR=iUJBXRi)xU zF^=(?nx)b}F@cGiTA<0Bh{Kom<48A^%_7@WK8sva1xO$eTLML~B~TJu0+VdhK9x}( zjMJCajPS2|{&fIaEpb>`CR*l+mWL(^QS(GmS3^!GO%z0&WC~L!BzdKRN<YbzB$?tQ zQ$tBAj3i0rAW7fpq$CwO)!zq0M|%4(jcNU;SJ|{AFc=z3%Iph^g=(lsU)X)&iCE&n z^h65NpoYq_IMv`0PSZ1-cZLg`(dP4qd*vK$Nfqp%!PDDnRn>f!{cHh(sfL<t$7!6V zGdM$MQSF&qI4i%)j5b;{6Jj>ku5*I=u>>Q+A!~T<Sb~7vj`+{xyztLrmgX==^ElTt zw=ggKb>Xj{G&Toj7e-gx-8((@cEA3*GP~M8&>gC*t`3f=sw&de=-%n@pQLe)6=-*l zL9g#B`#0=YSN^bHyRK5bYM9W6BQH9DBduK!VbetsK3x(KP(uW$DWXaXB4%k(!~!kB z$Au1EMj978bOl*l>d;l>(CE-L1ZZ~XI*M56&@xI`?2yJJURdhT3S3;4eq3CUa$Q`N zVq9F4Vmw?In}=nwdC+3>up&=MVf1Lo`(Kw{8u1fFC>Std@mq}e$<VKCQoM+WR?qQ& zq>V_=!9&#dqy1;?M#KA)mGHYtx#YWWn9?RbV2JURa)0}jPort>X50J0DQ#AG=N>8F zD{^B|_OvL%sUqU}r5tzmbizLt7Gs>S?-*X64Z_c--FA%K9bPv_+k<^(T?<Z2ZfAeH z1RXp+N47|+Im&T(GcnrWVQ_F)rV%5Ty*#G&bTFV+LhZG{HXZP*Nb|e)4!J$y_V!m! z7c3(YzE=OyNbJ|o?F)E3_bY?%=gkO%9~xUma(}K_He=s*`t9Yy_ZR<};3ICx6y)SZ zd8QUjKUL(8iSKZ@*er#=Ty|&DNcXQzO0G?cD@+Ytn=~W2HtFzX;8moFFE(Y7(Kvj@ zV~A4@@uNqd=SBmj33O!8XqM67W%AD=sKqNRYZFMHLHKwvbBQAh99bBO9Ak78neU;) x$bv)`I5NAOp(2Vj4n-vxG{GbjLtT^@8JoRE#s{AVKcQG?LP(5Ec;)KD{{R&Ekfi_s delta 1933 zcmZ{k&u<%55XWb|n`Z6x+UwtI$BE~;NxYl5iJO!-4N;Y?5DMz05)wT|E_F$4=Rgxw z0m5q}0$eJ!+5-~ez&{YA$Wkv{I3o4Ji5sefxP$m1xF9iaU-A-dsbuTzeCO@ge(y6g zkA}a0n1;^5z5)QsmmiNtP<oPn?a9O3$^PwF<I#wOq>(gJX)BY><qO42pK(d?!5b;Y z<e&V7_)Jh!%ai->4G#Cf3})1tk_v99m1?H6-FbVkv)wt^-MKmF^t&r}cOG;Px`&Xp z=@mP8S1r7CZ||M%!6D>}FYdknpxcE)?Zw0{cYL^axVzKuz7NItz0P50=V0%Ht{O`` z{)7MJ@!#st_P9{rzGRsd1XM7FDw?QSsbJsf+sO)Q9=uK;%||WVki-cq9sK6p+DIFi z@PO$ojylHI0E{2$)R2h{%f2#HUiwvs<2$Yw^H~Wk4?KO~DTAH^ny1kNg*|3R68c%9 z97!b45*6>)f1m#Kk(FRmIOPJcsuZSi+6A4>NTG%`7cAzZR2VWBY*v@TWxVVHvRNt2 z;hYN&o0mcZ8!oh%BLx>-7uMMVma*Cfpk<~FIxW}+i<WvDY^>lc&sA`~4ZcpR!;=+U zpri-Ko__o(Tg2+k(dZK$7rpP`_~__}HL-+E{$5FVmV{?Xc-q3#=AJs*!qN^cv4|5y zNM#yP)i|Lqj)+h;HZ*)C_@z3fszWXKc5%b!4F8`+B9f3Sj7UPVNXk1g(c~;rQb=Q( zv#_L)!A!^^E0rAPIE%a#3RvJQic%<HiL<b!P{uN65vhT7Rz(9-{N4<-_}v(o<=1Us zp0h||k>`?Vx8bf%YlSD1oStMcjVZxm`i#X4#yJF_CG?C7&$#eR2+suf)G;9}6QO1B z&59j7TQJsYL<H3>L{EQ1+w#C6Gtzp9y$d%=(G`FV%Au$97zQWJ+&0#5a*d2>`!WBs zHO9!SPG)t_mS(`s>OG{KXNS#2(WzOTo7KlB&9bVP!L#Kb6m$GlYs`b&*Pc_*dL^b& zuzG!<q{d%guf^QQpNo=7y|kfuv#Uch`2N*@e3n7;ypgjM$b!jHAd4iz7ovRiC|@he z*N*l$Qjhy*V<2pDhedk4747kLHj6m{EhnJm1hiZT4f6tao_Cy15p}Ue3w5!L6QW<| zuqbL|4wd6KdB4tMhBqV764pURSZ0J}R#;|*WmZ^bg{4KacY+43iZRQoP|Y!#Gr>=r zjcX1%URVwdPwBG;A#Zqa>#TkpifD+UbBbAP3R;_a-(fVFXe_xN6;fCYY!OY?yol)v zRnZbzE_s@)q6Lb=(Ht5#!>C8y%+IyNt7wT{I-mVXWkN9wl9tJ5`P?VCzcC-IZf3Sz q*1{IMiojM-VXL%j^}+#GC{p_2PhFLdr-$Jgw#pBqxWSzpPyYj>1*#VS diff --git a/src/wasm/Hacl_Hash_Blake2b_Simd256.wasm b/src/wasm/Hacl_Hash_Blake2b_Simd256.wasm index 2724451529574975575f03f42e29974896d5d9f5..d144e065bcafff0663829218e54e65f227f2eb9a 100644 GIT binary patch delta 697 zcmZva&1(};6vgkGkIc+_FUjPyV-$L)0b>^m7Mn^|eO(Ar{R<S+u?EQ`v0&oHg^4Z{ zyC}p5et=-tf<m2tz?CStaO2kQx)2oHy7ErM>Oz>socqrF=A1jTy{ymXAsP-C0I(-_ zCljbn^DSmhH;(LGPFQ1SLZht5h0NyiexX<@S27RM85@H-$Oz~2JrZ0O%%e{CMt21K zxNaMvGq}|sbwTPYM#IP=jcVQ?>i4%c!Jki+d$Tj_jG&Mnp#eqx-B@5H!k|%Zqy~M_ z%#|zNwP+Nzhuzy9lktZy(=2+++^z4XNe$zUGgfc{Aas-)y6E~&ZKjp0n2!9~84tZR zSOGv9^g`EMr5jkcR%b5sNV)wOy+!!Pr1$*tF)!o@p{Rp;#A4qDbQFYkm_ZveiLfqY zd|5+4h6b9LMa$3X>%13;8d?g@(PfR%ni(Y8eolYo>nx|6Vw*kJ^RnW-NY_RMxZW2n z%B0?c&udy1gRvP}#I%}J%cGZa3eA;!{xGzH7<rr)q40`Pejc9$Xi-b9SR8VC=r2Pu zn+ZWxohG<Qz*j5aqZbNtNkU5%9HJpbpO!Jwp$dMp<sY_8+44VZmDHteGN~8ypO{R3 z=95&sF71=pDSu?_jlNVJ81F5OvaG*UgM|<FY^7;XH>8h%9+eg1+kM&zgF1)<9n3w= eul1u|XX$EtX}Nid{w=)`O!d3D$H|Z28T$pe!HD$$ delta 367 zcmbPi(PhfdkXW3{$iTqBIH9qjfkAX4ztzToV~py(4L}|bCl@ylFCV{vppdW#TRTXI zv7W*4BO5pSmL?#FQ*H7FCaKB%%xshEnb?`QRbgEA_?*Pz5(b{h>zS08_~k*u>_w@? zsU-{oKp|<M4t7RC5Q{S<Gd&fkQb-Q0Caownl|fh?Y)lz5pNI%&N@7W3d~s$~Dl;S3 zyyYM_O`gHLVDnuT4>kdADFp@vMg=AXW(8ga76G2grrg<#T$2}ai!t&}-ofn+Bw2X6 zm?kk!p1>o*c@yM(CZ;;}$!mG6*c3UH85~zk?&lHRe1i826C?NJy#f~)xi|L-Ze|8@ zoJ8*fIZ9$@7#a6YelMQObeRQY$mAjk38gEnSpuvK3S5p1iX4iZ3LFZYW(*A6+&|ht g!NZ`;!2NOZ8i^T`&q=Of0r`1yz0}0bRZ=q<0iKCtHUIzs diff --git a/src/wasm/Hacl_Hash_Blake2s.wasm b/src/wasm/Hacl_Hash_Blake2s.wasm index 0dcaff92fc840a8a399b6410fb14041d83f27baf..f9d6889edb710d8b1845bb009261b1fd960d68cb 100644 GIT binary patch delta 2058 zcmaJ>%WoTH5dZe!WWBq#*Y?_8Z~U0C>)LJN=F!$|leEnjL6nL^#T5=wL{kyh1*sc^ zKmrE}syKkuu2hK&f&<4MP*ene0umQa9MfBma6v+<DwtWPYez*$md5k?&CGA-o5#1G zy_*r+!EHqdp?vqr{=V?;XI{~?;qZs+*Hrn{K3P(hol0k%Y%cE>ilwQ0Y*U6p?km>x zm!Fbi7B{!w8f<ND2XAk!54LaZECpM;@9gdgyB0oC%hR{t8|>|hba<%Nl}z}L>Q{25 zmox6{1Uq{o?@@}U3OBs2`F`O)kZ<1E*%8I?u7++Yd1HHTdn?%ea7R<jhflfLgP*i! zY5435`md@VUl~f#5dx>Bfd&}Pv>)lxkjg;ngGlK+suY;ODM-LnkAjnsl!E>MMcqO} zTcbbXHGM6Lh9qhFpbtsH9S0plu*1VvVhBkzL7)Xf>Z5Xfv`IOt-NzIu_6tv1{_*_B zzdmwI%s_@)c49*ovK^sgE;i&L-w_77v7rEkj<B&98%j_bc7%goY$-#zBV6=j!wk%H zgol;bP=#toRImmqaCop3<a$CU;r4_<qSzBQq`_lf8hrMpp~Aj2)W}B^*P$L${CYGe z(aay<C5{0=ie*BoGskt}xIV!#u$ef9u9yf4e{1D$03cGO1~lSI|68aD%~7ES7iv(U z#zdheX<VpzRA>~$g>-1*iSW->bJ&8G1a7s(Kne+ES*RnSv5}dGgu!BkSc)RkBawj? zU{5$CPV|HeEj&rf(xyh*QoZ(KtIY9^bbtb+H{izT8!l2DZ7LB-I-Y`4yd0<DG|s{- z&Os+~_hF7dOIs>^Y*YKiH@j4zd#u0|W6<W}nPUZ93LE3k!#v|JzydD9A}+z1$lZq} z#_uwIm+2XT2`VVk*qZ?B3RODC4Vv`!f*{~zb0U)VnOQq-GI*CJP4h(Mn2WARkI{$B zMptAacwS7C+dj)e$8#(UJkP?$9t#IAuyFAr3lA@`sNga<a5lgd$icY)SHXqz0bYh8 z^a8vB9$X0UD)?|Qz%{7Ar2r+=U^&3`4X|K^r?Oy`C$Zo%cW=QJZpMbI?6YBweKtt; z*|5&9M8Nd;SRDNBmo+Etg8+s2)aaS%PUb;vWi#c2F2x4@^dabx--3kWBu4MmN{ozB zJYuT_CV?7sx(rBCY3uN_(E)T1?$*}T1}zjgwoij4C{9D2O3@b();D~>=}?;CYGaui zi^9Su^=6N5Aeyv9rZnO$C0ifNKHo!WL<>pU(bF+`H_Y%`a9>TrG!IPCk1o*SC($A- zo3L!@#aM!|>^_k1XxT|S!m<e~yk9RIe0}0qRY`|8+YgoW!SnV98Y%D3eosnu?iW^` z&i9neL2Y41P5%7(Xp~~OzVvs6j=91UJ47jSrGe^XeF;d{G`x52WIG4B(P7B)VaQT< z*@?rDBaIJ3F5IZ%8#$zti!S7)!;gp`VgXWEgw*)imS{$gP&}!}GrFvCe1uhuv_35= zFNeo`c_E(7pQp?+WtJy03#`SNrAT{`S?0_#Wx8v5^ufm&5Lf{Ps{~S=7@|U&ax1Dm S6aPJ;m_1l!5GDVh_xNA!-F!6w delta 1802 zcmZuxL2u(k7@dh->cmds#7^S4Y4c6eG)|hP-L%aL_R?7`OIM4;eGfzt6tQV45Ge<c zAVFG*69+Kjz<D|D0fhx|<cI`6fCD#996$(=K!C*ec@k4aNS4Om`(~a!@6DUPUU__x zWy8q@XN>WW-<i!=>HX}jPwzdQXudbY$}+8VCTr*Nj$0@`@h(Ap%H)ij>%Y<L<W|VF z^7_T=<IDRj{ef2HnGiIe=fWFWIg$6U>m`^IzN-1YTRa`UFdm!^Cod0fj)&)Gy~*IE z*UrvZA$+I_x0rl!csU$Q?!S4a@zgIr(AVeRY4y_l?`lD_(>^fZkN^$Rpxc>H)Nh<x zKIoF&#z&um9!)S|&CagLpa1#%_qWV71xogaP!m#;2}2~ofMlOB^E2EKOC;WI&mY!r zCUj8(J3KfnPCc+Clg3!`@hD)rH1I|0<B=$@G^}OAS0A)fVgoh;#zZ9sHenMv#8wPc zp&BqlKnw^F0kcGH2~0&D>H)LG_7V{dXavj^J2B9NX23iV#6SyL0jr2Ml%axq!(pq> zbR3}13><2GW`Pge)bnA7dOify^P!DB+VG{=g^HXFW)BS5l`xr1L<dUHp*1DNS5kZ> z#pfwLPw{z*&x`n=2y3XeCUkU6C$)clpwx!&*`p`dbh05*I|au7t8K0{VzsS!*J((T z+L;*0LYCCFV;~1PQac|54mhN?y9B1900mOJxJ2+Alt^ta2Fg$-wO3rOhzgjHA$3f! zNl_E>q^Jolsck`#dKP%pL-na=kv$8wHz6Zuw@B?xrS=viNoIya#FtcjNyV2^d@043 zQhce1FXWASzlwT;b^;)cJNk)as0<)B0vKIU601GNp28kTJ`xaq)o`Dw!aDsN&VF>A z*-#Y%xoXH&lU~flh^saN>`5;Q2UZKN8gbQ-%bDBFZxTEme&70tr{|aLH#97M+WQ2H z54&Ge@qDjuWPAx?8@9u5k2mID^#0_@9~WWlgkK*0F%>yTOMMxyJQi^X9W3Ib5ZkC+ zWUDUft1cR=E?TQuwK1#H=>EVsM`3kW!|MGPR+ZHX?!{5|ILaPJ+2cg^fU9hEDLpz? zm_`E!OrwP{!QeHZC}(sM8o)7k&xsw#QK}dY(ecSCzMSIAE55wq%PYRT;<NFBq>E33 zgl&_|cvqmzJ4XQoGBUm?`MGGKyG_aNE>B8;72bCcEF4vnLUHWg3k2RSc(t^oO^)C! zu?uO@xoXiK9+)mtcBLL4m^M{3KO*i#6<(-}w$-Hr(?xpc7+3D&%Ka-Vcd3e3?nTvd x<vy+4ryo0Mi32zg*MNy0aB+wvhgWvg!-}6r-@X>VE_O#9aY!V*72dx7_+Qu9dF%iH diff --git a/src/wasm/Hacl_Hash_Blake2s_Simd128.wasm b/src/wasm/Hacl_Hash_Blake2s_Simd128.wasm index 6d5cdb7834f987142bb56a6a2aec4f62a473dfd3..fd3c1b86281cdfbf43173dd093717f4f2d448d64 100644 GIT binary patch delta 746 zcmZvaKWG#|7{$NYKexLxvv+&{;(0+blYnPolmv-#Hkm*K5nD@-Ll3#lo)Pa-DCnLd z5mE%=NK{aXg=Gpou(LN>Sc$Dwx@cu7_{{}#1nlO`y#3Ah-t6kh_0u_Mb~^+B$g>Ci zK8$VT>b9Mx?-oCk+Ik;%!hkX!W^+-#P%M=*kIf!QLG5Ok_w6AHs`K`^*S^{A0X?o8 zmh?I+Nv{oDU$tshC~&J9bec)Bd<~)rqx{>gZmS1*b0jP%=%3akDI!K#rJ6D5%XYR@ z4z4$Q%|^F<w`CLh=#800FWXz`mKoHt?t7_%69CdvzVwA3dDWp-z9NZolA(wrOM!G{ zMz|s~hvq;83UDFNwIqFe9v5)QnIF1EfXYc?5g>PDIz-_5Yv3LefusT?n*#NO#E}ca z8@UF|Ici6|DnJln30s81i9&tGJ5QLt<&7Q5y6V@T55Mm*S2)I`U|YCRR=@JrCSF=Y zoQpVHI{2}JgRs}8Y0OOZ1;370DG|}C{t;Btkx61QNih*s{>6ht3SvQHlT!H!He=K@ zKpiWfio}v0x`-2(For#NbKsk*w$DO@VHvtOqPeOZpuwPLcr5TxRrcBZADbIC{|{RY z*8DFP;ra^OBz&;P?${`9<ldqPqa8xt>+ksv`J@*M(~~>yunaS!k57janKIbkDz-sj p3fQiGT6i8UB+aGPY_~Bpd+wC^5%orSMSm=g>xJUxpi_E5{sJ0zkAnaJ delta 398 zcmXw#&npE{6vxlKcjnEHJ7eaV8H#Wp@it_qP-^}I|G{g@(8Jrjc_|9R0x7~RVIdo3 zBQ&zJRZ=!ASjgH+Z=s}=dtcd|&$sXScFuQuaIN2gD5)R-KszgG3c;>3ay5R3id(55 z%P^^BH#u&;+4FPjQbNlR)^k+5UKL>U@k`vs9g^eASi`jUAGOkKl+?iD7q}ZcT~gMn zaT3?S6;iv{&`@4Z#zc847S86*hG()G$KVwkF>|EJ_l=3D7L}6nLQIf(bS!V;2jnDs zQv%}BHU<na%m}lY;#wT*qsZiAdP}RVhM&JTUyD>_iZq3A&Q#atGx}!N9-4MlU}^{j zQc%RQG6X<h<#!k_X?(*Qrb@x+f$$6qXVzgpU_|+cwU20)+Ve!fk9#WMB!7?4EuZ!( z=!w601KrPRBia<vdcj~iGh{UVUX#s1570U<`Um_yXyK(`Uy+sYM}If_3J%d9XhCKz diff --git a/src/wasm/Hacl_SHA2_Vec128.wasm b/src/wasm/Hacl_SHA2_Vec128.wasm index cef1c90da828ebb4ad5cf85f71efe317b3c1a35b..549c8a5f1523879d3471e328a6b7732e0453a3f6 100644 GIT binary patch delta 327 zcmdn4vt4I`loE4&eLZ7+0wb8HW2%QS5rPxrR3|2Oi3x`%7Uu?+78K+cmBi<!=2oQ^ z<ufo%c4t&zWS*SCsL9AOc_X7XBkRQbN{nn1?@La$W#p7&=SI>cfW(e3DM~Due4BA0 zBgbS1?oW*DlM9&VGO|v-$Rh@1zu-v_XO(hf&|qM2<Zxun0U;14OMrcIJZ}^WP{}Sq zXCV0xL~gF<6lMf+!h}IWvxLo9r!Zy-a7-5B)<rViWO6!BCYd%&uID^4nM>Fk$r39@ Kj?Gtvlb8T7_*s4c delta 274 zcmdn4vt4I`6fa{vV|@a1eLaX`oG2?fF-dV^V%NkI!Yqbn3``U6D>5=q+#|`An3I{F z7jI_5z%rSUQGt<lvJ#^vBirPCjB<?ZlYJPqC*NUQ0Ax9Ee_~{rT);e+kz?{j9x)*M z1y6!Fhm<3O1_Og5ha+PS2!S|R0xX;3d81f>N_Gi41Id3Na&tYWFe8u?CJYjqC2Ynz qg)vKjeX<a@E|Tdclhb)J$+Tf|J?DwZT*BT+mRK>eZ@wy=!~_6exkRb} diff --git a/src/wasm/INFO.txt b/src/wasm/INFO.txt index d2f1192f..1957e6b9 100644 --- a/src/wasm/INFO.txt +++ b/src/wasm/INFO.txt @@ -1,4 +1,4 @@ This code was generated with the following toolchain. -F* version: 6e23042e74555544267731295b7d382c86edc574 +F* version: fe6dec16fc4f0234663da63de26d9d2e72fe14df Karamel version: a7be2a7c43eca637ceb57fe8f3ffd16fc6627ebd Vale version: 0.3.19 diff --git a/src/wasm/layouts.json b/src/wasm/layouts.json index 81273a66..d62bb7ad 100644 --- a/src/wasm/layouts.json +++ b/src/wasm/layouts.json @@ -1 +1 @@ -{"Spec_Hash_Definitions_hash_alg":["LEnum"],"Prims_string":["LBuiltin",["I32"],["A32"]],"Prims_int":["LBuiltin",["I32"],["A32"]],"K___uint32_t_uint32_t":["LFlat",{"size":8,"fields":[["fst",[0,["Int",["A32"]]]],["snd",[4,["Int",["A32"]]]]]}],"__bool_bool_bool_bool":["LFlat",{"size":4,"fields":[["fst",[0,["Int",["A8"]]]],["snd",[1,["Int",["A8"]]]],["thd",[2,["Int",["A8"]]]],["f3",[3,["Int",["A8"]]]]]}],"__bool_bool":["LFlat",{"size":2,"fields":[["fst",[0,["Int",["A8"]]]],["snd",[1,["Int",["A8"]]]]]}],"Hacl_Streaming_Types_error_code":["LEnum"],"Hacl_MAC_Poly1305_state_t":["LFlat",{"size":20,"fields":[["block_state",[0,["Pointer",["Int",["A64"]]]]],["buf",[4,["Pointer",["Int",["A8"]]]]],["total_len",[8,["Int",["A64"]]]],["p_key",[16,["Pointer",["Int",["A8"]]]]]]}],"Hacl_Streaming_MD_state_64":["LFlat",{"size":16,"fields":[["block_state",[0,["Pointer",["Int",["A64"]]]]],["buf",[4,["Pointer",["Int",["A8"]]]]],["total_len",[8,["Int",["A64"]]]]]}],"Hacl_Streaming_MD_state_32":["LFlat",{"size":16,"fields":[["block_state",[0,["Pointer",["Int",["A32"]]]]],["buf",[4,["Pointer",["Int",["A8"]]]]],["total_len",[8,["Int",["A64"]]]]]}],"Hacl_Hash_SHA3_state_t":["LFlat",{"size":24,"fields":[["block_state",[0,["Layout","Hacl_Hash_SHA3_hash_buf"]]],["buf",[8,["Pointer",["Int",["A8"]]]]],["total_len",[16,["Int",["A64"]]]]]}],"hash_buf2":["LFlat",{"size":16,"fields":[["fst",[0,["Layout","Hacl_Hash_SHA3_hash_buf"]]],["snd",[8,["Layout","Hacl_Hash_SHA3_hash_buf"]]]]}],"Hacl_Hash_SHA3_hash_buf":["LFlat",{"size":8,"fields":[["fst",[0,["Int",["A32"]]]],["snd",[4,["Pointer",["Int",["A64"]]]]]]}],"Hacl_Hash_Blake2s_state_t":["LFlat",{"size":24,"fields":[["block_state",[0,["Layout","Hacl_Hash_Blake2s_block_state_t"]]],["buf",[8,["Pointer",["Int",["A8"]]]]],["total_len",[16,["Int",["A64"]]]]]}],"Hacl_Hash_Blake2s_block_state_t":["LFlat",{"size":8,"fields":[["fst",[0,["Pointer",["Int",["A32"]]]]],["snd",[4,["Pointer",["Int",["A32"]]]]]]}],"Hacl_Hash_Blake2s_Simd128_state_t":["LFlat",{"size":24,"fields":[["block_state",[0,["Layout","Hacl_Hash_Blake2s_Simd128_block_state_t"]]],["buf",[8,["Pointer",["Int",["A8"]]]]],["total_len",[16,["Int",["A64"]]]]]}],"Hacl_Hash_Blake2s_Simd128_block_state_t":["LFlat",{"size":8,"fields":[["fst",[0,["Pointer",["Unknown"]]]],["snd",[4,["Pointer",["Unknown"]]]]]}],"Hacl_Hash_Blake2b_state_t":["LFlat",{"size":24,"fields":[["block_state",[0,["Layout","Hacl_Hash_Blake2b_block_state_t"]]],["buf",[8,["Pointer",["Int",["A8"]]]]],["total_len",[16,["Int",["A64"]]]]]}],"Hacl_Hash_Blake2b_block_state_t":["LFlat",{"size":8,"fields":[["fst",[0,["Pointer",["Int",["A64"]]]]],["snd",[4,["Pointer",["Int",["A64"]]]]]]}],"Hacl_Hash_Blake2b_Simd256_state_t":["LFlat",{"size":24,"fields":[["block_state",[0,["Layout","Hacl_Hash_Blake2b_Simd256_block_state_t"]]],["buf",[8,["Pointer",["Int",["A8"]]]]],["total_len",[16,["Int",["A64"]]]]]}],"Hacl_Hash_Blake2b_Simd256_block_state_t":["LFlat",{"size":8,"fields":[["fst",[0,["Pointer",["Unknown"]]]],["snd",[4,["Pointer",["Unknown"]]]]]}],"Hacl_Hash_SHA2_uint8_8p":["LFlat",{"size":56,"fields":[["fst",[0,["Pointer",["Int",["A8"]]]]],["snd",[8,["Layout","Hacl_Hash_SHA2_uint8_7p"]]]]}],"Hacl_Hash_SHA2_uint8_7p":["LFlat",{"size":48,"fields":[["fst",[0,["Pointer",["Int",["A8"]]]]],["snd",[8,["Layout","Hacl_Hash_SHA2_uint8_6p"]]]]}],"Hacl_Hash_SHA2_uint8_6p":["LFlat",{"size":40,"fields":[["fst",[0,["Pointer",["Int",["A8"]]]]],["snd",[8,["Layout","Hacl_Hash_SHA2_uint8_5p"]]]]}],"Hacl_Hash_SHA2_uint8_5p":["LFlat",{"size":32,"fields":[["fst",[0,["Pointer",["Int",["A8"]]]]],["snd",[8,["Layout","Hacl_Hash_SHA2_uint8_4p"]]]]}],"Hacl_Hash_SHA2_uint8_4p":["LFlat",{"size":24,"fields":[["fst",[0,["Pointer",["Int",["A8"]]]]],["snd",[8,["Layout","Hacl_Hash_SHA2_uint8_3p"]]]]}],"Hacl_Hash_SHA2_uint8_3p":["LFlat",{"size":16,"fields":[["fst",[0,["Pointer",["Int",["A8"]]]]],["snd",[8,["Layout","Hacl_Hash_SHA2_uint8_2p"]]]]}],"Hacl_Hash_SHA2_uint8_2x8p":["LFlat",{"size":112,"fields":[["fst",[0,["Layout","Hacl_Hash_SHA2_uint8_8p"]]],["snd",[56,["Layout","Hacl_Hash_SHA2_uint8_8p"]]]]}],"Hacl_Hash_SHA2_uint8_2x4p":["LFlat",{"size":48,"fields":[["fst",[0,["Layout","Hacl_Hash_SHA2_uint8_4p"]]],["snd",[24,["Layout","Hacl_Hash_SHA2_uint8_4p"]]]]}],"Hacl_Hash_SHA2_uint8_2p":["LFlat",{"size":8,"fields":[["fst",[0,["Pointer",["Int",["A8"]]]]],["snd",[4,["Pointer",["Int",["A8"]]]]]]}],"Hacl_Impl_HPKE_context_s":["LFlat",{"size":16,"fields":[["ctx_key",[0,["Pointer",["Int",["A8"]]]]],["ctx_nonce",[4,["Pointer",["Int",["A8"]]]]],["ctx_seq",[8,["Pointer",["Int",["A64"]]]]],["ctx_exporter",[12,["Pointer",["Int",["A8"]]]]]]}],"Hacl_HMAC_DRBG_state":["LFlat",{"size":12,"fields":[["k",[0,["Pointer",["Int",["A8"]]]]],["v",[4,["Pointer",["Int",["A8"]]]]],["reseed_counter",[8,["Pointer",["Int",["A32"]]]]]]}],"Hacl_Bignum_MontArithmetic_bn_mont_ctx_u64":["LFlat",{"size":20,"fields":[["len",[0,["Int",["A32"]]]],["n",[4,["Pointer",["Int",["A64"]]]]],["mu",[8,["Int",["A64"]]]],["r2",[16,["Pointer",["Int",["A64"]]]]]]}],"Hacl_Bignum_MontArithmetic_bn_mont_ctx_u32":["LFlat",{"size":16,"fields":[["len",[0,["Int",["A32"]]]],["n",[4,["Pointer",["Int",["A32"]]]]],["mu",[8,["Int",["A32"]]]],["r2",[12,["Pointer",["Int",["A32"]]]]]]}],"FStar_UInt128_uint128":["LFlat",{"size":16,"fields":[["low",[0,["Int",["A64"]]]],["high",[8,["Int",["A64"]]]]]}],"EverCrypt_Hash_Incremental_state_t":["LFlat",{"size":16,"fields":[["block_state",[0,["Pointer",["Layout","EverCrypt_Hash_state_s"]]]],["buf",[4,["Pointer",["Int",["A8"]]]]],["total_len",[8,["Int",["A64"]]]]]}],"state_s_tags":["LEnum"],"EverCrypt_Hash_state_s":["LFlat",{"size":12,"fields":[["tag",[0,["Int",["A32"]]]],["val",[8,["Union",[["Pointer",["Int",["A32"]]],["Pointer",["Int",["A32"]]],["Pointer",["Int",["A32"]]],["Pointer",["Int",["A32"]]],["Pointer",["Int",["A64"]]],["Pointer",["Int",["A64"]]],["Pointer",["Int",["A64"]]],["Pointer",["Int",["A64"]]],["Pointer",["Int",["A64"]]],["Pointer",["Int",["A64"]]],["Pointer",["Int",["A32"]]],["Pointer",["Unknown"]],["Pointer",["Int",["A64"]]],["Pointer",["Unknown"]]]]]]]}],"EverCrypt_Error_error_code":["LEnum"],"C_String_t_":["LBuiltin",["I32"],["A32"]],"C_String_t":["LBuiltin",["I32"],["A32"]],"C_Compat_String_t_":["LBuiltin",["I32"],["A32"]],"C_Compat_String_t":["LBuiltin",["I32"],["A32"]],"exit_code":["LBuiltin",["I32"],["A32"]],"clock_t":["LBuiltin",["I32"],["A32"]]} \ No newline at end of file +{"Spec_Hash_Definitions_hash_alg":["LEnum"],"Prims_string":["LBuiltin",["I32"],["A32"]],"Prims_int":["LBuiltin",["I32"],["A32"]],"K___uint32_t_uint32_t":["LFlat",{"size":8,"fields":[["fst",[0,["Int",["A32"]]]],["snd",[4,["Int",["A32"]]]]]}],"__bool_bool_bool_bool":["LFlat",{"size":4,"fields":[["fst",[0,["Int",["A8"]]]],["snd",[1,["Int",["A8"]]]],["thd",[2,["Int",["A8"]]]],["f3",[3,["Int",["A8"]]]]]}],"__bool_bool":["LFlat",{"size":2,"fields":[["fst",[0,["Int",["A8"]]]],["snd",[1,["Int",["A8"]]]]]}],"Hacl_Streaming_Types_error_code":["LEnum"],"Hacl_MAC_Poly1305_state_t":["LFlat",{"size":20,"fields":[["block_state",[0,["Pointer",["Int",["A64"]]]]],["buf",[4,["Pointer",["Int",["A8"]]]]],["total_len",[8,["Int",["A64"]]]],["p_key",[16,["Pointer",["Int",["A8"]]]]]]}],"Hacl_Streaming_MD_state_64":["LFlat",{"size":16,"fields":[["block_state",[0,["Pointer",["Int",["A64"]]]]],["buf",[4,["Pointer",["Int",["A8"]]]]],["total_len",[8,["Int",["A64"]]]]]}],"Hacl_Streaming_MD_state_32":["LFlat",{"size":16,"fields":[["block_state",[0,["Pointer",["Int",["A32"]]]]],["buf",[4,["Pointer",["Int",["A8"]]]]],["total_len",[8,["Int",["A64"]]]]]}],"Hacl_Hash_SHA3_state_t":["LFlat",{"size":24,"fields":[["block_state",[0,["Layout","Hacl_Hash_SHA3_hash_buf"]]],["buf",[8,["Pointer",["Int",["A8"]]]]],["total_len",[16,["Int",["A64"]]]]]}],"hash_buf2":["LFlat",{"size":16,"fields":[["fst",[0,["Layout","Hacl_Hash_SHA3_hash_buf"]]],["snd",[8,["Layout","Hacl_Hash_SHA3_hash_buf"]]]]}],"Hacl_Hash_SHA3_hash_buf":["LFlat",{"size":8,"fields":[["fst",[0,["Int",["A32"]]]],["snd",[4,["Pointer",["Int",["A64"]]]]]]}],"Hacl_Hash_Blake2s_state_t":["LFlat",{"size":24,"fields":[["block_state",[0,["Layout","Hacl_Hash_Blake2s_block_state_t"]]],["buf",[8,["Pointer",["Int",["A8"]]]]],["total_len",[16,["Int",["A64"]]]]]}],"Hacl_Hash_Blake2s_block_state_t":["LFlat",{"size":8,"fields":[["fst",[0,["Pointer",["Int",["A32"]]]]],["snd",[4,["Pointer",["Int",["A32"]]]]]]}],"Hacl_Hash_Blake2s_Simd128_state_t":["LFlat",{"size":24,"fields":[["block_state",[0,["Layout","Hacl_Hash_Blake2s_Simd128_block_state_t"]]],["buf",[8,["Pointer",["Int",["A8"]]]]],["total_len",[16,["Int",["A64"]]]]]}],"Hacl_Hash_Blake2s_Simd128_block_state_t":["LFlat",{"size":8,"fields":[["fst",[0,["Pointer",["Unknown"]]]],["snd",[4,["Pointer",["Unknown"]]]]]}],"Hacl_Hash_Blake2b_state_t":["LFlat",{"size":24,"fields":[["block_state",[0,["Layout","Hacl_Hash_Blake2b_block_state_t"]]],["buf",[8,["Pointer",["Int",["A8"]]]]],["total_len",[16,["Int",["A64"]]]]]}],"Hacl_Hash_Blake2b_block_state_t":["LFlat",{"size":8,"fields":[["fst",[0,["Pointer",["Int",["A64"]]]]],["snd",[4,["Pointer",["Int",["A64"]]]]]]}],"Hacl_Hash_Blake2b_Simd256_state_t":["LFlat",{"size":24,"fields":[["block_state",[0,["Layout","Hacl_Hash_Blake2b_Simd256_block_state_t"]]],["buf",[8,["Pointer",["Int",["A8"]]]]],["total_len",[16,["Int",["A64"]]]]]}],"Hacl_Hash_Blake2b_Simd256_block_state_t":["LFlat",{"size":8,"fields":[["fst",[0,["Pointer",["Unknown"]]]],["snd",[4,["Pointer",["Unknown"]]]]]}],"Hacl_Hash_SHA2_uint8_8p":["LFlat",{"size":56,"fields":[["fst",[0,["Pointer",["Int",["A8"]]]]],["snd",[8,["Layout","Hacl_Hash_SHA2_uint8_7p"]]]]}],"Hacl_Hash_SHA2_uint8_7p":["LFlat",{"size":48,"fields":[["fst",[0,["Pointer",["Int",["A8"]]]]],["snd",[8,["Layout","Hacl_Hash_SHA2_uint8_6p"]]]]}],"Hacl_Hash_SHA2_uint8_6p":["LFlat",{"size":40,"fields":[["fst",[0,["Pointer",["Int",["A8"]]]]],["snd",[8,["Layout","Hacl_Hash_SHA2_uint8_5p"]]]]}],"Hacl_Hash_SHA2_uint8_5p":["LFlat",{"size":32,"fields":[["fst",[0,["Pointer",["Int",["A8"]]]]],["snd",[8,["Layout","Hacl_Hash_SHA2_uint8_4p"]]]]}],"Hacl_Hash_SHA2_uint8_4p":["LFlat",{"size":24,"fields":[["fst",[0,["Pointer",["Int",["A8"]]]]],["snd",[8,["Layout","Hacl_Hash_SHA2_uint8_3p"]]]]}],"Hacl_Hash_SHA2_uint8_3p":["LFlat",{"size":16,"fields":[["fst",[0,["Pointer",["Int",["A8"]]]]],["snd",[8,["Layout","Hacl_Hash_SHA2_uint8_2p"]]]]}],"Hacl_Hash_SHA2_uint8_2x8p":["LFlat",{"size":112,"fields":[["fst",[0,["Layout","Hacl_Hash_SHA2_uint8_8p"]]],["snd",[56,["Layout","Hacl_Hash_SHA2_uint8_8p"]]]]}],"Hacl_Hash_SHA2_uint8_2x4p":["LFlat",{"size":48,"fields":[["fst",[0,["Layout","Hacl_Hash_SHA2_uint8_4p"]]],["snd",[24,["Layout","Hacl_Hash_SHA2_uint8_4p"]]]]}],"Hacl_Hash_SHA2_uint8_2p":["LFlat",{"size":8,"fields":[["fst",[0,["Pointer",["Int",["A8"]]]]],["snd",[4,["Pointer",["Int",["A8"]]]]]]}],"Hacl_Impl_HPKE_context_s":["LFlat",{"size":16,"fields":[["ctx_key",[0,["Pointer",["Int",["A8"]]]]],["ctx_nonce",[4,["Pointer",["Int",["A8"]]]]],["ctx_seq",[8,["Pointer",["Int",["A64"]]]]],["ctx_exporter",[12,["Pointer",["Int",["A8"]]]]]]}],"Hacl_Hash_Blake2s_blake2s_params":["LFlat",{"size":24,"fields":[["digest_length",[0,["Int",["A8"]]]],["key_length",[1,["Int",["A8"]]]],["fanout",[2,["Int",["A8"]]]],["depth",[3,["Int",["A8"]]]],["leaf_length",[4,["Int",["A32"]]]],["node_offset",[8,["Int",["A32"]]]],["xof_length",[12,["Int",["A16"]]]],["node_depth",[14,["Int",["A8"]]]],["inner_length",[15,["Int",["A8"]]]],["salt",[16,["Pointer",["Int",["A8"]]]]],["personal",[20,["Pointer",["Int",["A8"]]]]]]}],"Hacl_Hash_Blake2s_blake2b_params":["LFlat",{"size":28,"fields":[["digest_length1",[0,["Int",["A8"]]]],["key_length1",[1,["Int",["A8"]]]],["fanout1",[2,["Int",["A8"]]]],["depth1",[3,["Int",["A8"]]]],["leaf_length1",[4,["Int",["A32"]]]],["node_offset1",[8,["Int",["A32"]]]],["xof_length1",[12,["Int",["A32"]]]],["node_depth1",[16,["Int",["A8"]]]],["inner_length1",[17,["Int",["A8"]]]],["salt1",[20,["Pointer",["Int",["A8"]]]]],["personal1",[24,["Pointer",["Int",["A8"]]]]]]}],"Hacl_HMAC_DRBG_state":["LFlat",{"size":12,"fields":[["k",[0,["Pointer",["Int",["A8"]]]]],["v",[4,["Pointer",["Int",["A8"]]]]],["reseed_counter",[8,["Pointer",["Int",["A32"]]]]]]}],"Hacl_Bignum_MontArithmetic_bn_mont_ctx_u64":["LFlat",{"size":20,"fields":[["len",[0,["Int",["A32"]]]],["n",[4,["Pointer",["Int",["A64"]]]]],["mu",[8,["Int",["A64"]]]],["r2",[16,["Pointer",["Int",["A64"]]]]]]}],"Hacl_Bignum_MontArithmetic_bn_mont_ctx_u32":["LFlat",{"size":16,"fields":[["len",[0,["Int",["A32"]]]],["n",[4,["Pointer",["Int",["A32"]]]]],["mu",[8,["Int",["A32"]]]],["r2",[12,["Pointer",["Int",["A32"]]]]]]}],"FStar_UInt128_uint128":["LFlat",{"size":16,"fields":[["low",[0,["Int",["A64"]]]],["high",[8,["Int",["A64"]]]]]}],"EverCrypt_Hash_Incremental_state_t":["LFlat",{"size":16,"fields":[["block_state",[0,["Pointer",["Layout","EverCrypt_Hash_state_s"]]]],["buf",[4,["Pointer",["Int",["A8"]]]]],["total_len",[8,["Int",["A64"]]]]]}],"state_s_tags":["LEnum"],"EverCrypt_Hash_state_s":["LFlat",{"size":12,"fields":[["tag",[0,["Int",["A32"]]]],["val",[8,["Union",[["Pointer",["Int",["A32"]]],["Pointer",["Int",["A32"]]],["Pointer",["Int",["A32"]]],["Pointer",["Int",["A32"]]],["Pointer",["Int",["A64"]]],["Pointer",["Int",["A64"]]],["Pointer",["Int",["A64"]]],["Pointer",["Int",["A64"]]],["Pointer",["Int",["A64"]]],["Pointer",["Int",["A64"]]],["Pointer",["Int",["A32"]]],["Pointer",["Unknown"]],["Pointer",["Int",["A64"]]],["Pointer",["Unknown"]]]]]]]}],"EverCrypt_Error_error_code":["LEnum"],"C_String_t_":["LBuiltin",["I32"],["A32"]],"C_String_t":["LBuiltin",["I32"],["A32"]],"C_Compat_String_t_":["LBuiltin",["I32"],["A32"]],"C_Compat_String_t":["LBuiltin",["I32"],["A32"]],"exit_code":["LBuiltin",["I32"],["A32"]],"clock_t":["LBuiltin",["I32"],["A32"]]} \ No newline at end of file