From a5567f7492d6f7154741904ead9da2b5c3707a3e Mon Sep 17 00:00:00 2001 From: ms8421ms <109365501+ms8421ms@users.noreply.github.com> Date: Fri, 13 Mar 2026 22:07:11 +0100 Subject: [PATCH 01/19] chore: mayo library clean --- Makefile | 1 + 1 file changed, 1 insertion(+) diff --git a/Makefile b/Makefile index b9d246dcf..57def7483 100644 --- a/Makefile +++ b/Makefile @@ -121,6 +121,7 @@ clean: rm -rf ${pwd}/meson $(MAKE) clean -C ${pwd}/lib/lua54/src $(MAKE) clean -C ${pwd}/lib/pqclean + $(MAKE) clean -C ${pwd}/lib/mayo $(MAKE) clean -C ${pwd}/lib/mlkem $(MAKE) clean -C ${pwd}/lib/longfellow-zk $(MAKE) clean -C ${pwd}/lib/zk-circuit-lang From 5b09964c5331710e108bad880198f27f2a4962b1 Mon Sep 17 00:00:00 2001 From: ms8421ms <109365501+ms8421ms@users.noreply.github.com> Date: Fri, 13 Mar 2026 22:08:50 +0100 Subject: [PATCH 02/19] feat: added mayo library --- lib/mayo/Makefile | 13 + lib/mayo/aes128ctr.c | 293 +++++++++ lib/mayo/aes_c.c | 741 ++++++++++++++++++++++ lib/mayo/aes_ctr.h | 32 + lib/mayo/api.c | 46 ++ lib/mayo/api.h | 43 ++ lib/mayo/arithmetic.c | 128 ++++ lib/mayo/arithmetic.h | 124 ++++ lib/mayo/arithmetic_dynamic.h | 68 ++ lib/mayo/arithmetic_fixed.h | 84 +++ lib/mayo/debug_bench_tools.h | 69 +++ lib/mayo/echelon_form.h | 152 +++++ lib/mayo/ef_inner_loop.h | 56 ++ lib/mayo/fips202.c | 1093 +++++++++++++++++++++++++++++++++ lib/mayo/fips202.h | 12 + lib/mayo/generic_arithmetic.h | 294 +++++++++ lib/mayo/mayo.c | 675 ++++++++++++++++++++ lib/mayo/mayo.h | 442 +++++++++++++ lib/mayo/mem.c | 19 + lib/mayo/mem.h | 25 + lib/mayo/params.c | 42 ++ lib/mayo/simple_arithmetic.h | 138 +++++ 22 files changed, 4589 insertions(+) create mode 100644 lib/mayo/Makefile create mode 100644 lib/mayo/aes128ctr.c create mode 100644 lib/mayo/aes_c.c create mode 100644 lib/mayo/aes_ctr.h create mode 100644 lib/mayo/api.c create mode 100644 lib/mayo/api.h create mode 100644 lib/mayo/arithmetic.c create mode 100644 lib/mayo/arithmetic.h create mode 100644 lib/mayo/arithmetic_dynamic.h create mode 100644 lib/mayo/arithmetic_fixed.h create mode 100644 lib/mayo/debug_bench_tools.h create mode 100644 lib/mayo/echelon_form.h create mode 100644 lib/mayo/ef_inner_loop.h create mode 100644 lib/mayo/fips202.c create mode 100644 lib/mayo/fips202.h create mode 100644 lib/mayo/generic_arithmetic.h create mode 100644 lib/mayo/mayo.c create mode 100644 lib/mayo/mayo.h create mode 100644 lib/mayo/mem.c create mode 100644 lib/mayo/mem.h create mode 100644 lib/mayo/params.c create mode 100644 lib/mayo/simple_arithmetic.h diff --git a/lib/mayo/Makefile b/lib/mayo/Makefile new file mode 100644 index 000000000..078ee16e7 --- /dev/null +++ b/lib/mayo/Makefile @@ -0,0 +1,13 @@ +CFLAGS ?= -O2 -I../../src -I. -fPIC -fstack-protector-all -D_FORTIFY_SOURCE=2 -fno-strict-overflow -DMAYO_BUILD_TYPE_REF=1 -DMAYO_VARIANT=MAYO_5 +CC ?= gcc + +MAYO=aes_c.o aes128ctr.o fips202.o mem.o api.o mayo.o params.o arithmetic.o + +all: libmayo.a + +libmayo.a: ${MAYO} + ${AR} -r libmayo.a ${MAYO} + +clean: + rm -f *.a + rm -f ${MAYO} \ No newline at end of file diff --git a/lib/mayo/aes128ctr.c b/lib/mayo/aes128ctr.c new file mode 100644 index 000000000..6fa736c83 --- /dev/null +++ b/lib/mayo/aes128ctr.c @@ -0,0 +1,293 @@ +// SPDX-License-Identifier: Apache-2.0 and MIT and Public Domain + +#ifdef ENABLE_AESNI + +#include +#include +#include +#include +#include + +// Adapted from liboqs/src/common/aes which in turn takes it from: +// crypto_core/aes128ncrypt/dolbeau/aesenc-int +// (https://bench.cr.yp.to/supercop.html) +static inline void aes128ni_setkey_encrypt(const unsigned char *key, + __m128i rkeys[11]) { + __m128i key0 = _mm_loadu_si128((const __m128i *)(key + 0)); + __m128i temp0, temp1, temp4; + int idx = 0; + + temp0 = key0; + +#define BLOCK1(IMM) \ + temp1 = _mm_aeskeygenassist_si128(temp0, IMM); \ + rkeys[idx++] = temp0; \ + temp4 = _mm_slli_si128(temp0, 4); \ + temp0 = _mm_xor_si128(temp0, temp4); \ + temp4 = _mm_slli_si128(temp0, 8); \ + temp0 = _mm_xor_si128(temp0, temp4); \ + temp1 = _mm_shuffle_epi32(temp1, 0xff); \ + temp0 = _mm_xor_si128(temp0, temp1) + + BLOCK1(0x01); + BLOCK1(0x02); + BLOCK1(0x04); + BLOCK1(0x08); + BLOCK1(0x10); + BLOCK1(0x20); + BLOCK1(0x40); + BLOCK1(0x80); + BLOCK1(0x1b); + BLOCK1(0x36); + rkeys[idx++] = temp0; +} + +void oqs_aes128_load_schedule_ni(const uint8_t *key, void **_schedule) { + *_schedule = malloc(11 * sizeof(__m128i)); + // assert(*_schedule != NULL); + __m128i *schedule = (__m128i *)*_schedule; + aes128ni_setkey_encrypt(key, schedule); +} + +void oqs_aes128_free_schedule_ni(void *schedule) { + if (schedule != NULL) { + mayo_secure_free(schedule, 11 * sizeof(__m128i)); + } +} + +// Single encryption +static inline void aes128ni_encrypt(const __m128i rkeys[11], __m128i nv, + unsigned char *out) { + __m128i temp = _mm_xor_si128(nv, rkeys[0]); + temp = _mm_aesenc_si128(temp, rkeys[1]); + temp = _mm_aesenc_si128(temp, rkeys[2]); + temp = _mm_aesenc_si128(temp, rkeys[3]); + temp = _mm_aesenc_si128(temp, rkeys[4]); + temp = _mm_aesenc_si128(temp, rkeys[5]); + temp = _mm_aesenc_si128(temp, rkeys[6]); + temp = _mm_aesenc_si128(temp, rkeys[7]); + temp = _mm_aesenc_si128(temp, rkeys[8]); + temp = _mm_aesenc_si128(temp, rkeys[9]); + temp = _mm_aesenclast_si128(temp, rkeys[10]); + _mm_storeu_si128((__m128i *)(out), temp); +} + +// 4x interleaved encryption +static inline void aes128ni_encrypt_x4(const __m128i rkeys[11], __m128i n0, + __m128i n1, __m128i n2, __m128i n3, + unsigned char *out) { + __m128i temp0 = _mm_xor_si128(n0, rkeys[0]); + __m128i temp1 = _mm_xor_si128(n1, rkeys[0]); + __m128i temp2 = _mm_xor_si128(n2, rkeys[0]); + __m128i temp3 = _mm_xor_si128(n3, rkeys[0]); + +#define AESNENCX4(IDX) \ + temp0 = _mm_aesenc_si128(temp0, rkeys[IDX]); \ + temp1 = _mm_aesenc_si128(temp1, rkeys[IDX]); \ + temp2 = _mm_aesenc_si128(temp2, rkeys[IDX]); \ + temp3 = _mm_aesenc_si128(temp3, rkeys[IDX]) + + AESNENCX4(1); + AESNENCX4(2); + AESNENCX4(3); + AESNENCX4(4); + AESNENCX4(5); + AESNENCX4(6); + AESNENCX4(7); + AESNENCX4(8); + AESNENCX4(9); + + temp0 = _mm_aesenclast_si128(temp0, rkeys[10]); + temp1 = _mm_aesenclast_si128(temp1, rkeys[10]); + temp2 = _mm_aesenclast_si128(temp2, rkeys[10]); + temp3 = _mm_aesenclast_si128(temp3, rkeys[10]); + + _mm_storeu_si128((__m128i *)(out + 0), temp0); + _mm_storeu_si128((__m128i *)(out + 16), temp1); + _mm_storeu_si128((__m128i *)(out + 32), temp2); + _mm_storeu_si128((__m128i *)(out + 48), temp3); +} + +// Not for general use: IV = 0, nonce = 0 +static void oqs_aes128_ctr_enc_sch_ni(const void *schedule, uint8_t *out, + size_t out_len) { + __m128i mask = + _mm_set_epi8(8, 9, 10, 11, 12, 13, 14, 15, 7, 6, 5, 4, 3, 2, 1, 0); + __m128i block = _mm_set_epi64x(0, 0); + // block = _mm_xor_si128(block, block); // set to zero + + while (out_len >= 64) { + __m128i nv0 = block; + __m128i nv1 = _mm_shuffle_epi8( + _mm_add_epi64(_mm_shuffle_epi8(block, mask), _mm_set_epi64x(1, 0)), + mask); + __m128i nv2 = _mm_shuffle_epi8( + _mm_add_epi64(_mm_shuffle_epi8(block, mask), _mm_set_epi64x(2, 0)), + mask); + __m128i nv3 = _mm_shuffle_epi8( + _mm_add_epi64(_mm_shuffle_epi8(block, mask), _mm_set_epi64x(3, 0)), + mask); + aes128ni_encrypt_x4(schedule, nv0, nv1, nv2, nv3, out); + block = _mm_shuffle_epi8( + _mm_add_epi64(_mm_shuffle_epi8(block, mask), _mm_set_epi64x(4, 0)), + mask); + out += 64; + out_len -= 64; + } + while (out_len >= 16) { + aes128ni_encrypt(schedule, block, out); + out += 16; + out_len -= 16; + block = _mm_shuffle_epi8( + _mm_add_epi64(_mm_shuffle_epi8(block, mask), _mm_set_epi64x(1, 0)), + mask); + } + if (out_len > 0) { + uint8_t tmp[16]; + aes128ni_encrypt(schedule, block, tmp); + memcpy(out, tmp, out_len); + } +} + +int AES_128_CTR_NI(unsigned char *output, size_t outputByteLen, + const unsigned char *input, size_t inputByteLen) { + void *schedule = NULL; + oqs_aes128_load_schedule_ni(input, &schedule); + oqs_aes128_ctr_enc_sch_ni(schedule, output, outputByteLen); + oqs_aes128_free_schedule_ni(schedule); + return (int)outputByteLen; +} + +// 4-Round AES... + +// From crypto_core/aes128ncrypt/dolbeau/aesenc-int +static inline void aes128r4ni_setkey_encrypt(const unsigned char *key, + __m128i rkeys[5]) { + __m128i key0 = _mm_loadu_si128((const __m128i *)(key + 0)); + __m128i temp0, temp1, temp4; + int idx = 0; + + temp0 = key0; + + /* blockshift-based block by Cedric Bourrasset */ +#define BLOCK1(IMM) \ + temp1 = _mm_aeskeygenassist_si128(temp0, IMM); \ + rkeys[idx++] = temp0; \ + temp4 = _mm_slli_si128(temp0, 4); \ + temp0 = _mm_xor_si128(temp0, temp4); \ + temp4 = _mm_slli_si128(temp0, 8); \ + temp0 = _mm_xor_si128(temp0, temp4); \ + temp1 = _mm_shuffle_epi32(temp1, 0xff); \ + temp0 = _mm_xor_si128(temp0, temp1) + + BLOCK1(0x01); + BLOCK1(0x02); + BLOCK1(0x04); + BLOCK1(0x08); + rkeys[idx++] = temp0; +} + +void oqs_aes128r4_load_schedule_ni(const uint8_t *key, void **_schedule) { + *_schedule = malloc(5 * sizeof(__m128i)); + // assert(*_schedule != NULL); + __m128i *schedule = (__m128i *)*_schedule; + aes128r4ni_setkey_encrypt(key, schedule); +} + +void oqs_aes128r4_free_schedule_ni(void *schedule) { + if (schedule != NULL) { + mayo_secure_free(schedule, 5 * sizeof(__m128i)); + } +} + +// Single encryption +static inline void aes128r4ni_encrypt(const __m128i rkeys[5], __m128i nv, + unsigned char *out) { + __m128i temp = _mm_xor_si128(nv, rkeys[0]); + temp = _mm_aesenc_si128(temp, rkeys[1]); + temp = _mm_aesenc_si128(temp, rkeys[2]); + temp = _mm_aesenc_si128(temp, rkeys[3]); + temp = _mm_aesenclast_si128(temp, rkeys[4]); + _mm_storeu_si128((__m128i *)(out), temp); +} + +// 4x interleaved encryption +static inline void aes128r4ni_encrypt_x4(const __m128i rkeys[5], __m128i n0, + __m128i n1, __m128i n2, __m128i n3, + unsigned char *out) { + __m128i temp0 = _mm_xor_si128(n0, rkeys[0]); + __m128i temp1 = _mm_xor_si128(n1, rkeys[0]); + __m128i temp2 = _mm_xor_si128(n2, rkeys[0]); + __m128i temp3 = _mm_xor_si128(n3, rkeys[0]); + +#define AESNENCX4(IDX) \ + temp0 = _mm_aesenc_si128(temp0, rkeys[IDX]); \ + temp1 = _mm_aesenc_si128(temp1, rkeys[IDX]); \ + temp2 = _mm_aesenc_si128(temp2, rkeys[IDX]); \ + temp3 = _mm_aesenc_si128(temp3, rkeys[IDX]) + + AESNENCX4(1); + AESNENCX4(2); + AESNENCX4(3); + + temp0 = _mm_aesenclast_si128(temp0, rkeys[4]); + temp1 = _mm_aesenclast_si128(temp1, rkeys[4]); + temp2 = _mm_aesenclast_si128(temp2, rkeys[4]); + temp3 = _mm_aesenclast_si128(temp3, rkeys[4]); + + _mm_storeu_si128((__m128i *)(out + 0), temp0); + _mm_storeu_si128((__m128i *)(out + 16), temp1); + _mm_storeu_si128((__m128i *)(out + 32), temp2); + _mm_storeu_si128((__m128i *)(out + 48), temp3); +} + +// Not for general use: IV = 0, nonce = 0 +static void oqs_aes128r4_ctr_enc_sch_ni(const void *schedule, uint8_t *out, + size_t out_len) { + __m128i mask = + _mm_set_epi8(8, 9, 10, 11, 12, 13, 14, 15, 7, 6, 5, 4, 3, 2, 1, 0); + __m128i block = _mm_set_epi64x(0, 0); + + while (out_len >= 64) { + __m128i nv0 = block; + __m128i nv1 = _mm_shuffle_epi8( + _mm_add_epi64(_mm_shuffle_epi8(block, mask), _mm_set_epi64x(1, 0)), + mask); + __m128i nv2 = _mm_shuffle_epi8( + _mm_add_epi64(_mm_shuffle_epi8(block, mask), _mm_set_epi64x(2, 0)), + mask); + __m128i nv3 = _mm_shuffle_epi8( + _mm_add_epi64(_mm_shuffle_epi8(block, mask), _mm_set_epi64x(3, 0)), + mask); + aes128r4ni_encrypt_x4(schedule, nv0, nv1, nv2, nv3, out); + block = _mm_shuffle_epi8( + _mm_add_epi64(_mm_shuffle_epi8(block, mask), _mm_set_epi64x(4, 0)), + mask); + out += 64; + out_len -= 64; + } + while (out_len >= 16) { + aes128r4ni_encrypt(schedule, block, out); + out += 16; + out_len -= 16; + block = _mm_shuffle_epi8( + _mm_add_epi64(_mm_shuffle_epi8(block, mask), _mm_set_epi64x(1, 0)), + mask); + } + if (out_len > 0) { + uint8_t tmp[16]; + aes128r4ni_encrypt(schedule, block, tmp); + memcpy(out, tmp, out_len); + } +} + +int AES_128_CTR_4R_NI(unsigned char *output, size_t outputByteLen, + const unsigned char *input, size_t inputByteLen) { + void *schedule = NULL; + oqs_aes128r4_load_schedule_ni(input, &schedule); + oqs_aes128r4_ctr_enc_sch_ni(schedule, output, outputByteLen); + oqs_aes128r4_free_schedule_ni(schedule); + return (int)outputByteLen; +} +#endif + diff --git a/lib/mayo/aes_c.c b/lib/mayo/aes_c.c new file mode 100644 index 000000000..8afec21ec --- /dev/null +++ b/lib/mayo/aes_c.c @@ -0,0 +1,741 @@ +// SPDX-License-Identifier: MIT and Apache-2.0 + +/* + * AES implementation based on code from PQClean, + * which is in turn based on BearSSL (https://bearssl.org/) + * by Thomas Pornin. + * + * + * Copyright (c) 2016 Thomas Pornin + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS + * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN + * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +#include +#include +#include + +#define AES128_KEYBYTES 16 +#define AES192_KEYBYTES 24 +#define AES256_KEYBYTES 32 +#define AESCTR_NONCEBYTES 12 +#define AES_BLOCKBYTES 16 + +// We've put these states on the heap to make sure ctx_release is used. +#define PQC_AES128_STATESIZE 88 +typedef struct { + uint64_t *sk_exp; +} aes128ctx; + +#define PQC_AES192_STATESIZE 104 +typedef struct { + uint64_t *sk_exp; +} aes192ctx; + +#define PQC_AES256_STATESIZE 120 +typedef struct { + uint64_t *sk_exp; +} aes256ctx; + + +/** Initializes the context **/ +void aes128_ecb_keyexp(aes128ctx *r, const unsigned char *key); + +void aes128_ctr_keyexp(aes128ctx *r, const unsigned char *key); + +void aes128_ecb(unsigned char *out, const unsigned char *in, size_t nblocks, const aes128ctx *ctx); + +void aes128_ctr(unsigned char *out, size_t outlen, const unsigned char *iv, const aes128ctx *ctx); + +/** Frees the context **/ +void aes128_ctx_release(aes128ctx *r); + + +/** Initializes the context **/ +void aes192_ecb_keyexp(aes192ctx *r, const unsigned char *key); + +void aes192_ctr_keyexp(aes192ctx *r, const unsigned char *key); + +void aes192_ecb(unsigned char *out, const unsigned char *in, size_t nblocks, const aes192ctx *ctx); + +void aes192_ctr(unsigned char *out, size_t outlen, const unsigned char *iv, const aes192ctx *ctx); + +void aes192_ctx_release(aes192ctx *r); + + +/** Initializes the context **/ +void aes256_ecb_keyexp(aes256ctx *r, const unsigned char *key); + +void aes256_ctr_keyexp(aes256ctx *r, const unsigned char *key); + +void aes256_ecb(unsigned char *out, const unsigned char *in, size_t nblocks, const aes256ctx *ctx); + +void aes256_ctr(unsigned char *out, size_t outlen, const unsigned char *iv, const aes256ctx *ctx); + +/** Frees the context **/ +void aes256_ctx_release(aes256ctx *r); + +static inline uint32_t br_dec32le(const unsigned char *src) { + return (uint32_t)src[0] + | ((uint32_t)src[1] << 8) + | ((uint32_t)src[2] << 16) + | ((uint32_t)src[3] << 24); +} + + +static void br_range_dec32le(uint32_t *v, size_t num, const unsigned char *src) { + while (num-- > 0) { + *v ++ = br_dec32le(src); + src += 4; + } +} + + +static inline uint32_t br_swap32(uint32_t x) { + x = ((x & (uint32_t)0x00FF00FF) << 8) + | ((x >> 8) & (uint32_t)0x00FF00FF); + return (x << 16) | (x >> 16); +} + + +static inline void br_enc32le(unsigned char *dst, uint32_t x) { + dst[0] = (unsigned char)x; + dst[1] = (unsigned char)(x >> 8); + dst[2] = (unsigned char)(x >> 16); + dst[3] = (unsigned char)(x >> 24); +} + + +static void br_range_enc32le(unsigned char *dst, const uint32_t *v, size_t num) { + while (num-- > 0) { + br_enc32le(dst, *v ++); + dst += 4; + } +} + + +static void br_aes_ct64_bitslice_Sbox(uint64_t *q) { + /* + * This S-box implementation is a straightforward translation of + * the circuit described by Boyar and Peralta in "A new + * combinational logic minimization technique with applications + * to cryptology" (https://eprint.iacr.org/2009/191.pdf). + * + * Note that variables x* (input) and s* (output) are numbered + * in "reverse" order (x0 is the high bit, x7 is the low bit). + */ + + uint64_t x0, x1, x2, x3, x4, x5, x6, x7; + uint64_t y1, y2, y3, y4, y5, y6, y7, y8, y9; + uint64_t y10, y11, y12, y13, y14, y15, y16, y17, y18, y19; + uint64_t y20, y21; + uint64_t z0, z1, z2, z3, z4, z5, z6, z7, z8, z9; + uint64_t z10, z11, z12, z13, z14, z15, z16, z17; + uint64_t t0, t1, t2, t3, t4, t5, t6, t7, t8, t9; + uint64_t t10, t11, t12, t13, t14, t15, t16, t17, t18, t19; + uint64_t t20, t21, t22, t23, t24, t25, t26, t27, t28, t29; + uint64_t t30, t31, t32, t33, t34, t35, t36, t37, t38, t39; + uint64_t t40, t41, t42, t43, t44, t45, t46, t47, t48, t49; + uint64_t t50, t51, t52, t53, t54, t55, t56, t57, t58, t59; + uint64_t t60, t61, t62, t63, t64, t65, t66, t67; + uint64_t s0, s1, s2, s3, s4, s5, s6, s7; + + x0 = q[7]; + x1 = q[6]; + x2 = q[5]; + x3 = q[4]; + x4 = q[3]; + x5 = q[2]; + x6 = q[1]; + x7 = q[0]; + + /* + * Top linear transformation. + */ + y14 = x3 ^ x5; + y13 = x0 ^ x6; + y9 = x0 ^ x3; + y8 = x0 ^ x5; + t0 = x1 ^ x2; + y1 = t0 ^ x7; + y4 = y1 ^ x3; + y12 = y13 ^ y14; + y2 = y1 ^ x0; + y5 = y1 ^ x6; + y3 = y5 ^ y8; + t1 = x4 ^ y12; + y15 = t1 ^ x5; + y20 = t1 ^ x1; + y6 = y15 ^ x7; + y10 = y15 ^ t0; + y11 = y20 ^ y9; + y7 = x7 ^ y11; + y17 = y10 ^ y11; + y19 = y10 ^ y8; + y16 = t0 ^ y11; + y21 = y13 ^ y16; + y18 = x0 ^ y16; + + /* + * Non-linear section. + */ + t2 = y12 & y15; + t3 = y3 & y6; + t4 = t3 ^ t2; + t5 = y4 & x7; + t6 = t5 ^ t2; + t7 = y13 & y16; + t8 = y5 & y1; + t9 = t8 ^ t7; + t10 = y2 & y7; + t11 = t10 ^ t7; + t12 = y9 & y11; + t13 = y14 & y17; + t14 = t13 ^ t12; + t15 = y8 & y10; + t16 = t15 ^ t12; + t17 = t4 ^ t14; + t18 = t6 ^ t16; + t19 = t9 ^ t14; + t20 = t11 ^ t16; + t21 = t17 ^ y20; + t22 = t18 ^ y19; + t23 = t19 ^ y21; + t24 = t20 ^ y18; + + t25 = t21 ^ t22; + t26 = t21 & t23; + t27 = t24 ^ t26; + t28 = t25 & t27; + t29 = t28 ^ t22; + t30 = t23 ^ t24; + t31 = t22 ^ t26; + t32 = t31 & t30; + t33 = t32 ^ t24; + t34 = t23 ^ t33; + t35 = t27 ^ t33; + t36 = t24 & t35; + t37 = t36 ^ t34; + t38 = t27 ^ t36; + t39 = t29 & t38; + t40 = t25 ^ t39; + + t41 = t40 ^ t37; + t42 = t29 ^ t33; + t43 = t29 ^ t40; + t44 = t33 ^ t37; + t45 = t42 ^ t41; + z0 = t44 & y15; + z1 = t37 & y6; + z2 = t33 & x7; + z3 = t43 & y16; + z4 = t40 & y1; + z5 = t29 & y7; + z6 = t42 & y11; + z7 = t45 & y17; + z8 = t41 & y10; + z9 = t44 & y12; + z10 = t37 & y3; + z11 = t33 & y4; + z12 = t43 & y13; + z13 = t40 & y5; + z14 = t29 & y2; + z15 = t42 & y9; + z16 = t45 & y14; + z17 = t41 & y8; + + /* + * Bottom linear transformation. + */ + t46 = z15 ^ z16; + t47 = z10 ^ z11; + t48 = z5 ^ z13; + t49 = z9 ^ z10; + t50 = z2 ^ z12; + t51 = z2 ^ z5; + t52 = z7 ^ z8; + t53 = z0 ^ z3; + t54 = z6 ^ z7; + t55 = z16 ^ z17; + t56 = z12 ^ t48; + t57 = t50 ^ t53; + t58 = z4 ^ t46; + t59 = z3 ^ t54; + t60 = t46 ^ t57; + t61 = z14 ^ t57; + t62 = t52 ^ t58; + t63 = t49 ^ t58; + t64 = z4 ^ t59; + t65 = t61 ^ t62; + t66 = z1 ^ t63; + s0 = t59 ^ t63; + s6 = t56 ^ ~t62; + s7 = t48 ^ ~t60; + t67 = t64 ^ t65; + s3 = t53 ^ t66; + s4 = t51 ^ t66; + s5 = t47 ^ t65; + s1 = t64 ^ ~s3; + s2 = t55 ^ ~t67; + + q[7] = s0; + q[6] = s1; + q[5] = s2; + q[4] = s3; + q[3] = s4; + q[2] = s5; + q[1] = s6; + q[0] = s7; +} + +static void br_aes_ct64_ortho(uint64_t *q) { +#define SWAPN(cl, ch, s, x, y) do { \ + uint64_t a, b; \ + a = (x); \ + b = (y); \ + (x) = (a & (uint64_t)(cl)) | ((b & (uint64_t)(cl)) << (s)); \ + (y) = ((a & (uint64_t)(ch)) >> (s)) | (b & (uint64_t)(ch)); \ + } while (0) + +#define SWAP2(x, y) SWAPN(0x5555555555555555, 0xAAAAAAAAAAAAAAAA, 1, x, y) +#define SWAP4(x, y) SWAPN(0x3333333333333333, 0xCCCCCCCCCCCCCCCC, 2, x, y) +#define SWAP8(x, y) SWAPN(0x0F0F0F0F0F0F0F0F, 0xF0F0F0F0F0F0F0F0, 4, x, y) + + SWAP2(q[0], q[1]); + SWAP2(q[2], q[3]); + SWAP2(q[4], q[5]); + SWAP2(q[6], q[7]); + + SWAP4(q[0], q[2]); + SWAP4(q[1], q[3]); + SWAP4(q[4], q[6]); + SWAP4(q[5], q[7]); + + SWAP8(q[0], q[4]); + SWAP8(q[1], q[5]); + SWAP8(q[2], q[6]); + SWAP8(q[3], q[7]); +} + + +static void br_aes_ct64_interleave_in(uint64_t *q0, uint64_t *q1, const uint32_t *w) { + uint64_t x0, x1, x2, x3; + + x0 = w[0]; + x1 = w[1]; + x2 = w[2]; + x3 = w[3]; + x0 |= (x0 << 16); + x1 |= (x1 << 16); + x2 |= (x2 << 16); + x3 |= (x3 << 16); + x0 &= (uint64_t)0x0000FFFF0000FFFF; + x1 &= (uint64_t)0x0000FFFF0000FFFF; + x2 &= (uint64_t)0x0000FFFF0000FFFF; + x3 &= (uint64_t)0x0000FFFF0000FFFF; + x0 |= (x0 << 8); + x1 |= (x1 << 8); + x2 |= (x2 << 8); + x3 |= (x3 << 8); + x0 &= (uint64_t)0x00FF00FF00FF00FF; + x1 &= (uint64_t)0x00FF00FF00FF00FF; + x2 &= (uint64_t)0x00FF00FF00FF00FF; + x3 &= (uint64_t)0x00FF00FF00FF00FF; + *q0 = x0 | (x2 << 8); + *q1 = x1 | (x3 << 8); +} + + +static void br_aes_ct64_interleave_out(uint32_t *w, uint64_t q0, uint64_t q1) { + uint64_t x0, x1, x2, x3; + + x0 = q0 & (uint64_t)0x00FF00FF00FF00FF; + x1 = q1 & (uint64_t)0x00FF00FF00FF00FF; + x2 = (q0 >> 8) & (uint64_t)0x00FF00FF00FF00FF; + x3 = (q1 >> 8) & (uint64_t)0x00FF00FF00FF00FF; + x0 |= (x0 >> 8); + x1 |= (x1 >> 8); + x2 |= (x2 >> 8); + x3 |= (x3 >> 8); + x0 &= (uint64_t)0x0000FFFF0000FFFF; + x1 &= (uint64_t)0x0000FFFF0000FFFF; + x2 &= (uint64_t)0x0000FFFF0000FFFF; + x3 &= (uint64_t)0x0000FFFF0000FFFF; + w[0] = (uint32_t)x0 | (uint32_t)(x0 >> 16); + w[1] = (uint32_t)x1 | (uint32_t)(x1 >> 16); + w[2] = (uint32_t)x2 | (uint32_t)(x2 >> 16); + w[3] = (uint32_t)x3 | (uint32_t)(x3 >> 16); +} + +static const unsigned char Rcon[] = { + 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1B, 0x36 +}; + +static uint32_t sub_word(uint32_t x) { + uint64_t q[8]; + + memset(q, 0, sizeof q); + q[0] = x; + br_aes_ct64_ortho(q); + br_aes_ct64_bitslice_Sbox(q); + br_aes_ct64_ortho(q); + return (uint32_t)q[0]; +} + +static void br_aes_ct64_keysched(uint64_t *comp_skey, const unsigned char *key, unsigned int key_len) { + unsigned int i, j, k, nk, nkf; + uint32_t tmp; + uint32_t skey[60]; + unsigned nrounds = 10 + ((key_len - 16) >> 2); + + nk = (key_len >> 2); + nkf = ((nrounds + 1) << 2); + br_range_dec32le(skey, (key_len >> 2), key); + tmp = skey[(key_len >> 2) - 1]; + for (i = nk, j = 0, k = 0; i < nkf; i ++) { + if (j == 0) { + tmp = (tmp << 24) | (tmp >> 8); + tmp = sub_word(tmp) ^ Rcon[k]; + } else if (nk > 6 && j == 4) { + tmp = sub_word(tmp); + } + tmp ^= skey[i - nk]; + skey[i] = tmp; + if (++ j == nk) { + j = 0; + k ++; + } + } + + for (i = 0, j = 0; i < nkf; i += 4, j += 2) { + uint64_t q[8]; + + br_aes_ct64_interleave_in(&q[0], &q[4], skey + i); + q[1] = q[0]; + q[2] = q[0]; + q[3] = q[0]; + q[5] = q[4]; + q[6] = q[4]; + q[7] = q[4]; + br_aes_ct64_ortho(q); + comp_skey[j + 0] = + (q[0] & (uint64_t)0x1111111111111111) + | (q[1] & (uint64_t)0x2222222222222222) + | (q[2] & (uint64_t)0x4444444444444444) + | (q[3] & (uint64_t)0x8888888888888888); + comp_skey[j + 1] = + (q[4] & (uint64_t)0x1111111111111111) + | (q[5] & (uint64_t)0x2222222222222222) + | (q[6] & (uint64_t)0x4444444444444444) + | (q[7] & (uint64_t)0x8888888888888888); + } +} + +static void br_aes_ct64_skey_expand(uint64_t *skey, const uint64_t *comp_skey, unsigned int nrounds) { + unsigned u, v, n; + + n = (nrounds + 1) << 1; + for (u = 0, v = 0; u < n; u ++, v += 4) { + uint64_t x0, x1, x2, x3; + + x0 = x1 = x2 = x3 = comp_skey[u]; + x0 &= (uint64_t)0x1111111111111111; + x1 &= (uint64_t)0x2222222222222222; + x2 &= (uint64_t)0x4444444444444444; + x3 &= (uint64_t)0x8888888888888888; + x1 >>= 1; + x2 >>= 2; + x3 >>= 3; + skey[v + 0] = (x0 << 4) - x0; + skey[v + 1] = (x1 << 4) - x1; + skey[v + 2] = (x2 << 4) - x2; + skey[v + 3] = (x3 << 4) - x3; + } +} + + +static inline void add_round_key(uint64_t *q, const uint64_t *sk) { + q[0] ^= sk[0]; + q[1] ^= sk[1]; + q[2] ^= sk[2]; + q[3] ^= sk[3]; + q[4] ^= sk[4]; + q[5] ^= sk[5]; + q[6] ^= sk[6]; + q[7] ^= sk[7]; +} + +static inline void shift_rows(uint64_t *q) { + int i; + + for (i = 0; i < 8; i ++) { + uint64_t x; + + x = q[i]; + q[i] = (x & (uint64_t)0x000000000000FFFF) + | ((x & (uint64_t)0x00000000FFF00000) >> 4) + | ((x & (uint64_t)0x00000000000F0000) << 12) + | ((x & (uint64_t)0x0000FF0000000000) >> 8) + | ((x & (uint64_t)0x000000FF00000000) << 8) + | ((x & (uint64_t)0xF000000000000000) >> 12) + | ((x & (uint64_t)0x0FFF000000000000) << 4); + } +} + +static inline uint64_t rotr32(uint64_t x) { + return (x << 32) | (x >> 32); +} + +static inline void mix_columns(uint64_t *q) { + uint64_t q0, q1, q2, q3, q4, q5, q6, q7; + uint64_t r0, r1, r2, r3, r4, r5, r6, r7; + + q0 = q[0]; + q1 = q[1]; + q2 = q[2]; + q3 = q[3]; + q4 = q[4]; + q5 = q[5]; + q6 = q[6]; + q7 = q[7]; + r0 = (q0 >> 16) | (q0 << 48); + r1 = (q1 >> 16) | (q1 << 48); + r2 = (q2 >> 16) | (q2 << 48); + r3 = (q3 >> 16) | (q3 << 48); + r4 = (q4 >> 16) | (q4 << 48); + r5 = (q5 >> 16) | (q5 << 48); + r6 = (q6 >> 16) | (q6 << 48); + r7 = (q7 >> 16) | (q7 << 48); + + q[0] = q7 ^ r7 ^ r0 ^ rotr32(q0 ^ r0); + q[1] = q0 ^ r0 ^ q7 ^ r7 ^ r1 ^ rotr32(q1 ^ r1); + q[2] = q1 ^ r1 ^ r2 ^ rotr32(q2 ^ r2); + q[3] = q2 ^ r2 ^ q7 ^ r7 ^ r3 ^ rotr32(q3 ^ r3); + q[4] = q3 ^ r3 ^ q7 ^ r7 ^ r4 ^ rotr32(q4 ^ r4); + q[5] = q4 ^ r4 ^ r5 ^ rotr32(q5 ^ r5); + q[6] = q5 ^ r5 ^ r6 ^ rotr32(q6 ^ r6); + q[7] = q6 ^ r6 ^ r7 ^ rotr32(q7 ^ r7); +} + + +static void inc4_be(uint32_t *x) { + uint32_t t = br_swap32(*x) + 4; + *x = br_swap32(t); +} + + +static void aes_ecb4x(unsigned char out[64], const uint32_t ivw[16], const uint64_t *sk_exp, unsigned int nrounds) { + uint32_t w[16]; + uint64_t q[8]; + unsigned int i; + + memcpy(w, ivw, sizeof(w)); + for (i = 0; i < 4; i++) { + br_aes_ct64_interleave_in(&q[i], &q[i + 4], w + (i << 2)); + } + br_aes_ct64_ortho(q); + + + add_round_key(q, sk_exp); + for (i = 1; i < nrounds; i++) { + br_aes_ct64_bitslice_Sbox(q); + shift_rows(q); + mix_columns(q); + add_round_key(q, sk_exp + (i << 3)); + } + br_aes_ct64_bitslice_Sbox(q); + shift_rows(q); + add_round_key(q, sk_exp + 8 * nrounds); + + br_aes_ct64_ortho(q); + for (i = 0; i < 4; i ++) { + br_aes_ct64_interleave_out(w + (i << 2), q[i], q[i + 4]); + } + br_range_enc32le(out, w, 16); +} + + +static void aes_ctr4x(unsigned char out[64], uint32_t ivw[16], const uint64_t *sk_exp, unsigned int nrounds) { + aes_ecb4x(out, ivw, sk_exp, nrounds); + + /* Increase counter for next 4 blocks */ + inc4_be(ivw + 3); + inc4_be(ivw + 7); + inc4_be(ivw + 11); + inc4_be(ivw + 15); +} + + +static void aes_ecb(unsigned char *out, const unsigned char *in, size_t nblocks, const uint64_t *rkeys, unsigned int nrounds) { + uint32_t blocks[16]; + unsigned char t[64]; + + while (nblocks >= 4) { + br_range_dec32le(blocks, 16, in); + aes_ecb4x(out, blocks, rkeys, nrounds); + nblocks -= 4; + in += 64; + out += 64; + } + + if (nblocks) { + br_range_dec32le(blocks, nblocks * 4, in); + aes_ecb4x(t, blocks, rkeys, nrounds); + memcpy(out, t, nblocks * 16); + } +} + + +static void aes_ctr(unsigned char *out, size_t outlen, const unsigned char *iv, const uint64_t *rkeys, unsigned int nrounds) { + uint32_t ivw[16]; + size_t i; + uint32_t cc = 0; + + br_range_dec32le(ivw, 3, iv); + memcpy(ivw + 4, ivw, 3 * sizeof(uint32_t)); + memcpy(ivw + 8, ivw, 3 * sizeof(uint32_t)); + memcpy(ivw + 12, ivw, 3 * sizeof(uint32_t)); + ivw[ 3] = br_swap32(cc); + ivw[ 7] = br_swap32(cc + 1); + ivw[11] = br_swap32(cc + 2); + ivw[15] = br_swap32(cc + 3); + + while (outlen > 64) { + aes_ctr4x(out, ivw, rkeys, nrounds); + out += 64; + outlen -= 64; + } + if (outlen > 0) { + unsigned char tmp[64]; + aes_ctr4x(tmp, ivw, rkeys, nrounds); + for (i = 0; i < outlen; i++) { + out[i] = tmp[i]; + } + } +} + +void aes128_ecb_keyexp(aes128ctx *r, const unsigned char *key) { + uint64_t skey[22]; + + r->sk_exp = malloc(sizeof(uint64_t) * PQC_AES128_STATESIZE); + if (r->sk_exp == NULL) { + exit(111); + } + + br_aes_ct64_keysched(skey, key, 16); + br_aes_ct64_skey_expand(r->sk_exp, skey, 10); +} + +void aes128_ctr_keyexp(aes128ctx *r, const unsigned char *key) { + aes128_ecb_keyexp(r, key); +} + + +void aes192_ecb_keyexp(aes192ctx *r, const unsigned char *key) { + uint64_t skey[26]; + r->sk_exp = malloc(sizeof(uint64_t) * PQC_AES192_STATESIZE); + if (r->sk_exp == NULL) { + exit(111); + } + + br_aes_ct64_keysched(skey, key, 24); + br_aes_ct64_skey_expand(r->sk_exp, skey, 12); +} + + +void aes192_ctr_keyexp(aes192ctx *r, const unsigned char *key) { + aes192_ecb_keyexp(r, key); +} + + +void aes256_ecb_keyexp(aes256ctx *r, const unsigned char *key) { + uint64_t skey[30]; + r->sk_exp = malloc(sizeof(uint64_t) * PQC_AES256_STATESIZE); + if (r->sk_exp == NULL) { + exit(111); + } + + br_aes_ct64_keysched(skey, key, 32); + br_aes_ct64_skey_expand(r->sk_exp, skey, 14); +} + + +void aes256_ctr_keyexp(aes256ctx *r, const unsigned char *key) { + aes256_ecb_keyexp(r, key); +} + + +void aes128_ecb(unsigned char *out, const unsigned char *in, size_t nblocks, const aes128ctx *ctx) { + aes_ecb(out, in, nblocks, ctx->sk_exp, 10); +} + +void aes128_ctr(unsigned char *out, size_t outlen, const unsigned char *iv, const aes128ctx *ctx) { + aes_ctr(out, outlen, iv, ctx->sk_exp, 10); +} + +void aes192_ecb(unsigned char *out, const unsigned char *in, size_t nblocks, const aes192ctx *ctx) { + aes_ecb(out, in, nblocks, ctx->sk_exp, 12); +} + +void aes192_ctr(unsigned char *out, size_t outlen, const unsigned char *iv, const aes192ctx *ctx) { + aes_ctr(out, outlen, iv, ctx->sk_exp, 12); +} + +void aes256_ecb(unsigned char *out, const unsigned char *in, size_t nblocks, const aes256ctx *ctx) { + aes_ecb(out, in, nblocks, ctx->sk_exp, 14); +} + +void aes256_ctr(unsigned char *out, size_t outlen, const unsigned char *iv, const aes256ctx *ctx) { + aes_ctr(out, outlen, iv, ctx->sk_exp, 14); +} + +void aes128_ctx_release(aes128ctx *r) { + free(r->sk_exp); +} + +void aes192_ctx_release(aes192ctx *r) { + free(r->sk_exp); +} + +void aes256_ctx_release(aes256ctx *r) { + free(r->sk_exp); +} + +int AES_128_CTR(unsigned char *output, size_t outputByteLen, + const unsigned char *input, size_t inputByteLen) { + aes128ctx ctx; + unsigned char iv[16] = { 0 }; + + aes128_ctr_keyexp(&ctx, input); + aes128_ctr(output, outputByteLen, iv, &ctx); + aes128_ctx_release(&ctx); + + return (int)outputByteLen; +} + +void AES_256_ECB(const uint8_t *input, const unsigned char *key, unsigned char *output) { + aes256ctx ctx; + + aes256_ecb_keyexp(&ctx, key); + aes256_ecb(output, input, 1, &ctx); + aes256_ctx_release(&ctx); +} + diff --git a/lib/mayo/aes_ctr.h b/lib/mayo/aes_ctr.h new file mode 100644 index 000000000..fdec519ac --- /dev/null +++ b/lib/mayo/aes_ctr.h @@ -0,0 +1,32 @@ +// SPDX-License-Identifier: Apache-2.0 + +#ifndef AESCTR_H +#define AESCTR_H + +#include +#include + +void AES_256_ECB(const uint8_t *input, const uint8_t *key, uint8_t *output); +#define AES_ECB_encrypt AES_256_ECB + +#ifdef ENABLE_AESNI +int AES_128_CTR_NI(unsigned char *output, size_t outputByteLen, + const unsigned char *input, size_t inputByteLen); +int AES_128_CTR_4R_NI(unsigned char *output, size_t outputByteLen, + const unsigned char *input, size_t inputByteLen); +#define AES_128_CTR AES_128_CTR_NI +#else +#ifdef ENABLE_AESNEON +int AES_128_CTR_NEON(unsigned char *output, size_t outputByteLen, + const unsigned char *input, size_t inputByteLen); +int AES_128_CTR_4R_NI(unsigned char *output, size_t outputByteLen, + const unsigned char *input, size_t inputByteLen); +#define AES_128_CTR AES_128_CTR_NEON +#else +int AES_128_CTR(unsigned char *output, size_t outputByteLen, + const unsigned char *input, size_t inputByteLen); +#endif +#endif + +#endif + diff --git a/lib/mayo/api.c b/lib/mayo/api.c new file mode 100644 index 000000000..f2e861e9c --- /dev/null +++ b/lib/mayo/api.c @@ -0,0 +1,46 @@ +// SPDX-License-Identifier: Apache-2.0 + +#include +#include + +#ifdef ENABLE_PARAMS_DYNAMIC +#define MAYO_PARAMS &MAYO_5 +#else +#define MAYO_PARAMS 0 +#endif + +int +crypto_sign_keypair(unsigned char *pk, unsigned char *sk) { + return mayo_keypair(MAYO_PARAMS, pk, sk); +} + +int +crypto_sign(unsigned char *sm, size_t *smlen, + const unsigned char *m, size_t mlen, + const unsigned char *sk) { + return mayo_sign(MAYO_PARAMS, sm, smlen, m, mlen, sk); +} + +int +crypto_sign_signature(unsigned char *sig, + size_t *siglen, const unsigned char *m, + size_t mlen, const unsigned char *sk) { + return mayo_sign_signature(MAYO_PARAMS, sig, siglen, m, mlen, sk); +} + +int +crypto_sign_open(unsigned char *m, size_t *mlen, + const unsigned char *sm, size_t smlen, + const unsigned char *pk) { + return mayo_open(MAYO_PARAMS, m, mlen, sm, smlen, pk); +} + +int +crypto_sign_verify(const unsigned char *sig, size_t siglen, + const unsigned char *m, size_t mlen, + const unsigned char *pk) { + if (siglen != CRYPTO_BYTES) + return -1; + return mayo_verify(MAYO_PARAMS, m, mlen, sig, pk); +} + diff --git a/lib/mayo/api.h b/lib/mayo/api.h new file mode 100644 index 000000000..44caa7d1f --- /dev/null +++ b/lib/mayo/api.h @@ -0,0 +1,43 @@ +// SPDX-License-Identifier: Apache-2.0 + +#ifndef api_h +#define api_h + +#include + +#define CRYPTO_SECRETKEYBYTES 40 +#define CRYPTO_PUBLICKEYBYTES 5554 +#define CRYPTO_BYTES 964 + +#define CRYPTO_ALGNAME "MAYO-5" + +#define crypto_sign_keypair MAYO_NAMESPACE(crypto_sign_keypair) +int +crypto_sign_keypair(unsigned char *pk, unsigned char *sk); + +#define crypto_sign MAYO_NAMESPACE(crypto_sign) +int +crypto_sign(unsigned char *sm, size_t *smlen, + const unsigned char *m, size_t mlen, + const unsigned char *sk); + +#define crypto_sign_signature MAYO_NAMESPACE(crypto_sign_signature) +int +crypto_sign_signature(unsigned char *sig, + size_t *siglen, const unsigned char *m, + size_t mlen, const unsigned char *sk); + +#define crypto_sign_open MAYO_NAMESPACE(crypto_sign_open) +int +crypto_sign_open(unsigned char *m, size_t *mlen, + const unsigned char *sm, size_t smlen, + const unsigned char *pk); + +#define crypto_sign_verify MAYO_NAMESPACE(crypto_sign_verify) +int +crypto_sign_verify(const unsigned char *sig, size_t siglen, + const unsigned char *m, size_t mlen, + const unsigned char *pk); + +#endif /* api_h */ + diff --git a/lib/mayo/arithmetic.c b/lib/mayo/arithmetic.c new file mode 100644 index 000000000..803d695f3 --- /dev/null +++ b/lib/mayo/arithmetic.c @@ -0,0 +1,128 @@ +// SPDX-License-Identifier: Apache-2.0 + +#include +#include +#include +#include +#include +#include +#include +#ifdef ENABLE_CT_TESTING +#include +#endif + +void m_upper(const mayo_params_t* p, const uint64_t *in, uint64_t *out, int size) { + #ifndef ENABLE_PARAMS_DYNAMIC + (void) p; + #endif + // Look into AVX2'ing this + const int m_vec_limbs = PARAM_m_vec_limbs(p); + int m_vecs_stored = 0; + for (int r = 0; r < size; r++) { + for (int c = r; c < size; c++) { + m_vec_copy(m_vec_limbs, in + m_vec_limbs * (r * size + c), out + m_vec_limbs * m_vecs_stored ); + if (r != c) { + m_vec_add(m_vec_limbs, in + m_vec_limbs * (c * size + r), out + m_vec_limbs * m_vecs_stored ); + } + m_vecs_stored ++; + } + } +} + + +// sample a solution x to Ax = y, with r used as randomness +// require: +// - A is a matrix with m rows and k*o+1 collumns (values in the last collum are +// not important, they will be overwritten by y) in row major order +// - y is a vector with m elements +// - r and x are k*o bytes long +// return: 1 on success, 0 on failure +int sample_solution(const mayo_params_t *p, unsigned char *A, + const unsigned char *y, const unsigned char *r, + unsigned char *x, int k, int o, int m, int A_cols) { + #ifdef MAYO_VARIANT + (void) p; + #endif + unsigned char finished; + int col_upper_bound; + unsigned char correct_column; + + // x <- r + for (int i = 0; i < k * o; i++) { + x[i] = r[i]; + } + + // compute Ar; + unsigned char Ar[M_MAX]; + for (int i = 0; i < m; i++) { + A[k * o + i * (k * o + 1)] = 0; // clear last col of A + } + mat_mul(A, r, Ar, k * o + 1, m, 1); + + // move y - Ar to last column of matrix A + for (int i = 0; i < m; i++) { + A[k * o + i * (k * o + 1)] = sub_f(y[i], Ar[i]); + } + + EF(A, m, k * o + 1); + + // check if last row of A (excluding the last entry of y) is zero + unsigned char full_rank = 0; + for (int i = 0; i < A_cols - 1; i++) { + full_rank |= A[(m - 1) * A_cols + i]; + } + +// It is okay to leak if we need to restart or not +#ifdef ENABLE_CT_TESTING + VALGRIND_MAKE_MEM_DEFINED(&full_rank, 1); +#endif + + if (full_rank == 0) { + return 0; + } + + // back substitution in constant time + // the index of the first nonzero entry in each row is secret, which makes + // things less efficient + + for (int row = m - 1; row >= 0; row--) { + finished = 0; + col_upper_bound = MAYO_MIN(row + (32/(m-row)), k*o); + // the first nonzero entry in row r is between r and col_upper_bound with probability at least ~1-q^{-32} + + for (int col = row; col <= col_upper_bound; col++) { + + // Compare two chars in constant time. + // Returns 0x00 if the byte arrays are equal, 0xff otherwise. + correct_column = ct_compare_8((A[row * A_cols + col]), 0) & ~finished; + + unsigned char u = correct_column & A[row * A_cols + A_cols - 1]; + x[col] ^= u; + + for (int i = 0; i < row; i += 8) { + uint64_t tmp = ( (uint64_t) A[ i * A_cols + col] << 0) ^ ( (uint64_t) A[(i+1) * A_cols + col] << 8) + ^ ( (uint64_t) A[(i+2) * A_cols + col] << 16) ^ ( (uint64_t) A[(i+3) * A_cols + col] << 24) + ^ ( (uint64_t) A[(i+4) * A_cols + col] << 32) ^ ( (uint64_t) A[(i+5) * A_cols + col] << 40) + ^ ( (uint64_t) A[(i+6) * A_cols + col] << 48) ^ ( (uint64_t) A[(i+7) * A_cols + col] << 56); + + tmp = mul_fx8(u, tmp); + + A[ i * A_cols + A_cols - 1] ^= (tmp ) & 0xf; + A[(i+1) * A_cols + A_cols - 1] ^= (tmp >> 8 ) & 0xf; + A[(i+2) * A_cols + A_cols - 1] ^= (tmp >> 16) & 0xf; + A[(i+3) * A_cols + A_cols - 1] ^= (tmp >> 24) & 0xf; + A[(i+4) * A_cols + A_cols - 1] ^= (tmp >> 32) & 0xf; + A[(i+5) * A_cols + A_cols - 1] ^= (tmp >> 40) & 0xf; + A[(i+6) * A_cols + A_cols - 1] ^= (tmp >> 48) & 0xf; + A[(i+7) * A_cols + A_cols - 1] ^= (tmp >> 56) & 0xf; + } + + finished = finished | correct_column; + } + } + return 1; +} + +volatile uint32_t uint32_t_blocker = 0; +volatile uint64_t uint64_t_blocker = 0; +volatile unsigned char unsigned_char_blocker = 0; diff --git a/lib/mayo/arithmetic.h b/lib/mayo/arithmetic.h new file mode 100644 index 000000000..0fdd0e367 --- /dev/null +++ b/lib/mayo/arithmetic.h @@ -0,0 +1,124 @@ + +// SPDX-License-Identifier: Apache-2.0 + +#ifndef ARITHMETIC_H +#define ARITHMETIC_H + +#include +#include +#include +#include + +#if defined(__BYTE_ORDER__) && (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__) +#ifndef TARGET_BIG_ENDIAN +#define TARGET_BIG_ENDIAN +#endif +#endif + +#define uint32_t_blocker MAYO_NAMESPACE(uint32_t_blocker) +extern volatile uint32_t uint32_t_blocker; +#define uint64_t_blocker MAYO_NAMESPACE(uint64_t_blocker) +extern volatile uint64_t uint64_t_blocker; +#define unsigned_char_blocker MAYO_NAMESPACE(unsigned_char_blocker) +extern volatile unsigned char unsigned_char_blocker; + +#if !(((!defined(__clang__) && defined(__GNUC__) && __GNUC__ <= 12)) && (defined(__x86_64__) || defined(_M_X64))) +// a > b -> b - a is negative +// returns 0xFFFFFFFF if true, 0x00000000 if false +static inline uint32_t ct_is_greater_than(int a, int b) { + int32_t diff = b - a; + return ((uint32_t) (diff >> (8*sizeof(uint32_t)-1)) ^ uint32_t_blocker); +} + +// a > b -> b - a is negative +// returns 0xFFFFFFFF if true, 0x00000000 if false +static inline uint64_t ct_64_is_greater_than(int a, int b) { + int64_t diff = ((int64_t) b) - ((int64_t) a); + return ((uint64_t) (diff >> (8*sizeof(uint64_t)-1)) ^ uint64_t_blocker); +} + +// if a == b -> 0x00000000, else 0xFFFFFFFF +static inline uint32_t ct_compare_32(int a, int b) { + return ((uint32_t)((-(int32_t)(a ^ b)) >> (8*sizeof(uint32_t)-1)) ^ uint32_t_blocker); +} + +// if a == b -> 0x0000000000000000, else 0xFFFFFFFFFFFFFFFF +static inline uint64_t ct_compare_64(int a, int b) { + return ((uint64_t)((-(int64_t)(a ^ b)) >> (8*sizeof(uint64_t)-1)) ^ uint64_t_blocker); +} + +// if a == b -> 0x00, else 0xFF +static inline unsigned char ct_compare_8(unsigned char a, unsigned char b) { + return ((int8_t)((-(int32_t)(a ^ b)) >> (8*sizeof(uint32_t)-1)) ^ unsigned_char_blocker); +} +#else +// a > b -> b - a is negative +// returns 0xFFFFFFFF if true, 0x00000000 if false +static inline uint32_t ct_is_greater_than(int a, int b) { + int32_t diff = b - a; + return ((uint32_t) (diff >> (8*sizeof(uint32_t)-1))); +} + +// a > b -> b - a is negative +// returns 0xFFFFFFFF if true, 0x00000000 if false +static inline uint64_t ct_64_is_greater_than(int a, int b) { + int64_t diff = ((int64_t) b) - ((int64_t) a); + return ((uint64_t) (diff >> (8*sizeof(uint64_t)-1))); +} + +// if a == b -> 0x00000000, else 0xFFFFFFFF +static inline uint32_t ct_compare_32(int a, int b) { + return ((uint32_t)((-(int32_t)(a ^ b)) >> (8*sizeof(uint32_t)-1))); +} + +// if a == b -> 0x0000000000000000, else 0xFFFFFFFFFFFFFFFF +static inline uint64_t ct_compare_64(int a, int b) { + return ((uint64_t)((-(int64_t)(a ^ b)) >> (8*sizeof(uint64_t)-1))); +} + +// if a == b -> 0x00, else 0xFF +static inline unsigned char ct_compare_8(unsigned char a, unsigned char b) { + return ((int8_t)((-(int32_t)(a ^ b)) >> (8*sizeof(uint32_t)-1))); +} +#endif + +#if defined(MAYO_AVX) || defined(MAYO_NEON) + #include +#elif defined(MAYO_M4) + #include +#else + #include +#endif + +static +inline void vec_mul_add_u64(const int legs, const uint64_t *in, unsigned char a, uint64_t *acc) { + uint32_t tab = mul_table(a); + + uint64_t lsb_ask = 0x1111111111111111ULL; + + for(int i=0; i < legs; i++){ + acc[i] ^= ( in[i] & lsb_ask) * (tab & 0xff) + ^ ((in[i] >> 1) & lsb_ask) * ((tab >> 8) & 0xf) + ^ ((in[i] >> 2) & lsb_ask) * ((tab >> 16) & 0xf) + ^ ((in[i] >> 3) & lsb_ask) * ((tab >> 24) & 0xf); + } +} + +// Calculate Upper in KeyGen +#define m_upper MAYO_NAMESPACE(m_upper) +void m_upper(const mayo_params_t* p, const uint64_t *in, uint64_t *out, int size); + +// Sample solution in Sign +#define sample_solution MAYO_NAMESPACE(sample_solution) +int sample_solution(const mayo_params_t *p, unsigned char *A, const unsigned char *y, const unsigned char *r, unsigned char *x, int k, int o, int m, int A_cols); + +#if defined(__GNUC__) || defined(__clang__) +#define BSWAP32(i) __builtin_bswap32((i)) +#define BSWAP64(i) __builtin_bswap64((i)) +#else +#define BSWAP32(i) ((((i) >> 24) & 0xff) | (((i) >> 8) & 0xff00) | (((i) & 0xff00) << 8) | ((i) << 24)) +#define BSWAP64(i) ((BSWAP32((i) >> 32) & 0xffffffff) | (BSWAP32(i) << 32)) +#endif + +#endif + diff --git a/lib/mayo/arithmetic_dynamic.h b/lib/mayo/arithmetic_dynamic.h new file mode 100644 index 000000000..d91f6c520 --- /dev/null +++ b/lib/mayo/arithmetic_dynamic.h @@ -0,0 +1,68 @@ +// SPDX-License-Identifier: Apache-2.0 + +#ifndef ARITHMETIC_DYNAMIC_H +#define ARITHMETIC_DYNAMIC_H + +#include +#include + +static +inline void m_vec_copy(int m_vec_limbs, const uint64_t *in, uint64_t *out) { + for (int i = 0; i < m_vec_limbs; i++) { + out[i] = in[i]; + } +} + +static +inline void m_vec_add(int m_vec_limbs, const uint64_t *in, uint64_t *acc) { + for (int i = 0; i < m_vec_limbs; i++) { + acc[i] ^= in[i]; + } +} + +static inline +void m_vec_mul_add(int m_vec_limbs, const uint64_t *in, unsigned char a, uint64_t *acc) { + for(int i=0; i < m_vec_limbs; i++){ + acc[i] ^= gf16v_mul_u64(in[i], a); + } +} + +inline +static void m_vec_mul_add_x (int m_vec_limbs, const uint64_t *in, uint64_t *acc) { + uint64_t mask_msb = 0x8888888888888888ULL; + for(int i=0; i < m_vec_limbs; i++){ + uint64_t t = in[i] & mask_msb; + acc[i] ^= ((in[i] ^ t) << 1) ^ ((t >> 3) * 3); + } +} + +inline +static void m_vec_mul_add_x_inv (int m_vec_limbs, const uint64_t *in, uint64_t *acc) { + uint64_t mask_lsb = 0x1111111111111111ULL; + for(int i=0; i < m_vec_limbs; i++){ + uint64_t t = in[i] & mask_lsb; + acc[i] ^= ((in[i] ^ t) >> 1) ^ (t * 9); + } +} + +static +inline void m_vec_multiply_bins (int m_vec_limbs, uint64_t *bins, uint64_t *out) { + + m_vec_mul_add_x_inv (m_vec_limbs, bins + 5 * m_vec_limbs, bins + 10 * m_vec_limbs); + m_vec_mul_add_x (m_vec_limbs, bins + 11 * m_vec_limbs, bins + 12 * m_vec_limbs); + m_vec_mul_add_x_inv (m_vec_limbs, bins + 10 * m_vec_limbs, bins + 7 * m_vec_limbs); + m_vec_mul_add_x (m_vec_limbs, bins + 12 * m_vec_limbs, bins + 6 * m_vec_limbs); + m_vec_mul_add_x_inv (m_vec_limbs, bins + 7 * m_vec_limbs, bins + 14 * m_vec_limbs); + m_vec_mul_add_x (m_vec_limbs, bins + 6 * m_vec_limbs, bins + 3 * m_vec_limbs); + m_vec_mul_add_x_inv (m_vec_limbs, bins + 14 * m_vec_limbs, bins + 15 * m_vec_limbs); + m_vec_mul_add_x (m_vec_limbs, bins + 3 * m_vec_limbs, bins + 8 * m_vec_limbs); + m_vec_mul_add_x_inv (m_vec_limbs, bins + 15 * m_vec_limbs, bins + 13 * m_vec_limbs); + m_vec_mul_add_x (m_vec_limbs, bins + 8 * m_vec_limbs, bins + 4 * m_vec_limbs); + m_vec_mul_add_x_inv (m_vec_limbs, bins + 13 * m_vec_limbs, bins + 9 * m_vec_limbs); + m_vec_mul_add_x (m_vec_limbs, bins + 4 * m_vec_limbs, bins + 2 * m_vec_limbs); + m_vec_mul_add_x_inv (m_vec_limbs, bins + 9 * m_vec_limbs, bins + 1 * m_vec_limbs); + m_vec_mul_add_x (m_vec_limbs, bins + 2 * m_vec_limbs, bins + 1 * m_vec_limbs); + m_vec_copy (m_vec_limbs, bins + m_vec_limbs, out); +} + +#endif \ No newline at end of file diff --git a/lib/mayo/arithmetic_fixed.h b/lib/mayo/arithmetic_fixed.h new file mode 100644 index 000000000..bd0ccf27f --- /dev/null +++ b/lib/mayo/arithmetic_fixed.h @@ -0,0 +1,84 @@ +// SPDX-License-Identifier: Apache-2.0 + +#ifndef ARITHMETIC_FIXED_H +#define ARITHMETIC_FIXED_H + +#include +#include +#include + +// This implements arithmetic for vectors of X field elements in Z_2[x]/(x^4+x+1) + +static +inline void m_vec_copy (int m_vec_limbs, const uint64_t *in, uint64_t *out) { + (void) m_vec_limbs; + for (size_t i = 0; i < M_VEC_LIMBS_MAX; i++) + { + out[i] = in[i]; + } +} + +static +inline void m_vec_add (int m_vec_limbs, const uint64_t *in, uint64_t *acc) { + (void) m_vec_limbs; + for (size_t i = 0; i < M_VEC_LIMBS_MAX; i++) + { + acc[i] ^= in[i]; + } +} + +static +inline void m_vec_mul_add (int m_vec_limbs, const uint64_t *in, unsigned char a, uint64_t *acc) { + (void) m_vec_limbs; + uint32_t tab = mul_table(a); + + uint64_t lsb_ask = 0x1111111111111111ULL; + + for(int i=0; i < M_VEC_LIMBS_MAX ;i++){ + acc[i] ^= ( in[i] & lsb_ask) * (tab & 0xff) + ^ ((in[i] >> 1) & lsb_ask) * ((tab >> 8) & 0xf) + ^ ((in[i] >> 2) & lsb_ask) * ((tab >> 16) & 0xf) + ^ ((in[i] >> 3) & lsb_ask) * ((tab >> 24) & 0xf); + } +} + +inline +static void m_vec_mul_add_x (int m_vec_limbs, const uint64_t *in, uint64_t *acc) { + (void) m_vec_limbs; + uint64_t mask_msb = 0x8888888888888888ULL; + for(int i=0; i < M_VEC_LIMBS_MAX; i++){ + uint64_t t = in[i] & mask_msb; + acc[i] ^= ((in[i] ^ t) << 1) ^ ((t >> 3) * 3); + } +} + +inline +static void m_vec_mul_add_x_inv (int m_vec_limbs, const uint64_t *in, uint64_t *acc) { + (void) m_vec_limbs; + uint64_t mask_lsb = 0x1111111111111111ULL; + for(int i=0; i < M_VEC_LIMBS_MAX; i++){ + uint64_t t = in[i] & mask_lsb; + acc[i] ^= ((in[i] ^ t) >> 1) ^ (t * 9); + } +} + +static +inline void m_vec_multiply_bins (int m_vec_limbs, uint64_t *bins, uint64_t *out) { + m_vec_mul_add_x_inv (m_vec_limbs, bins + 5 * M_VEC_LIMBS_MAX, bins + 10 * M_VEC_LIMBS_MAX); + m_vec_mul_add_x (m_vec_limbs, bins + 11 * M_VEC_LIMBS_MAX, bins + 12 * M_VEC_LIMBS_MAX); + m_vec_mul_add_x_inv (m_vec_limbs, bins + 10 * M_VEC_LIMBS_MAX, bins + 7 * M_VEC_LIMBS_MAX); + m_vec_mul_add_x (m_vec_limbs, bins + 12 * M_VEC_LIMBS_MAX, bins + 6 * M_VEC_LIMBS_MAX); + m_vec_mul_add_x_inv (m_vec_limbs, bins + 7 * M_VEC_LIMBS_MAX, bins + 14 * M_VEC_LIMBS_MAX); + m_vec_mul_add_x (m_vec_limbs, bins + 6 * M_VEC_LIMBS_MAX, bins + 3 * M_VEC_LIMBS_MAX); + m_vec_mul_add_x_inv (m_vec_limbs, bins + 14 * M_VEC_LIMBS_MAX, bins + 15 * M_VEC_LIMBS_MAX); + m_vec_mul_add_x (m_vec_limbs, bins + 3 * M_VEC_LIMBS_MAX, bins + 8 * M_VEC_LIMBS_MAX); + m_vec_mul_add_x_inv (m_vec_limbs, bins + 15 * M_VEC_LIMBS_MAX, bins + 13 * M_VEC_LIMBS_MAX); + m_vec_mul_add_x (m_vec_limbs, bins + 8 * M_VEC_LIMBS_MAX, bins + 4 * M_VEC_LIMBS_MAX); + m_vec_mul_add_x_inv (m_vec_limbs, bins + 13 * M_VEC_LIMBS_MAX, bins + 9 * M_VEC_LIMBS_MAX); + m_vec_mul_add_x (m_vec_limbs, bins + 4 * M_VEC_LIMBS_MAX, bins + 2 * M_VEC_LIMBS_MAX); + m_vec_mul_add_x_inv (m_vec_limbs, bins + 9 * M_VEC_LIMBS_MAX, bins + 1 * M_VEC_LIMBS_MAX); + m_vec_mul_add_x (m_vec_limbs, bins + 2 * M_VEC_LIMBS_MAX, bins + 1 * M_VEC_LIMBS_MAX); + m_vec_copy (m_vec_limbs, bins + M_VEC_LIMBS_MAX, out); +} + +#endif diff --git a/lib/mayo/debug_bench_tools.h b/lib/mayo/debug_bench_tools.h new file mode 100644 index 000000000..8d1259289 --- /dev/null +++ b/lib/mayo/debug_bench_tools.h @@ -0,0 +1,69 @@ +// SPDX-License-Identifier: Apache-2.0 + +#ifndef DEBUG_BENCH_TOOLS_H +#define DEBUG_BENCH_TOOLS_H + +#include +#include + +static inline int64_t cpucycles(void) { +#if (defined(TARGET_AMD64) || defined(TARGET_X86)) + unsigned int hi, lo; + + asm volatile ("rdtsc" : "=a" (lo), "=d"(hi)); + return ((int64_t) lo) | (((int64_t) hi) << 32); +#elif (defined(TARGET_S390X)) + uint64_t tod; + asm volatile("stckf %0\n" : "=Q" (tod) : : "cc"); + return (tod * 1000 / 4096); +#else + struct timespec time; + clock_gettime(CLOCK_REALTIME, &time); + return (int64_t)(time.tv_sec * 1e9 + time.tv_nsec); +#endif +} + +#ifdef TICTOC +#define TIC printf("\n"); \ + int64_t tic_toc_cycles = cpucycles(); + +#define TOC(name) printf(" %-30s cycles: %lu \n", name, cpucycles() - tic_toc_cycles); \ + tic_toc_cycles = cpucycles(); +#else +#define TIC +#define TOC(name) +#endif + +#ifdef MAYO_AVX + +#include + +static inline void print_avx2(__m256i a){ + unsigned char *temp = (unsigned char*) &a; + for (size_t i = 0; i < 32; i++) + { + printf("%X", temp[i] & 0xf); + printf("%X", temp[i] >> 4); + if(i%4 == 3){ + printf(" "); + } + } + printf("\n"); +} + +static inline void print_avx2_(__m256i a){ + unsigned char *temp = (unsigned char*) &a; + for (size_t i = 0; i < 32; i++) + { + printf("%X", temp[i] & 0xf); + printf("%X", temp[i] >> 4); + if(i%4 == 3){ + printf(" "); + } + } +} + +#endif + +#endif + diff --git a/lib/mayo/echelon_form.h b/lib/mayo/echelon_form.h new file mode 100644 index 000000000..5a171f5a5 --- /dev/null +++ b/lib/mayo/echelon_form.h @@ -0,0 +1,152 @@ + +// SPDX-License-Identifier: Apache-2.0 + +#ifndef ECHELON_FORM_H +#define ECHELON_FORM_H + +#include +#include +#include +#include + +#define MAYO_MAX(x, y) (((x) > (y)) ? (x) : (y)) +#define MAYO_MIN(x, y) (((x) < (y)) ? (x) : (y)) + +static inline unsigned char +m_extract_element(const uint64_t *in, int index) { + const int leg = index / 16; + const int offset = index % 16; + + return (in[leg] >> (offset*4)) & 0xF; +} + +static inline void +ef_pack_m_vec(const unsigned char *in, uint64_t *out, int ncols) { + int i; + unsigned char *out8 = (unsigned char *)out; + for(i = 0; i+1 < ncols; i += 2){ +#ifdef TARGET_BIG_ENDIAN + out8[(((i/2 + 8) / 8) * 8) - 1 - (i/2)%8] = (in[i+0] << 0) | (in[i+1] << 4); +#else + out8[i/2] = (in[i+0] << 0) | (in[i+1] << 4); +#endif + } + if (ncols % 2 == 1){ +#ifdef TARGET_BIG_ENDIAN + out8[(((i/2 + 8) / 8) * 8) - 1 - (i/2)%8] = (in[i+0] << 0); +#else + out8[i/2] = (in[i+0] << 0); +#endif + } +} + +static inline void +ef_unpack_m_vec(int legs, const uint64_t *in, unsigned char *out) { + const unsigned char *in8 = (const unsigned char *)in; + for(int i = 0; i < legs * 16; i += 2){ +#ifdef TARGET_BIG_ENDIAN + out[i] = (in8[(((i/2 + 8) / 8) * 8) - 1 - (i/2)%8]) & 0xF; + out[i+1] = (in8[(((i/2 + 8) / 8) * 8) - 1 - (i/2)%8] >> 4); +#else + out[i] = (in8[i/2]) & 0xF; + out[i+1] = (in8[i/2] >> 4); +#endif + } +} + + +// put matrix in row echelon form with ones on first nonzero entries *in +// constant time* +static inline void EF(unsigned char *A, int nrows, int ncols) { + + alignas (32) uint64_t _pivot_row[(K_MAX * O_MAX + 1 + 15) / 16]; + alignas (32) uint64_t _pivot_row2[(K_MAX * O_MAX + 1 + 15) / 16]; + alignas (32) uint64_t packed_A[((K_MAX * O_MAX + 1 + 15) / 16) * M_MAX] = {0}; + + int row_len = (ncols + 15) / 16; + + // nibbleslice the matrix A + for (int i = 0; i < nrows; i++) { + ef_pack_m_vec(A + i * ncols, packed_A + i * row_len, ncols); + } + + // pivot row is secret, pivot col is not + + unsigned char inverse; + int pivot_row = 0; + for (int pivot_col = 0; pivot_col < ncols; pivot_col++) { + + int pivot_row_lower_bound = MAYO_MAX(0, pivot_col + nrows - ncols); + int pivot_row_upper_bound = MAYO_MIN(nrows - 1, pivot_col); + // the pivot row is guaranteed to be between these lower and upper bounds if + // A has full rank + + // zero out pivot row + for (int i = 0; i < row_len; i++) { + _pivot_row[i] = 0; + _pivot_row2[i] = 0; + } + + // try to get a pivot row in constant time + unsigned char pivot = 0; + uint64_t pivot_is_zero = -1; + for (int row = pivot_row_lower_bound; + row <= MAYO_MIN(nrows - 1, pivot_row_upper_bound + 32); row++) { + + uint64_t is_pivot_row = ~ct_compare_64(row, pivot_row); + uint64_t below_pivot_row = ct_64_is_greater_than(row, pivot_row); + + for (int j = 0; j < row_len; j++) { + _pivot_row[j] ^= (is_pivot_row | (below_pivot_row & pivot_is_zero)) & + packed_A[row * row_len + j]; + } + pivot = m_extract_element(_pivot_row, pivot_col); + pivot_is_zero = ~ct_compare_64((int) pivot, 0); + } + + // multiply pivot row by inverse of pivot + inverse = inverse_f(pivot); + vec_mul_add_u64(row_len, _pivot_row, inverse, _pivot_row2); + + // conditionally write pivot row to the correct row, if there is a nonzero + // pivot + for (int row = pivot_row_lower_bound; row <= pivot_row_upper_bound; row++) { + uint64_t do_copy = ~ct_compare_64(row, pivot_row) & ~pivot_is_zero; + uint64_t do_not_copy = ~do_copy; + for (int col = 0; col < row_len; col++) { + packed_A[row * row_len + col] = + (do_not_copy & packed_A[row * row_len + col]) + + (do_copy & _pivot_row2[col]); + } + } + + // eliminate entries below pivot + for (int row = pivot_row_lower_bound; row < nrows; row++) { + unsigned char below_pivot = (row > pivot_row); + unsigned char elt_to_elim = m_extract_element(packed_A + row * row_len, pivot_col); + + vec_mul_add_u64(row_len, _pivot_row2, below_pivot * elt_to_elim, + packed_A + row * row_len); + } + + pivot_row += (-(int64_t)(~pivot_is_zero)); + } + + unsigned char temp[(O_MAX * K_MAX + 1 + 15)]; + + // unbitslice the matrix A + for (int i = 0; i < nrows; i++) { + ef_unpack_m_vec(row_len, packed_A + i * row_len, temp); + for (int j = 0; j < ncols; j++) { + A[i * ncols + j] = temp[j]; + } + } + + mayo_secure_clear(temp, K_MAX * O_MAX + 1 + 15); + mayo_secure_clear(_pivot_row, (K_MAX * O_MAX + 1 + 15) / 16 * 8); + mayo_secure_clear(_pivot_row2, (K_MAX * O_MAX + 1 + 15) / 16 * 8); + mayo_secure_clear(packed_A, ((K_MAX * O_MAX + 1 + 15) / 16) * M_MAX * 8); +} + +#endif + diff --git a/lib/mayo/ef_inner_loop.h b/lib/mayo/ef_inner_loop.h new file mode 100644 index 000000000..52b43d913 --- /dev/null +++ b/lib/mayo/ef_inner_loop.h @@ -0,0 +1,56 @@ +// SPDX-License-Identifier: Apache-2.0 + +int pivot_row_lower_bound = MAYO_MAX(0, pivot_col + nrows - ncols); +int pivot_row_upper_bound = MAYO_MIN(nrows - 1, pivot_col); +// the pivot row is guaranteed to be between these lower and upper bounds if +// A has full rank + +// zero out pivot row +for (int i = offset; i < row_len; i++) { + _pivot_row[i] = 0; + _pivot_row2[i] = 0; +} + +// try to get a pivot row in constant time +unsigned char pivot = 0; +uint64_t pivot_is_zero = -1; +for (int row = pivot_row_lower_bound; + row <= MAYO_MIN(nrows - 1, pivot_row_upper_bound + 32); row++) { + + uint64_t is_pivot_row = ~ct_compare_64(row, pivot_row); + uint64_t below_pivot_row = ct_64_is_greater_than(row, pivot_row); + + for (int j = offset; j < row_len; j++) { + _pivot_row[j] ^= (is_pivot_row | (below_pivot_row & pivot_is_zero)) & + packed_A[row * row_len + j]; + } + pivot = m_extract_element(_pivot_row, pivot_col); + pivot_is_zero = ~ct_compare_64((int) pivot, 0); +} + +// multiply pivot row by inverse of pivot +inverse = inverse_f(pivot); +vec_mul_add_u64(row_len - offset, _pivot_row + offset, inverse, _pivot_row2 + offset); + +// conditionally write pivot row to the correct row, if there is a nonzero +// pivot +for (int row = pivot_row_lower_bound; row <= pivot_row_upper_bound; row++) { + uint64_t do_copy = ~ct_compare_64(row, pivot_row) & ~pivot_is_zero; + uint64_t do_not_copy = ~do_copy; + for (int col = offset; col < row_len; col++) { + packed_A[row * row_len + col] = + (do_not_copy & packed_A[row * row_len + col]) + + (do_copy & _pivot_row2[col]); + } +} + +// eliminate entries below pivot +for (int row = pivot_row_lower_bound; row < nrows; row++) { + unsigned char below_pivot = (row > pivot_row); + unsigned char elt_to_elim = m_extract_element(packed_A + row * row_len, pivot_col); + + vec_mul_add_u64(row_len - offset, _pivot_row2 + offset, below_pivot * elt_to_elim, + packed_A + row * row_len + offset); +} + +pivot_row += (-(int32_t)(~pivot_is_zero)); diff --git a/lib/mayo/fips202.c b/lib/mayo/fips202.c new file mode 100644 index 000000000..1a5475a4e --- /dev/null +++ b/lib/mayo/fips202.c @@ -0,0 +1,1093 @@ +// SPDX-License-Identifier: Public Domain and Apache-2.0 + +/* AES implementation based on code from PQClean, + * which is in turn based based on the public domain implementation in + * crypto_hash/keccakc512/simple/ from http://bench.cr.yp.to/supercop.html + * by Ronny Van Keer + * and the public domain "TweetFips202" implementation + * from https://twitter.com/tweetfips202 + * by Gilles Van Assche, Daniel J. Bernstein, and Peter Schwabe */ + +#include +#include +#include +#include + +#include +#include + +#define SHAKE128_RATE 168 +#define SHAKE256_RATE 136 +#define SHA3_256_RATE 136 +#define SHA3_384_RATE 104 +#define SHA3_512_RATE 72 + +#define PQC_SHAKEINCCTX_BYTES (sizeof(uint64_t)*26) +#define PQC_SHAKECTX_BYTES (sizeof(uint64_t)*25) + +// Context for incremental API +typedef struct { + uint64_t *ctx; +} shake128incctx; + +// Context for non-incremental API +typedef struct { + uint64_t *ctx; +} shake128ctx; + +// Context for incremental API +typedef struct { + uint64_t *ctx; +} shake256incctx; + +// Context for non-incremental API +typedef struct { + uint64_t *ctx; +} shake256ctx; + +// Context for incremental API +typedef struct { + uint64_t *ctx; +} sha3_256incctx; + +// Context for incremental API +typedef struct { + uint64_t *ctx; +} sha3_384incctx; + +// Context for incremental API +typedef struct { + uint64_t *ctx; +} sha3_512incctx; + +/* Initialize the state and absorb the provided input. + * + * This function does not support being called multiple times + * with the same state. + */ +void shake128_absorb(shake128ctx *state, const uint8_t *input, size_t inlen); +/* Squeeze output out of the sponge. + * + * Supports being called multiple times + */ +void shake128_squeezeblocks(uint8_t *output, size_t nblocks, shake128ctx *state); +/* Free the state */ +void shake128_ctx_release(shake128ctx *state); +/* Copy the state. */ +void shake128_ctx_clone(shake128ctx *dest, const shake128ctx *src); + +/* Initialize incremental hashing API */ +void shake128_inc_init(shake128incctx *state); +/* Absorb more information into the XOF. + * + * Can be called multiple times. + */ +void shake128_inc_absorb(shake128incctx *state, const uint8_t *input, size_t inlen); +/* Finalize the XOF for squeezing */ +void shake128_inc_finalize(shake128incctx *state); +/* Squeeze output out of the sponge. + * + * Supports being called multiple times + */ +void shake128_inc_squeeze(uint8_t *output, size_t outlen, shake128incctx *state); +/* Copy the context of the SHAKE128 XOF */ +void shake128_inc_ctx_clone(shake128incctx *dest, const shake128incctx *src); +/* Free the context of the SHAKE128 XOF */ +void shake128_inc_ctx_release(shake128incctx *state); + +/* Initialize the state and absorb the provided input. + * + * This function does not support being called multiple times + * with the same state. + */ +void shake256_absorb(shake256ctx *state, const uint8_t *input, size_t inlen); +/* Squeeze output out of the sponge. + * + * Supports being called multiple times + */ +void shake256_squeezeblocks(uint8_t *output, size_t nblocks, shake256ctx *state); +/* Free the context held by this XOF */ +void shake256_ctx_release(shake256ctx *state); +/* Copy the context held by this XOF */ +void shake256_ctx_clone(shake256ctx *dest, const shake256ctx *src); + +/* Initialize incremental hashing API */ +void shake256_inc_init(shake256incctx *state); +void shake256_inc_absorb(shake256incctx *state, const uint8_t *input, size_t inlen); +/* Prepares for squeeze phase */ +void shake256_inc_finalize(shake256incctx *state); +/* Squeeze output out of the sponge. + * + * Supports being called multiple times + */ +void shake256_inc_squeeze(uint8_t *output, size_t outlen, shake256incctx *state); +/* Copy the state */ +void shake256_inc_ctx_clone(shake256incctx *dest, const shake256incctx *src); +/* Free the state */ +void shake256_inc_ctx_release(shake256incctx *state); + +/* One-stop SHAKE128 call */ +void shake128(uint8_t *output, size_t outlen, + const uint8_t *input, size_t inlen); + +/* One-stop SHAKE256 call */ +void shake256(uint8_t *output, size_t outlen, + const uint8_t *input, size_t inlen); + +/* Initialize the incremental hashing state */ +void sha3_256_inc_init(sha3_256incctx *state); +/* Absorb blocks into SHA3 */ +void sha3_256_inc_absorb(sha3_256incctx *state, const uint8_t *input, size_t inlen); +/* Obtain the output of the function and free `state` */ +void sha3_256_inc_finalize(uint8_t *output, sha3_256incctx *state); +/* Copy the context */ +void sha3_256_inc_ctx_clone(sha3_256incctx *dest, const sha3_256incctx *src); +/* Release the state, don't use if `_finalize` has been used */ +void sha3_256_inc_ctx_release(sha3_256incctx *state); + +void sha3_256(uint8_t *output, const uint8_t *input, size_t inlen); + +/* Initialize the incremental hashing state */ +void sha3_384_inc_init(sha3_384incctx *state); +/* Absorb blocks into SHA3 */ +void sha3_384_inc_absorb(sha3_384incctx *state, const uint8_t *input, size_t inlen); +/* Obtain the output of the function and free `state` */ +void sha3_384_inc_finalize(uint8_t *output, sha3_384incctx *state); +/* Copy the context */ +void sha3_384_inc_ctx_clone(sha3_384incctx *dest, const sha3_384incctx *src); +/* Release the state, don't use if `_finalize` has been used */ +void sha3_384_inc_ctx_release(sha3_384incctx *state); + +/* One-stop SHA3-384 shop */ +void sha3_384(uint8_t *output, const uint8_t *input, size_t inlen); + +/* Initialize the incremental hashing state */ +void sha3_512_inc_init(sha3_512incctx *state); +/* Absorb blocks into SHA3 */ +void sha3_512_inc_absorb(sha3_512incctx *state, const uint8_t *input, size_t inlen); +/* Obtain the output of the function and free `state` */ +void sha3_512_inc_finalize(uint8_t *output, sha3_512incctx *state); +/* Copy the context */ +void sha3_512_inc_ctx_clone(sha3_512incctx *dest, const sha3_512incctx *src); +/* Release the state, don't use if `_finalize` has been used */ +void sha3_512_inc_ctx_release(sha3_512incctx *state); + +/* One-stop SHA3-512 shop */ +void sha3_512(uint8_t *output, const uint8_t *input, size_t inlen); + +#define NROUNDS 24 +#define ROL(a, offset) (((a) << (offset)) ^ ((a) >> (64 - (offset)))) + +/************************************************* + * Name: load64 + * + * Description: Load 8 bytes into uint64_t in little-endian order + * + * Arguments: - const uint8_t *x: pointer to input byte array + * + * Returns the loaded 64-bit unsigned integer + **************************************************/ +static uint64_t load64(const uint8_t *x) { + uint64_t r = 0; + for (size_t i = 0; i < 8; ++i) { + r |= (uint64_t)x[i] << 8 * i; + } + + return r; +} + +/************************************************* + * Name: store64 + * + * Description: Store a 64-bit integer to a byte array in little-endian order + * + * Arguments: - uint8_t *x: pointer to the output byte array + * - uint64_t u: input 64-bit unsigned integer + **************************************************/ +static void store64(uint8_t *x, uint64_t u) { + for (size_t i = 0; i < 8; ++i) { + x[i] = (uint8_t) (u >> 8 * i); + } +} + +/* Keccak round constants */ +static const uint64_t KeccakF_RoundConstants[NROUNDS] = { + 0x0000000000000001ULL, 0x0000000000008082ULL, + 0x800000000000808aULL, 0x8000000080008000ULL, + 0x000000000000808bULL, 0x0000000080000001ULL, + 0x8000000080008081ULL, 0x8000000000008009ULL, + 0x000000000000008aULL, 0x0000000000000088ULL, + 0x0000000080008009ULL, 0x000000008000000aULL, + 0x000000008000808bULL, 0x800000000000008bULL, + 0x8000000000008089ULL, 0x8000000000008003ULL, + 0x8000000000008002ULL, 0x8000000000000080ULL, + 0x000000000000800aULL, 0x800000008000000aULL, + 0x8000000080008081ULL, 0x8000000000008080ULL, + 0x0000000080000001ULL, 0x8000000080008008ULL +}; + +/************************************************* + * Name: KeccakF1600_StatePermute + * + * Description: The Keccak F1600 Permutation + * + * Arguments: - uint64_t *state: pointer to input/output Keccak state + **************************************************/ +static void KeccakF1600_StatePermute(uint64_t *state) { + int round; + + uint64_t Aba, Abe, Abi, Abo, Abu; + uint64_t Aga, Age, Agi, Ago, Agu; + uint64_t Aka, Ake, Aki, Ako, Aku; + uint64_t Ama, Ame, Ami, Amo, Amu; + uint64_t Asa, Ase, Asi, Aso, Asu; + uint64_t BCa, BCe, BCi, BCo, BCu; + uint64_t Da, De, Di, Do, Du; + uint64_t Eba, Ebe, Ebi, Ebo, Ebu; + uint64_t Ega, Ege, Egi, Ego, Egu; + uint64_t Eka, Eke, Eki, Eko, Eku; + uint64_t Ema, Eme, Emi, Emo, Emu; + uint64_t Esa, Ese, Esi, Eso, Esu; + + // copyFromState(A, state) + Aba = state[0]; + Abe = state[1]; + Abi = state[2]; + Abo = state[3]; + Abu = state[4]; + Aga = state[5]; + Age = state[6]; + Agi = state[7]; + Ago = state[8]; + Agu = state[9]; + Aka = state[10]; + Ake = state[11]; + Aki = state[12]; + Ako = state[13]; + Aku = state[14]; + Ama = state[15]; + Ame = state[16]; + Ami = state[17]; + Amo = state[18]; + Amu = state[19]; + Asa = state[20]; + Ase = state[21]; + Asi = state[22]; + Aso = state[23]; + Asu = state[24]; + + for (round = 0; round < NROUNDS; round += 2) { + // prepareTheta + BCa = Aba ^ Aga ^ Aka ^ Ama ^ Asa; + BCe = Abe ^ Age ^ Ake ^ Ame ^ Ase; + BCi = Abi ^ Agi ^ Aki ^ Ami ^ Asi; + BCo = Abo ^ Ago ^ Ako ^ Amo ^ Aso; + BCu = Abu ^ Agu ^ Aku ^ Amu ^ Asu; + + // thetaRhoPiChiIotaPrepareTheta(round , A, E) + Da = BCu ^ ROL(BCe, 1); + De = BCa ^ ROL(BCi, 1); + Di = BCe ^ ROL(BCo, 1); + Do = BCi ^ ROL(BCu, 1); + Du = BCo ^ ROL(BCa, 1); + + Aba ^= Da; + BCa = Aba; + Age ^= De; + BCe = ROL(Age, 44); + Aki ^= Di; + BCi = ROL(Aki, 43); + Amo ^= Do; + BCo = ROL(Amo, 21); + Asu ^= Du; + BCu = ROL(Asu, 14); + Eba = BCa ^ ((~BCe) & BCi); + Eba ^= KeccakF_RoundConstants[round]; + Ebe = BCe ^ ((~BCi) & BCo); + Ebi = BCi ^ ((~BCo) & BCu); + Ebo = BCo ^ ((~BCu) & BCa); + Ebu = BCu ^ ((~BCa) & BCe); + + Abo ^= Do; + BCa = ROL(Abo, 28); + Agu ^= Du; + BCe = ROL(Agu, 20); + Aka ^= Da; + BCi = ROL(Aka, 3); + Ame ^= De; + BCo = ROL(Ame, 45); + Asi ^= Di; + BCu = ROL(Asi, 61); + Ega = BCa ^ ((~BCe) & BCi); + Ege = BCe ^ ((~BCi) & BCo); + Egi = BCi ^ ((~BCo) & BCu); + Ego = BCo ^ ((~BCu) & BCa); + Egu = BCu ^ ((~BCa) & BCe); + + Abe ^= De; + BCa = ROL(Abe, 1); + Agi ^= Di; + BCe = ROL(Agi, 6); + Ako ^= Do; + BCi = ROL(Ako, 25); + Amu ^= Du; + BCo = ROL(Amu, 8); + Asa ^= Da; + BCu = ROL(Asa, 18); + Eka = BCa ^ ((~BCe) & BCi); + Eke = BCe ^ ((~BCi) & BCo); + Eki = BCi ^ ((~BCo) & BCu); + Eko = BCo ^ ((~BCu) & BCa); + Eku = BCu ^ ((~BCa) & BCe); + + Abu ^= Du; + BCa = ROL(Abu, 27); + Aga ^= Da; + BCe = ROL(Aga, 36); + Ake ^= De; + BCi = ROL(Ake, 10); + Ami ^= Di; + BCo = ROL(Ami, 15); + Aso ^= Do; + BCu = ROL(Aso, 56); + Ema = BCa ^ ((~BCe) & BCi); + Eme = BCe ^ ((~BCi) & BCo); + Emi = BCi ^ ((~BCo) & BCu); + Emo = BCo ^ ((~BCu) & BCa); + Emu = BCu ^ ((~BCa) & BCe); + + Abi ^= Di; + BCa = ROL(Abi, 62); + Ago ^= Do; + BCe = ROL(Ago, 55); + Aku ^= Du; + BCi = ROL(Aku, 39); + Ama ^= Da; + BCo = ROL(Ama, 41); + Ase ^= De; + BCu = ROL(Ase, 2); + Esa = BCa ^ ((~BCe) & BCi); + Ese = BCe ^ ((~BCi) & BCo); + Esi = BCi ^ ((~BCo) & BCu); + Eso = BCo ^ ((~BCu) & BCa); + Esu = BCu ^ ((~BCa) & BCe); + + // prepareTheta + BCa = Eba ^ Ega ^ Eka ^ Ema ^ Esa; + BCe = Ebe ^ Ege ^ Eke ^ Eme ^ Ese; + BCi = Ebi ^ Egi ^ Eki ^ Emi ^ Esi; + BCo = Ebo ^ Ego ^ Eko ^ Emo ^ Eso; + BCu = Ebu ^ Egu ^ Eku ^ Emu ^ Esu; + + // thetaRhoPiChiIotaPrepareTheta(round+1, E, A) + Da = BCu ^ ROL(BCe, 1); + De = BCa ^ ROL(BCi, 1); + Di = BCe ^ ROL(BCo, 1); + Do = BCi ^ ROL(BCu, 1); + Du = BCo ^ ROL(BCa, 1); + + Eba ^= Da; + BCa = Eba; + Ege ^= De; + BCe = ROL(Ege, 44); + Eki ^= Di; + BCi = ROL(Eki, 43); + Emo ^= Do; + BCo = ROL(Emo, 21); + Esu ^= Du; + BCu = ROL(Esu, 14); + Aba = BCa ^ ((~BCe) & BCi); + Aba ^= KeccakF_RoundConstants[round + 1]; + Abe = BCe ^ ((~BCi) & BCo); + Abi = BCi ^ ((~BCo) & BCu); + Abo = BCo ^ ((~BCu) & BCa); + Abu = BCu ^ ((~BCa) & BCe); + + Ebo ^= Do; + BCa = ROL(Ebo, 28); + Egu ^= Du; + BCe = ROL(Egu, 20); + Eka ^= Da; + BCi = ROL(Eka, 3); + Eme ^= De; + BCo = ROL(Eme, 45); + Esi ^= Di; + BCu = ROL(Esi, 61); + Aga = BCa ^ ((~BCe) & BCi); + Age = BCe ^ ((~BCi) & BCo); + Agi = BCi ^ ((~BCo) & BCu); + Ago = BCo ^ ((~BCu) & BCa); + Agu = BCu ^ ((~BCa) & BCe); + + Ebe ^= De; + BCa = ROL(Ebe, 1); + Egi ^= Di; + BCe = ROL(Egi, 6); + Eko ^= Do; + BCi = ROL(Eko, 25); + Emu ^= Du; + BCo = ROL(Emu, 8); + Esa ^= Da; + BCu = ROL(Esa, 18); + Aka = BCa ^ ((~BCe) & BCi); + Ake = BCe ^ ((~BCi) & BCo); + Aki = BCi ^ ((~BCo) & BCu); + Ako = BCo ^ ((~BCu) & BCa); + Aku = BCu ^ ((~BCa) & BCe); + + Ebu ^= Du; + BCa = ROL(Ebu, 27); + Ega ^= Da; + BCe = ROL(Ega, 36); + Eke ^= De; + BCi = ROL(Eke, 10); + Emi ^= Di; + BCo = ROL(Emi, 15); + Eso ^= Do; + BCu = ROL(Eso, 56); + Ama = BCa ^ ((~BCe) & BCi); + Ame = BCe ^ ((~BCi) & BCo); + Ami = BCi ^ ((~BCo) & BCu); + Amo = BCo ^ ((~BCu) & BCa); + Amu = BCu ^ ((~BCa) & BCe); + + Ebi ^= Di; + BCa = ROL(Ebi, 62); + Ego ^= Do; + BCe = ROL(Ego, 55); + Eku ^= Du; + BCi = ROL(Eku, 39); + Ema ^= Da; + BCo = ROL(Ema, 41); + Ese ^= De; + BCu = ROL(Ese, 2); + Asa = BCa ^ ((~BCe) & BCi); + Ase = BCe ^ ((~BCi) & BCo); + Asi = BCi ^ ((~BCo) & BCu); + Aso = BCo ^ ((~BCu) & BCa); + Asu = BCu ^ ((~BCa) & BCe); + } + + // copyToState(state, A) + state[0] = Aba; + state[1] = Abe; + state[2] = Abi; + state[3] = Abo; + state[4] = Abu; + state[5] = Aga; + state[6] = Age; + state[7] = Agi; + state[8] = Ago; + state[9] = Agu; + state[10] = Aka; + state[11] = Ake; + state[12] = Aki; + state[13] = Ako; + state[14] = Aku; + state[15] = Ama; + state[16] = Ame; + state[17] = Ami; + state[18] = Amo; + state[19] = Amu; + state[20] = Asa; + state[21] = Ase; + state[22] = Asi; + state[23] = Aso; + state[24] = Asu; +} + +/************************************************* + * Name: keccak_absorb + * + * Description: Absorb step of Keccak; + * non-incremental, starts by zeroeing the state. + * + * Arguments: - uint64_t *s: pointer to (uninitialized) output Keccak state + * - uint32_t r: rate in bytes (e.g., 168 for SHAKE128) + * - const uint8_t *m: pointer to input to be absorbed into s + * - size_t mlen: length of input in bytes + * - uint8_t p: domain-separation byte for different + * Keccak-derived functions + **************************************************/ +static void keccak_absorb(uint64_t *s, uint32_t r, const uint8_t *m, + size_t mlen, uint8_t p) { + size_t i; + uint8_t t[200]; + + /* Zero state */ + for (i = 0; i < 25; ++i) { + s[i] = 0; + } + + while (mlen >= r) { + for (i = 0; i < r / 8; ++i) { + s[i] ^= load64(m + 8 * i); + } + + KeccakF1600_StatePermute(s); + mlen -= r; + m += r; + } + + for (i = 0; i < r; ++i) { + t[i] = 0; + } + for (i = 0; i < mlen; ++i) { + t[i] = m[i]; + } + t[i] = p; + t[r - 1] |= 128; + for (i = 0; i < r / 8; ++i) { + s[i] ^= load64(t + 8 * i); + } +} + +/************************************************* + * Name: keccak_squeezeblocks + * + * Description: Squeeze step of Keccak. Squeezes full blocks of r bytes each. + * Modifies the state. Can be called multiple times to keep + * squeezing, i.e., is incremental. + * + * Arguments: - uint8_t *h: pointer to output blocks + * - size_t nblocks: number of blocks to be + * squeezed (written to h) + * - uint64_t *s: pointer to input/output Keccak state + * - uint32_t r: rate in bytes (e.g., 168 for SHAKE128) + **************************************************/ +static void keccak_squeezeblocks(uint8_t *h, size_t nblocks, + uint64_t *s, uint32_t r) { + while (nblocks > 0) { + KeccakF1600_StatePermute(s); + for (size_t i = 0; i < (r >> 3); i++) { + store64(h + 8 * i, s[i]); + } + h += r; + nblocks--; + } +} + +/************************************************* + * Name: keccak_inc_init + * + * Description: Initializes the incremental Keccak state to zero. + * + * Arguments: - uint64_t *s_inc: pointer to input/output incremental state + * First 25 values represent Keccak state. + * 26th value represents either the number of absorbed bytes + * that have not been permuted, or not-yet-squeezed bytes. + **************************************************/ +static void keccak_inc_init(uint64_t *s_inc) { + size_t i; + + for (i = 0; i < 25; ++i) { + s_inc[i] = 0; + } + s_inc[25] = 0; +} + +/************************************************* + * Name: keccak_inc_absorb + * + * Description: Incremental keccak absorb + * Preceded by keccak_inc_init, succeeded by keccak_inc_finalize + * + * Arguments: - uint64_t *s_inc: pointer to input/output incremental state + * First 25 values represent Keccak state. + * 26th value represents either the number of absorbed bytes + * that have not been permuted, or not-yet-squeezed bytes. + * - uint32_t r: rate in bytes (e.g., 168 for SHAKE128) + * - const uint8_t *m: pointer to input to be absorbed into s + * - size_t mlen: length of input in bytes + **************************************************/ +static void keccak_inc_absorb(uint64_t *s_inc, uint32_t r, const uint8_t *m, + size_t mlen) { + size_t i; + + /* Recall that s_inc[25] is the non-absorbed bytes xored into the state */ + while (mlen + s_inc[25] >= r) { + for (i = 0; i < r - (uint32_t)s_inc[25]; i++) { + /* Take the i'th byte from message + xor with the s_inc[25] + i'th byte of the state; little-endian */ + s_inc[(s_inc[25] + i) >> 3] ^= (uint64_t)m[i] << (8 * ((s_inc[25] + i) & 0x07)); + } + mlen -= (size_t)(r - s_inc[25]); + m += r - s_inc[25]; + s_inc[25] = 0; + + KeccakF1600_StatePermute(s_inc); + } + + for (i = 0; i < mlen; i++) { + s_inc[(s_inc[25] + i) >> 3] ^= (uint64_t)m[i] << (8 * ((s_inc[25] + i) & 0x07)); + } + s_inc[25] += mlen; +} + +/************************************************* + * Name: keccak_inc_finalize + * + * Description: Finalizes Keccak absorb phase, prepares for squeezing + * + * Arguments: - uint64_t *s_inc: pointer to input/output incremental state + * First 25 values represent Keccak state. + * 26th value represents either the number of absorbed bytes + * that have not been permuted, or not-yet-squeezed bytes. + * - uint32_t r: rate in bytes (e.g., 168 for SHAKE128) + * - uint8_t p: domain-separation byte for different + * Keccak-derived functions + **************************************************/ +static void keccak_inc_finalize(uint64_t *s_inc, uint32_t r, uint8_t p) { + /* After keccak_inc_absorb, we are guaranteed that s_inc[25] < r, + so we can always use one more byte for p in the current state. */ + s_inc[s_inc[25] >> 3] ^= (uint64_t)p << (8 * (s_inc[25] & 0x07)); + s_inc[(r - 1) >> 3] ^= (uint64_t)128 << (8 * ((r - 1) & 0x07)); + s_inc[25] = 0; +} + +/************************************************* + * Name: keccak_inc_squeeze + * + * Description: Incremental Keccak squeeze; can be called on byte-level + * + * Arguments: - uint8_t *h: pointer to output bytes + * - size_t outlen: number of bytes to be squeezed + * - uint64_t *s_inc: pointer to input/output incremental state + * First 25 values represent Keccak state. + * 26th value represents either the number of absorbed bytes + * that have not been permuted, or not-yet-squeezed bytes. + * - uint32_t r: rate in bytes (e.g., 168 for SHAKE128) + **************************************************/ +static void keccak_inc_squeeze(uint8_t *h, size_t outlen, + uint64_t *s_inc, uint32_t r) { + size_t i; + + /* First consume any bytes we still have sitting around */ + for (i = 0; i < outlen && i < s_inc[25]; i++) { + /* There are s_inc[25] bytes left, so r - s_inc[25] is the first + available byte. We consume from there, i.e., up to r. */ + h[i] = (uint8_t)(s_inc[(r - s_inc[25] + i) >> 3] >> (8 * ((r - s_inc[25] + i) & 0x07))); + } + h += i; + outlen -= i; + s_inc[25] -= i; + + /* Then squeeze the remaining necessary blocks */ + while (outlen > 0) { + KeccakF1600_StatePermute(s_inc); + + for (i = 0; i < outlen && i < r; i++) { + h[i] = (uint8_t)(s_inc[i >> 3] >> (8 * (i & 0x07))); + } + h += i; + outlen -= i; + s_inc[25] = r - i; + } +} + +void shake128_inc_init(shake128incctx *state) { + state->ctx = malloc(PQC_SHAKEINCCTX_BYTES); + if (state->ctx == NULL) { + exit(111); + } + keccak_inc_init(state->ctx); +} + +void shake128_inc_absorb(shake128incctx *state, const uint8_t *input, size_t inlen) { + keccak_inc_absorb(state->ctx, SHAKE128_RATE, input, inlen); +} + +void shake128_inc_finalize(shake128incctx *state) { + keccak_inc_finalize(state->ctx, SHAKE128_RATE, 0x1F); +} + +void shake128_inc_squeeze(uint8_t *output, size_t outlen, shake128incctx *state) { + keccak_inc_squeeze(output, outlen, state->ctx, SHAKE128_RATE); +} + +void shake128_inc_ctx_clone(shake128incctx *dest, const shake128incctx *src) { + dest->ctx = malloc(PQC_SHAKEINCCTX_BYTES); + if (dest->ctx == NULL) { + exit(111); + } + memcpy(dest->ctx, src->ctx, PQC_SHAKEINCCTX_BYTES); +} + +void shake128_inc_ctx_release(shake128incctx *state) { + free(state->ctx); +} + +void shake256_inc_init(shake256incctx *state) { + state->ctx = malloc(PQC_SHAKEINCCTX_BYTES); + if (state->ctx == NULL) { + exit(111); + } + keccak_inc_init(state->ctx); +} + +void shake256_inc_absorb(shake256incctx *state, const uint8_t *input, size_t inlen) { + keccak_inc_absorb(state->ctx, SHAKE256_RATE, input, inlen); +} + +void shake256_inc_finalize(shake256incctx *state) { + keccak_inc_finalize(state->ctx, SHAKE256_RATE, 0x1F); +} + +void shake256_inc_squeeze(uint8_t *output, size_t outlen, shake256incctx *state) { + keccak_inc_squeeze(output, outlen, state->ctx, SHAKE256_RATE); +} + +void shake256_inc_ctx_clone(shake256incctx *dest, const shake256incctx *src) { + dest->ctx = malloc(PQC_SHAKEINCCTX_BYTES); + if (dest->ctx == NULL) { + exit(111); + } + memcpy(dest->ctx, src->ctx, PQC_SHAKEINCCTX_BYTES); +} + +void shake256_inc_ctx_release(shake256incctx *state) { + free(state->ctx); +} + + +/************************************************* + * Name: shake128_absorb + * + * Description: Absorb step of the SHAKE128 XOF. + * non-incremental, starts by zeroeing the state. + * + * Arguments: - uint64_t *s: pointer to (uninitialized) output Keccak state + * - const uint8_t *input: pointer to input to be absorbed + * into s + * - size_t inlen: length of input in bytes + **************************************************/ +void shake128_absorb(shake128ctx *state, const uint8_t *input, size_t inlen) { + state->ctx = malloc(PQC_SHAKECTX_BYTES); + if (state->ctx == NULL) { + exit(111); + } + keccak_absorb(state->ctx, SHAKE128_RATE, input, inlen, 0x1F); +} + +/************************************************* + * Name: shake128_squeezeblocks + * + * Description: Squeeze step of SHAKE128 XOF. Squeezes full blocks of + * SHAKE128_RATE bytes each. Modifies the state. Can be called + * multiple times to keep squeezing, i.e., is incremental. + * + * Arguments: - uint8_t *output: pointer to output blocks + * - size_t nblocks: number of blocks to be squeezed + * (written to output) + * - shake128ctx *state: pointer to input/output Keccak state + **************************************************/ +void shake128_squeezeblocks(uint8_t *output, size_t nblocks, shake128ctx *state) { + keccak_squeezeblocks(output, nblocks, state->ctx, SHAKE128_RATE); +} + +void shake128_ctx_clone(shake128ctx *dest, const shake128ctx *src) { + dest->ctx = malloc(PQC_SHAKECTX_BYTES); + if (dest->ctx == NULL) { + exit(111); + } + memcpy(dest->ctx, src->ctx, PQC_SHAKECTX_BYTES); +} + +/** Release the allocated state. Call only once. */ +void shake128_ctx_release(shake128ctx *state) { + free(state->ctx); +} + +/************************************************* + * Name: shake256_absorb + * + * Description: Absorb step of the SHAKE256 XOF. + * non-incremental, starts by zeroeing the state. + * + * Arguments: - shake256ctx *state: pointer to (uninitialized) output Keccak state + * - const uint8_t *input: pointer to input to be absorbed + * into s + * - size_t inlen: length of input in bytes + **************************************************/ +void shake256_absorb(shake256ctx *state, const uint8_t *input, size_t inlen) { + state->ctx = malloc(PQC_SHAKECTX_BYTES); + if (state->ctx == NULL) { + exit(111); + } + keccak_absorb(state->ctx, SHAKE256_RATE, input, inlen, 0x1F); +} + +/************************************************* + * Name: shake256_squeezeblocks + * + * Description: Squeeze step of SHAKE256 XOF. Squeezes full blocks of + * SHAKE256_RATE bytes each. Modifies the state. Can be called + * multiple times to keep squeezing, i.e., is incremental. + * + * Arguments: - uint8_t *output: pointer to output blocks + * - size_t nblocks: number of blocks to be squeezed + * (written to output) + * - shake256ctx *state: pointer to input/output Keccak state + **************************************************/ +void shake256_squeezeblocks(uint8_t *output, size_t nblocks, shake256ctx *state) { + keccak_squeezeblocks(output, nblocks, state->ctx, SHAKE256_RATE); +} + +void shake256_ctx_clone(shake256ctx *dest, const shake256ctx *src) { + dest->ctx = malloc(PQC_SHAKECTX_BYTES); + if (dest->ctx == NULL) { + exit(111); + } + memcpy(dest->ctx, src->ctx, PQC_SHAKECTX_BYTES); +} + +/** Release the allocated state. Call only once. */ +void shake256_ctx_release(shake256ctx *state) { + free(state->ctx); +} + +/************************************************* + * Name: shake128 + * + * Description: SHAKE128 XOF with non-incremental API + * + * Arguments: - uint8_t *output: pointer to output + * - size_t outlen: requested output length in bytes + * - const uint8_t *input: pointer to input + * - size_t inlen: length of input in bytes + **************************************************/ +void shake128(uint8_t *output, size_t outlen, + const uint8_t *input, size_t inlen) { + size_t nblocks = outlen / SHAKE128_RATE; + uint8_t t[SHAKE128_RATE]; + shake128ctx s; + + shake128_absorb(&s, input, inlen); + shake128_squeezeblocks(output, nblocks, &s); + + output += nblocks * SHAKE128_RATE; + outlen -= nblocks * SHAKE128_RATE; + + if (outlen) { + shake128_squeezeblocks(t, 1, &s); + for (size_t i = 0; i < outlen; ++i) { + output[i] = t[i]; + } + } + shake128_ctx_release(&s); +} + +/************************************************* + * Name: shake256 + * + * Description: SHAKE256 XOF with non-incremental API + * + * Arguments: - uint8_t *output: pointer to output + * - size_t outlen: requested output length in bytes + * - const uint8_t *input: pointer to input + * - size_t inlen: length of input in bytes + **************************************************/ +void shake256(uint8_t *output, size_t outlen, + const uint8_t *input, size_t inlen) { + size_t nblocks = outlen / SHAKE256_RATE; + uint8_t t[SHAKE256_RATE]; + shake256ctx s; + + shake256_absorb(&s, input, inlen); + shake256_squeezeblocks(output, nblocks, &s); + + output += nblocks * SHAKE256_RATE; + outlen -= nblocks * SHAKE256_RATE; + + if (outlen) { + shake256_squeezeblocks(t, 1, &s); + for (size_t i = 0; i < outlen; ++i) { + output[i] = t[i]; + } + } + shake256_ctx_release(&s); +} + +void sha3_256_inc_init(sha3_256incctx *state) { + state->ctx = malloc(PQC_SHAKEINCCTX_BYTES); + if (state->ctx == NULL) { + exit(111); + } + keccak_inc_init(state->ctx); +} + +void sha3_256_inc_ctx_clone(sha3_256incctx *dest, const sha3_256incctx *src) { + dest->ctx = malloc(PQC_SHAKEINCCTX_BYTES); + if (dest->ctx == NULL) { + exit(111); + } + memcpy(dest->ctx, src->ctx, PQC_SHAKEINCCTX_BYTES); +} + +void sha3_256_inc_ctx_release(sha3_256incctx *state) { + free(state->ctx); +} + +void sha3_256_inc_absorb(sha3_256incctx *state, const uint8_t *input, size_t inlen) { + keccak_inc_absorb(state->ctx, SHA3_256_RATE, input, inlen); +} + +void sha3_256_inc_finalize(uint8_t *output, sha3_256incctx *state) { + uint8_t t[SHA3_256_RATE]; + keccak_inc_finalize(state->ctx, SHA3_256_RATE, 0x06); + + keccak_squeezeblocks(t, 1, state->ctx, SHA3_256_RATE); + + sha3_256_inc_ctx_release(state); + + for (size_t i = 0; i < 32; i++) { + output[i] = t[i]; + } +} + +/************************************************* + * Name: sha3_256 + * + * Description: SHA3-256 with non-incremental API + * + * Arguments: - uint8_t *output: pointer to output + * - const uint8_t *input: pointer to input + * - size_t inlen: length of input in bytes + **************************************************/ +void sha3_256(uint8_t *output, const uint8_t *input, size_t inlen) { + uint64_t s[25]; + uint8_t t[SHA3_256_RATE]; + + /* Absorb input */ + keccak_absorb(s, SHA3_256_RATE, input, inlen, 0x06); + + /* Squeeze output */ + keccak_squeezeblocks(t, 1, s, SHA3_256_RATE); + + for (size_t i = 0; i < 32; i++) { + output[i] = t[i]; + } +} + +void sha3_384_inc_init(sha3_384incctx *state) { + state->ctx = malloc(PQC_SHAKEINCCTX_BYTES); + if (state->ctx == NULL) { + exit(111); + } + keccak_inc_init(state->ctx); +} + +void sha3_384_inc_ctx_clone(sha3_384incctx *dest, const sha3_384incctx *src) { + dest->ctx = malloc(PQC_SHAKEINCCTX_BYTES); + if (dest->ctx == NULL) { + exit(111); + } + memcpy(dest->ctx, src->ctx, PQC_SHAKEINCCTX_BYTES); +} + +void sha3_384_inc_absorb(sha3_384incctx *state, const uint8_t *input, size_t inlen) { + keccak_inc_absorb(state->ctx, SHA3_384_RATE, input, inlen); +} + +void sha3_384_inc_ctx_release(sha3_384incctx *state) { + free(state->ctx); +} + +void sha3_384_inc_finalize(uint8_t *output, sha3_384incctx *state) { + uint8_t t[SHA3_384_RATE]; + keccak_inc_finalize(state->ctx, SHA3_384_RATE, 0x06); + + keccak_squeezeblocks(t, 1, state->ctx, SHA3_384_RATE); + + sha3_384_inc_ctx_release(state); + + for (size_t i = 0; i < 48; i++) { + output[i] = t[i]; + } +} + +/************************************************* + * Name: sha3_384 + * + * Description: SHA3-256 with non-incremental API + * + * Arguments: - uint8_t *output: pointer to output + * - const uint8_t *input: pointer to input + * - size_t inlen: length of input in bytes + **************************************************/ +void sha3_384(uint8_t *output, const uint8_t *input, size_t inlen) { + uint64_t s[25]; + uint8_t t[SHA3_384_RATE]; + + /* Absorb input */ + keccak_absorb(s, SHA3_384_RATE, input, inlen, 0x06); + + /* Squeeze output */ + keccak_squeezeblocks(t, 1, s, SHA3_384_RATE); + + for (size_t i = 0; i < 48; i++) { + output[i] = t[i]; + } +} + +void sha3_512_inc_init(sha3_512incctx *state) { + state->ctx = malloc(PQC_SHAKEINCCTX_BYTES); + if (state->ctx == NULL) { + exit(111); + } + keccak_inc_init(state->ctx); +} + +void sha3_512_inc_ctx_clone(sha3_512incctx *dest, const sha3_512incctx *src) { + dest->ctx = malloc(PQC_SHAKEINCCTX_BYTES); + if (dest->ctx == NULL) { + exit(111); + } + memcpy(dest->ctx, src->ctx, PQC_SHAKEINCCTX_BYTES); +} + +void sha3_512_inc_absorb(sha3_512incctx *state, const uint8_t *input, size_t inlen) { + keccak_inc_absorb(state->ctx, SHA3_512_RATE, input, inlen); +} + +void sha3_512_inc_ctx_release(sha3_512incctx *state) { + free(state->ctx); +} + +void sha3_512_inc_finalize(uint8_t *output, sha3_512incctx *state) { + uint8_t t[SHA3_512_RATE]; + keccak_inc_finalize(state->ctx, SHA3_512_RATE, 0x06); + + keccak_squeezeblocks(t, 1, state->ctx, SHA3_512_RATE); + + sha3_512_inc_ctx_release(state); + + for (size_t i = 0; i < 64; i++) { + output[i] = t[i]; + } +} + +/************************************************* + * Name: sha3_512 + * + * Description: SHA3-512 with non-incremental API + * + * Arguments: - uint8_t *output: pointer to output + * - const uint8_t *input: pointer to input + * - size_t inlen: length of input in bytes + **************************************************/ +void sha3_512(uint8_t *output, const uint8_t *input, size_t inlen) { + uint64_t s[25]; + uint8_t t[SHA3_512_RATE]; + + /* Absorb input */ + keccak_absorb(s, SHA3_512_RATE, input, inlen, 0x06); + + /* Squeeze output */ + keccak_squeezeblocks(t, 1, s, SHA3_512_RATE); + + for (size_t i = 0; i < 64; i++) { + output[i] = t[i]; + } +} + diff --git a/lib/mayo/fips202.h b/lib/mayo/fips202.h new file mode 100644 index 000000000..ed39e1270 --- /dev/null +++ b/lib/mayo/fips202.h @@ -0,0 +1,12 @@ +// SPDX-License-Identifier: Apache-2.0 + +#ifndef FIPS202_H +#define FIPS202_H + +#include + +int shake128(unsigned char *output, size_t outputByteLen, const unsigned char *input, size_t inputByteLen); +int shake256(unsigned char *output, size_t outputByteLen, const unsigned char *input, size_t inputByteLen); + +#endif + diff --git a/lib/mayo/generic_arithmetic.h b/lib/mayo/generic_arithmetic.h new file mode 100644 index 000000000..ab6219c99 --- /dev/null +++ b/lib/mayo/generic_arithmetic.h @@ -0,0 +1,294 @@ +// SPDX-License-Identifier: Apache-2.0 + +#ifndef GENERIC_ARITHMETIC_H +#define GENERIC_ARITHMETIC_H + +#include + +#ifdef ENABLE_PARAMS_DYNAMIC +#include +#else +#include +#endif + +// multiplies m (possibly upper triangular) matrices with a single matrix and adds result to acc +static inline +void mul_add_m_upper_triangular_mat_x_mat(const int m_vec_limbs, const uint64_t *bs_mat, const unsigned char *mat, uint64_t *acc, + const int bs_mat_rows, const int bs_mat_cols, const int mat_cols, const int triangular) { + + int bs_mat_entries_used = 0; + for (int r = 0; r < bs_mat_rows; r++) { + for (int c = triangular * r; c < bs_mat_cols; c++) { + for (int k = 0; k < mat_cols; k += 1) { + m_vec_mul_add(m_vec_limbs, bs_mat + m_vec_limbs * bs_mat_entries_used, mat[c * mat_cols + k], acc + m_vec_limbs * (r * mat_cols + k)); + } + bs_mat_entries_used += 1; + } + } +} + +// multiplies m (possibly upper triangular) matrices with the transpose of a single matrix and adds result to acc +static inline +void mul_add_m_upper_triangular_mat_x_mat_trans(const int m_vec_limbs, const uint64_t *bs_mat, const unsigned char *mat, uint64_t *acc, + const int bs_mat_rows, const int bs_mat_cols, const int mat_rows, const int triangular) { + int bs_mat_entries_used = 0; + for (int r = 0; r < bs_mat_rows; r++) { + for (int c = triangular * r; c < bs_mat_cols; c++) { + for (int k = 0; k < mat_rows; k += 1) { + m_vec_mul_add(m_vec_limbs, bs_mat + m_vec_limbs * bs_mat_entries_used, mat[k * bs_mat_cols + c], acc + m_vec_limbs * (r * mat_rows + k)); + } + bs_mat_entries_used += 1; + } + } +} + +// multiplies the transpose of a single matrix with m matrices and adds result to acc +static inline +void mul_add_mat_trans_x_m_mat(const int m_vec_limbs, const unsigned char *mat, const uint64_t *bs_mat, uint64_t *acc, + const int mat_rows, const int mat_cols, const int bs_mat_cols) { + + for (int r = 0; r < mat_cols; r++) { + for (int c = 0; c < mat_rows; c++) { + for (int k = 0; k < bs_mat_cols; k += 1) { + m_vec_mul_add(m_vec_limbs, bs_mat + m_vec_limbs * (c * bs_mat_cols + k), mat[c * mat_cols + r], acc + m_vec_limbs * (r * bs_mat_cols + k)); + } + } + } +} + +// multiplies a single matrix with m matrices and adds result to acc +static inline +void mul_add_mat_x_m_mat(const int m_vec_limbs, const unsigned char *mat, const uint64_t *bs_mat, uint64_t *acc, + const int mat_rows, const int mat_cols, const int bs_mat_cols) { + + for (int r = 0; r < mat_rows; r++) { + for (int c = 0; c < mat_cols; c++) { + for (int k = 0; k < bs_mat_cols; k += 1) { + m_vec_mul_add(m_vec_limbs, bs_mat + m_vec_limbs * (c * bs_mat_cols + k), mat[r * mat_cols + c], acc + m_vec_limbs * (r * bs_mat_cols + k)); + } + } + } +} + +static inline +void P1_times_O(const mayo_params_t* p, const uint64_t* P1, const unsigned char* O, uint64_t* acc){ + #ifndef ENABLE_PARAMS_DYNAMIC + (void) p; + #endif + mul_add_m_upper_triangular_mat_x_mat(PARAM_m_vec_limbs(p), P1, O, acc, PARAM_v(p), PARAM_v(p), PARAM_o(p), 1); +} + +static inline +void P1_times_Vt(const mayo_params_t* p, const uint64_t* P1, const unsigned char* V, uint64_t* acc){ + #ifndef ENABLE_PARAMS_DYNAMIC + (void) p; + #endif + mul_add_m_upper_triangular_mat_x_mat_trans(PARAM_m_vec_limbs(p), P1, V, acc, PARAM_v(p), PARAM_v(p), PARAM_k(p), 1); +} + +#if defined(HAVE_STACKEFFICIENT) || defined(PQM4) +// compute P * S^t = [ P1 P2 ] * [S1] = [P1*S1 + P2*S2] +// [ 0 P3 ] [S2] [ P3*S2] +// compute S * PS = [ S1 S2 ] * [ P1*S1 + P2*S2 = P1 ] = [ S1*P1 + S2*P2 ] +// [ P3*S2 = P2 ] +static inline void mayo_generic_m_calculate_PS_SPS(const uint64_t *P1, const uint64_t *P2, const uint64_t *P3, const unsigned char *S, + const int m, const int v, const int o, const int k, uint64_t *SPS) { + + const int n = o + v; + const int m_vec_limbs = (m + 15)/16; + + uint64_t PS[(N_MAX + K_MAX) * M_VEC_LIMBS_MAX] = { 0 }; + uint64_t accumulator[16 * ((M_MAX+15)/16) * N_MAX] = {0}; + int P1_used; + int P3_used; + + for (int col = 0; col < k; col++) { + for(unsigned int i = 0; i < sizeof(accumulator)/8; i++) { + accumulator[i] = 0; + } + P1_used = 0; + for (int row = 0; row < v; row++) { + for (int j = row; j < v; j++) { + m_vec_add(m_vec_limbs, P1 + (P1_used * m_vec_limbs), accumulator + ( row * 16 + S[col * n + j] )*m_vec_limbs); + + P1_used ++; + } + + for (int j = 0; j < o; j++) { + m_vec_add(m_vec_limbs, P2 + (row * o + j)*m_vec_limbs, accumulator + ( row * 16 + S[(col * n) + j + v] )* m_vec_limbs); + } + } + + P3_used = 0; + for (int row = v; row < n; row++) { + for (int j = row; j < n; j++) { + m_vec_add(m_vec_limbs, P3 + P3_used * m_vec_limbs, accumulator + ( row * 16 + S[col * n + j] )* m_vec_limbs ); + P3_used ++; + } + } + + for (int row = 0; row < n; row++) { + m_vec_multiply_bins(m_vec_limbs, accumulator + row * 16 * m_vec_limbs, PS + (row + col) * m_vec_limbs); + } + + for (int row = 0; row < k; row++) { + for (unsigned int i = 0; i < 16*((M_MAX+15)/16); ++i) + accumulator[i] = 0; + for (int j = 0; j < n; j++) { + m_vec_add(m_vec_limbs, PS + (j + col) * m_vec_limbs, accumulator + S[row * n + j]*m_vec_limbs); + } + m_vec_multiply_bins(m_vec_limbs, accumulator, SPS + (row * k + col) * m_vec_limbs); + } + + } + +} + +#else + +// compute P * S^t = [ P1 P2 ] * [S1] = [P1*S1 + P2*S2] +// [ 0 P3 ] [S2] [ P3*S2] +static inline void mayo_generic_m_calculate_PS(const uint64_t *P1, const uint64_t *P2, const uint64_t *P3, const unsigned char *S, + const int m, const int v, const int o, const int k, uint64_t *PS) { + + const int n = o + v; + const int m_vec_limbs = (m + 15)/16; + + uint64_t accumulator[16 * ((M_MAX+15)/16) * K_MAX * N_MAX] = {0}; + int P1_used = 0; + for (int row = 0; row < v; row++) { + for (int j = row; j < v; j++) { + for (int col = 0; col < k; col++) { + m_vec_add(m_vec_limbs, P1 + (P1_used * m_vec_limbs), accumulator + ( (row * k + col) * 16 + S[col * n + j] )*m_vec_limbs); + } + P1_used ++; + } + + for (int j = 0; j < o; j++) { + for (int col = 0; col < k; col++) { + m_vec_add(m_vec_limbs, P2 + (row * o + j)*m_vec_limbs, accumulator + ( (row * k + col) * 16 + S[(col * n) + j + v] )* m_vec_limbs); + } + } + } + + int P3_used = 0; + for (int row = v; row < n; row++) { + for (int j = row; j < n; j++) { + for (int col = 0; col < k; col++) { + m_vec_add(m_vec_limbs, P3 + P3_used * m_vec_limbs, accumulator + ( (row * k + col) * 16 + S[col * n + j] )* m_vec_limbs ); + } + P3_used ++; + } + } + + // multiply stuff according to the bins of the accumulator and add to PS. + int i = 0; + while (i < n * k) { + m_vec_multiply_bins(m_vec_limbs, accumulator + i * 16 * m_vec_limbs, PS + i * m_vec_limbs); + i++; + } + +} + +// compute S * PS = [ S1 S2 ] * [ P1*S1 + P2*S2 = P1 ] = [ S1*P1 + S2*P2 ] +// [ P3*S2 = P2 ] +static inline void mayo_generic_m_calculate_SPS(const uint64_t *PS, const unsigned char *S, int m, int k, int n, uint64_t *SPS){ + uint64_t accumulator[16*((M_MAX+15)/16)*K_MAX*K_MAX] = {0}; + const int m_vec_limbs = (m + 15)/ 16; + for (int row = 0; row < k; row++) { + for (int j = 0; j < n; j++) { + for (int col = 0; col < k; col += 1) { + m_vec_add(m_vec_limbs, PS + (j * k + col) * m_vec_limbs, accumulator + ( (row * k + col) * 16 + S[row * n + j] )*m_vec_limbs); + } + } + } + + // multiply stuff according to the bins of the accumulator and add to PS. + int i = 0; + while (i < k*k) { + m_vec_multiply_bins(m_vec_limbs, accumulator + i * 16 * m_vec_limbs, SPS + i * m_vec_limbs); + i++; + } +} + +#endif + + +static inline +void P1P1t_times_O(const mayo_params_t* p, const uint64_t* P1, const unsigned char* O, uint64_t* acc){ + #ifndef ENABLE_PARAMS_DYNAMIC + (void) p; + #endif + const int param_o = PARAM_o(p); + const int param_v = PARAM_v(p); + const int m_vec_limbs = PARAM_m_vec_limbs(p); + + int bs_mat_entries_used = 0; + for (int r = 0; r < param_v; r++) { + for (int c = r; c < param_v; c++) { + if(c==r) { + bs_mat_entries_used += 1; + continue; + } + for (int k = 0; k < param_o; k += 1) { + m_vec_mul_add(m_vec_limbs, P1 + m_vec_limbs * bs_mat_entries_used, O[c * param_o + k], acc + m_vec_limbs * (r * param_o + k)); + m_vec_mul_add(m_vec_limbs, P1 + m_vec_limbs * bs_mat_entries_used, O[r * param_o + k], acc + m_vec_limbs * (c * param_o + k)); + } + bs_mat_entries_used += 1; + } + } +} + + +static inline +void compute_M_and_VPV(const mayo_params_t* p, const unsigned char* Vdec, const uint64_t *L, const uint64_t *P1, uint64_t *VL, uint64_t *VP1V){ + + const int param_k = PARAM_k(p); + const int param_v = PARAM_v(p); + const int param_o = PARAM_o(p); + + //VL + mul_add_mat_x_m_mat(PARAM_m_vec_limbs(p), Vdec, L, VL, param_k, param_v, param_o); + + //VP1V + uint64_t Pv[V_MAX * K_MAX * M_VEC_LIMBS_MAX] = {0}; + P1_times_Vt(p, P1, Vdec, Pv); + mul_add_mat_x_m_mat(PARAM_m_vec_limbs(p), Vdec, Pv, VP1V, param_k, param_v, param_k); +} + +static inline +void compute_P3(const mayo_params_t* p, const uint64_t* P1, uint64_t *P2, const unsigned char *O, uint64_t *P3){ + + const int m_vec_limbs = PARAM_m_vec_limbs(p); + const int param_v = PARAM_v(p); + const int param_o = PARAM_o(p); + + // compute P1*O + P2 + P1_times_O(p, P1, O, P2); + + // compute P3 = O^t * (P1*O + P2) + mul_add_mat_trans_x_m_mat(m_vec_limbs, O, P2, P3, param_v, param_o, param_o); +} + +// compute P * S^t = [ P1 P2 ] * [S1] = [P1*S1 + P2*S2] +// [ 0 P3 ] [S2] [ P3*S2] +// compute S * PS = [ S1 S2 ] * [ P1*S1 + P2*S2 = P1 ] = [ S1*P1 + S2*P2 ] +// [ P3*S2 = P2 ] +static inline void m_calculate_PS_SPS(const mayo_params_t *p, const uint64_t *P1, const uint64_t *P2, const uint64_t *P3, const unsigned char *s, + uint64_t *SPS) { + // compute P * S^t = {(P1, P2), (0, P3)} * S^t = {(P1*S1 + P2*S2), (P3 * S2)} + #ifndef ENABLE_PARAMS_DYNAMIC + (void) p; + #endif + #if defined(HAVE_STACKEFFICIENT) || defined(PQM4) + mayo_generic_m_calculate_PS_SPS(P1, P2, P3, s, PARAM_m(p), PARAM_v(p), PARAM_o(p), PARAM_k(p), SPS); + #else + uint64_t PS[N_MAX * K_MAX * M_VEC_LIMBS_MAX] = { 0 }; + mayo_generic_m_calculate_PS(P1, P2, P3, s, PARAM_m(p), PARAM_v(p), PARAM_o(p), PARAM_k(p), PS); + + // compute S * P * S = S* (P*S) + mayo_generic_m_calculate_SPS(PS, s, PARAM_m(p), PARAM_k(p), PARAM_n(p), SPS); + #endif +} + +#endif diff --git a/lib/mayo/mayo.c b/lib/mayo/mayo.c new file mode 100644 index 000000000..e3c8f2f3a --- /dev/null +++ b/lib/mayo/mayo.c @@ -0,0 +1,675 @@ +// SPDX-License-Identifier: Apache-2.0 + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#ifdef ENABLE_CT_TESTING +#include +#endif + +#define MAYO_MIN(x, y) (((x) < (y)) ? (x) : (y)) +#define PK_PRF AES_128_CTR + +static void decode(const unsigned char *m, unsigned char *mdec, int mdeclen) { + int i; + for (i = 0; i < mdeclen / 2; ++i) { + *mdec++ = m[i] & 0xf; + *mdec++ = m[i] >> 4; + } + + if (mdeclen % 2 == 1) { + *mdec++ = m[i] & 0x0f; + } +} + +static void encode(const unsigned char *m, unsigned char *menc, int mlen) { + int i; + for (i = 0; i < mlen / 2; ++i, m += 2) { + menc[i] = (*m) | (*(m + 1) << 4); + } + + if (mlen % 2 == 1) { + menc[i] = (*m); + } +} + +static void compute_rhs(const mayo_params_t *p, uint64_t *vPv, const unsigned char *t, unsigned char *y){ + #ifndef ENABLE_PARAMS_DYNAMIC + (void) p; + #endif + + const size_t top_pos = ((PARAM_m(p) - 1) % 16) * 4; + const size_t m_vec_limbs = PARAM_m_vec_limbs(p); + + // zero out tails of m_vecs if neccesary + if(PARAM_m(p) % 16 != 0){ + uint64_t mask = 1; + mask <<= ((PARAM_m(p) % 16)*4); + mask -= 1; + for (int i = 0; i < PARAM_k(p)*PARAM_k(p); i++) + { + vPv[i*m_vec_limbs + m_vec_limbs - 1] &= mask; + } + } + + uint64_t temp[M_VEC_LIMBS_MAX] = {0}; + unsigned char *temp_bytes = (unsigned char *) temp; + for (int i = PARAM_k(p) - 1; i >= 0 ; i--) { + for (int j = i; j < PARAM_k(p); j++) { + // multiply by X (shift up 4 bits) + unsigned char top = (temp[m_vec_limbs-1] >> top_pos) % 16; + temp[m_vec_limbs-1] <<= 4; + for(int k = m_vec_limbs - 2; k>=0; k--){ + temp[k+1] ^= temp[k] >> 60; + temp[k] <<= 4; + } + // reduce mod f(X) + for (int jj = 0; jj < F_TAIL_LEN; jj++) { + if(jj%2 == 0){ +#ifdef TARGET_BIG_ENDIAN + temp_bytes[(((jj/2 + 8) / 8) * 8) - 1 - (jj/2)%8] ^= mul_f(top, PARAM_f_tail(p)[jj]); +#else + temp_bytes[jj/2] ^= mul_f(top, PARAM_f_tail(p)[jj]); +#endif + } + else { +#ifdef TARGET_BIG_ENDIAN + temp_bytes[(((jj/2 + 8) / 8) * 8) - 1 - (jj/2)%8] ^= mul_f(top, PARAM_f_tail(p)[jj]) << 4; +#else + temp_bytes[jj/2] ^= mul_f(top, PARAM_f_tail(p)[jj]) << 4; +#endif + } + } + + // extract from vPv and add + for(size_t k=0; k < m_vec_limbs; k ++){ + temp[k] ^= vPv[( i * PARAM_k(p) + j )* m_vec_limbs + k] ^ ((i!=j)*vPv[( j * PARAM_k(p) + i )* m_vec_limbs + k]); + } + } + } + + // compute y + for (int i = 0; i < PARAM_m(p); i+=2) + { +#ifdef TARGET_BIG_ENDIAN + y[i] = t[i] ^ (temp_bytes[(((i/2 + 8) / 8) * 8) - 1 - (i/2)%8] & 0xF); + y[i+1] = t[i+1] ^ (temp_bytes[(((i/2 + 8) / 8) * 8) - 1 - (i/2)%8] >> 4); +#else + y[i] = t[i] ^ (temp_bytes[i/2] & 0xF); + y[i+1] = t[i+1] ^ (temp_bytes[i/2] >> 4); +#endif + } +} + +static void transpose_16x16_nibbles(uint64_t *M){ + static const uint64_t even_nibbles = 0x0f0f0f0f0f0f0f0f; + static const uint64_t even_bytes = 0x00ff00ff00ff00ff; + static const uint64_t even_2bytes = 0x0000ffff0000ffff; + static const uint64_t even_half = 0x00000000ffffffff; + + for (size_t i = 0; i < 16; i+=2) + { + uint64_t t = ((M[i] >> 4 ) ^ M[i+1]) & even_nibbles; + M[i ] ^= t << 4; + M[i+1] ^= t; + } + + for (size_t i = 0; i < 16; i+=4) + { + uint64_t t0 = ((M[i ] >> 8) ^ M[i+2]) & even_bytes; + uint64_t t1 = ((M[i+1] >> 8) ^ M[i+3]) & even_bytes; + M[i ] ^= (t0 << 8); + M[i+1] ^= (t1 << 8); + M[i+2] ^= t0; + M[i+3] ^= t1; + } + + for (size_t i = 0; i < 4; i++) + { + uint64_t t0 = ((M[i ] >> 16) ^ M[i+ 4]) & even_2bytes; + uint64_t t1 = ((M[i+8] >> 16) ^ M[i+12]) & even_2bytes; + + M[i ] ^= t0 << 16; + M[i+ 8] ^= t1 << 16; + M[i+ 4] ^= t0; + M[i+12] ^= t1; + } + + for (size_t i = 0; i < 8; i++) + { + uint64_t t = ((M[i]>>32) ^ M[i+8]) & even_half; + M[i ] ^= t << 32; + M[i+8] ^= t; + } +} + +#define MAYO_M_OVER_8 ((M_MAX + 7) / 8) +static void compute_A(const mayo_params_t *p, uint64_t *VtL, unsigned char *A_out) { + #ifndef ENABLE_PARAMS_DYNAMIC + (void) p; + #endif + + int bits_to_shift = 0; + int words_to_shift = 0; + const int m_vec_limbs = PARAM_m_vec_limbs(p); + uint64_t A[(((O_MAX*K_MAX+15)/16)*16)*MAYO_M_OVER_8] = {0}; + size_t A_width = ((PARAM_o(p)*PARAM_k(p) + 15)/16)*16; + const uint64_t *Mi, *Mj; + + // zero out tails of m_vecs if neccesary + if(PARAM_m(p) % 16 != 0){ + uint64_t mask = 1; + mask <<= (PARAM_m(p) % 16)*4; + mask -= 1; + for (int i = 0; i < PARAM_o(p)*PARAM_k(p); i++) + { + VtL[i*m_vec_limbs + m_vec_limbs - 1] &= mask; + } + } + + for (int i = 0; i <= PARAM_k(p) - 1; ++i) { + for (int j = PARAM_k(p) - 1; j >= i; --j) { + // add the M_i and M_j to A, shifted "down" by l positions + Mj = VtL + j * m_vec_limbs * PARAM_o(p); + for (int c = 0; c < PARAM_o(p); c++) { + for (int k = 0; k < m_vec_limbs; k++) + { + A[ PARAM_o(p) * i + c + (k + words_to_shift)*A_width] ^= Mj[k + c*m_vec_limbs] << bits_to_shift; + if(bits_to_shift > 0){ + A[ PARAM_o(p) * i + c + (k + words_to_shift + 1)*A_width] ^= Mj[k + c*m_vec_limbs] >> (64-bits_to_shift); + } + } + } + + if (i != j) { + Mi = VtL + i * m_vec_limbs * PARAM_o(p); + for (int c = 0; c < PARAM_o(p); c++) { + for (int k = 0; k < m_vec_limbs; k++) + { + A[PARAM_o(p) * j + c + (k + words_to_shift)*A_width] ^= Mi[k + c*m_vec_limbs] << bits_to_shift; + if(bits_to_shift > 0){ + A[PARAM_o(p) * j + c + (k + words_to_shift + 1)*A_width] ^= Mi[k + c*m_vec_limbs] >> (64-bits_to_shift); + } + } + } + } + + bits_to_shift += 4; + if(bits_to_shift == 64){ + words_to_shift ++; + bits_to_shift = 0; + } + } + } + + for (size_t c = 0; c < A_width*((PARAM_m(p) + (PARAM_k(p)+1)*PARAM_k(p)/2 +15)/16) ; c+= 16) + { + transpose_16x16_nibbles(A + c); + } + + unsigned char tab[F_TAIL_LEN*4] = {0}; + for (size_t i = 0; i < F_TAIL_LEN; i++) + { + tab[4*i] = mul_f(PARAM_f_tail(p)[i],1); + tab[4*i+1] = mul_f(PARAM_f_tail(p)[i],2); + tab[4*i+2] = mul_f(PARAM_f_tail(p)[i],4); + tab[4*i+3] = mul_f(PARAM_f_tail(p)[i],8); + } + + uint64_t low_bit_in_nibble = 0x1111111111111111; + + for (size_t c = 0; c < A_width; c+= 16) + { + for (int r = PARAM_m(p); r < PARAM_m(p) + (PARAM_k(p)+1)*PARAM_k(p)/2 ; r++) + { + size_t pos = (r/16)*A_width + c + (r%16); + uint64_t t0 = A[pos] & low_bit_in_nibble; + uint64_t t1 = (A[pos] >> 1) & low_bit_in_nibble; + uint64_t t2 = (A[pos] >> 2) & low_bit_in_nibble; + uint64_t t3 = (A[pos] >> 3) & low_bit_in_nibble; + for (size_t t = 0; t < F_TAIL_LEN; t++) + { + A[((r+t-PARAM_m(p))/16)*A_width + c + ((r+t-PARAM_m(p))%16)] ^= t0*tab[4*t+0] ^ t1*tab[4*t+1] ^ t2*tab[4*t+2] ^ t3*tab[4*t+3]; + } + } + } + +#ifdef TARGET_BIG_ENDIAN + for (int i = 0; i < (((PARAM_o(p)*PARAM_k(p)+15)/16)*16)*MAYO_M_OVER_8; ++i) + A[i] = BSWAP64(A[i]); +#endif + + + for (int r = 0; r < PARAM_m(p); r+=16) + { + for (int c = 0; c < PARAM_A_cols(p)-1 ; c+=16) + { + for (int i = 0; i + r < PARAM_m(p); i++) + { + decode( (unsigned char *) &A[r*A_width/16 + c + i], A_out + PARAM_A_cols(p)*(r+i) + c, MAYO_MIN(16, PARAM_A_cols(p)-1-c)); + } + } + } +} + +static void unpack_m_vecs(const unsigned char *in, uint64_t *out, int vecs, int m){ + const int m_vec_limbs = (m + 15) / 16; + unsigned char *_out = (unsigned char *) out; + uint64_t tmp[ (M_MAX + 15) / 16] = {0}; + for (int i = vecs-1; i >= 0; i--) + { + memcpy(tmp, in + i*m/2, m/2); + memcpy(_out + i*m_vec_limbs*sizeof(uint64_t), tmp, m_vec_limbs*sizeof(uint64_t)); + } +} +static void pack_m_vecs(const uint64_t *in, unsigned char *out, int vecs, int m){ + const int m_vec_limbs = (m + 15) / 16; + unsigned char *_in = (unsigned char *) in; + for (int i = 0; i < vecs; i++) + { + memmove(out + (i*m/2), _in + i*m_vec_limbs*sizeof(uint64_t), m/2); + } +} +static void expand_P1_P2(const mayo_params_t *p, uint64_t *P, const unsigned char *seed_pk) { + #ifndef ENABLE_PARAMS_DYNAMIC + (void) p; + #endif + PK_PRF((unsigned char *)P, PARAM_P1_bytes(p) + PARAM_P2_bytes(p), seed_pk, PARAM_pk_seed_bytes(p)); + unpack_m_vecs((unsigned char *)P, P, (PARAM_P1_limbs(p) + PARAM_P2_limbs(p))/PARAM_m_vec_limbs(p), PARAM_m(p)); +} + +static void eval_public_map(const mayo_params_t *p, const unsigned char *s, const uint64_t *P1, const uint64_t *P2, const uint64_t *P3, unsigned char *eval){ + uint64_t SPS[K_MAX * K_MAX * M_VEC_LIMBS_MAX] = {0}; + // combine computing PS and SPS in a single step + m_calculate_PS_SPS(p, P1, P2, P3, s, SPS); + unsigned char zero[M_MAX] = {0}; + compute_rhs(p, SPS, zero, eval); +} + +// Public API + +int mayo_keypair(const mayo_params_t *p, unsigned char *pk, unsigned char *sk) { + int ret = 0; + + ret = mayo_keypair_compact(p, pk, sk); + if (ret != MAYO_OK) { + goto err; + } + +err: + return ret; +} + +int mayo_expand_sk(const mayo_params_t *p, const unsigned char *csk, + sk_t *sk) { + int ret = MAYO_OK; + unsigned char S[PK_SEED_BYTES_MAX + O_BYTES_MAX]; + uint64_t *P = sk->p; + unsigned char *O = sk->O; + + const int param_o = PARAM_o(p); + const int param_v = PARAM_v(p); + const int param_O_bytes = PARAM_O_bytes(p); + const int param_pk_seed_bytes = PARAM_pk_seed_bytes(p); + const int param_sk_seed_bytes = PARAM_sk_seed_bytes(p); + + const unsigned char *seed_sk = csk; + unsigned char *seed_pk = S; + + shake256(S, param_pk_seed_bytes + param_O_bytes, seed_sk, + param_sk_seed_bytes); + decode(S + param_pk_seed_bytes, O, param_v * param_o); + +#ifdef ENABLE_CT_TESTING + VALGRIND_MAKE_MEM_DEFINED(seed_pk, param_pk_seed_bytes); +#endif + + expand_P1_P2(p, P, seed_pk); +#ifdef TARGET_BIG_ENDIAN + for (int i = 0; i < PARAM_P1_limbs(p) + PARAM_P2_limbs(p); ++i) { + P[i] = BSWAP64(P[i]); + } +#endif + + uint64_t *P2 = P + PARAM_P1_limbs(p); + + uint64_t *P1 = P; + + // compute L_i = (P1 + P1^t)*O + P2 + uint64_t *L = P2; + P1P1t_times_O(p, P1, O, L); + +#ifdef TARGET_BIG_ENDIAN + for (int i = 0; i < PARAM_P1_limbs(p) + PARAM_P2_limbs(p); ++i) { + P[i] = BSWAP64(P[i]); + } +#endif + + mayo_secure_clear(S, PK_SEED_BYTES_MAX + O_BYTES_MAX); + return ret; +} + +int mayo_sign_signature(const mayo_params_t *p, unsigned char *sig, + size_t *siglen, const unsigned char *m, + size_t mlen, const unsigned char *csk) { + int ret = MAYO_OK; + unsigned char tenc[M_BYTES_MAX], t[M_MAX]; // no secret data + unsigned char y[M_MAX]; // secret data + unsigned char salt[SALT_BYTES_MAX]; // not secret data + unsigned char V[K_MAX * V_BYTES_MAX + R_BYTES_MAX], Vdec[V_MAX * K_MAX]; // secret data + unsigned char A[((M_MAX+7)/8*8) * (K_MAX * O_MAX + 1)] = { 0 }; // secret data + unsigned char x[K_MAX * N_MAX]; // not secret data + unsigned char r[K_MAX * O_MAX + 1] = { 0 }; // secret data + unsigned char s[K_MAX * N_MAX]; // not secret data + const unsigned char *seed_sk; + alignas(32) sk_t sk; // secret data + unsigned char Ox[V_MAX]; // secret data + unsigned char tmp[DIGEST_BYTES_MAX + SALT_BYTES_MAX + SK_SEED_BYTES_MAX + 1]; + unsigned char *ctrbyte; + unsigned char *vi; + + const int param_m = PARAM_m(p); + const int param_n = PARAM_n(p); + const int param_o = PARAM_o(p); + const int param_k = PARAM_k(p); + const int param_v = PARAM_v(p); + const int param_m_bytes = PARAM_m_bytes(p); + const int param_v_bytes = PARAM_v_bytes(p); + const int param_r_bytes = PARAM_r_bytes(p); + const int param_sig_bytes = PARAM_sig_bytes(p); + const int param_A_cols = PARAM_A_cols(p); + const int param_digest_bytes = PARAM_digest_bytes(p); + const int param_sk_seed_bytes = PARAM_sk_seed_bytes(p); + const int param_salt_bytes = PARAM_salt_bytes(p); + + ret = mayo_expand_sk(p, csk, &sk); + if (ret != MAYO_OK) { + goto err; + } + + seed_sk = csk; + + + // hash message + shake256(tmp, param_digest_bytes, m, mlen); + + uint64_t *P1 = sk.p; + uint64_t *L = P1 + PARAM_P1_limbs(p); + uint64_t Mtmp[K_MAX * O_MAX * M_VEC_LIMBS_MAX] = {0}; + +#ifdef TARGET_BIG_ENDIAN + for (int i = 0; i < PARAM_P1_limbs(p); ++i) { + P1[i] = BSWAP64(P1[i]); + } + for (int i = 0; i < PARAM_P2_limbs(p); ++i) { + L[i] = BSWAP64(L[i]); + } +#endif + + // choose the randomizer + #if defined(PQM4) || defined(HAVE_RANDOMBYTES_NORETVAL) + randombytes(tmp + param_digest_bytes, param_salt_bytes); + #else + if (randombytes(tmp + param_digest_bytes, param_salt_bytes) != MAYO_OK) { + ret = MAYO_ERR; + goto err; + } + #endif + + // hashing to salt + memcpy(tmp + param_digest_bytes + param_salt_bytes, seed_sk, + param_sk_seed_bytes); + shake256(salt, param_salt_bytes, tmp, + param_digest_bytes + param_salt_bytes + param_sk_seed_bytes); + +#ifdef ENABLE_CT_TESTING + VALGRIND_MAKE_MEM_DEFINED(salt, SALT_BYTES_MAX); // Salt is not secret +#endif + + // hashing to t + memcpy(tmp + param_digest_bytes, salt, param_salt_bytes); + ctrbyte = tmp + param_digest_bytes + param_salt_bytes + param_sk_seed_bytes; + + shake256(tenc, param_m_bytes, tmp, param_digest_bytes + param_salt_bytes); + + decode(tenc, t, param_m); // may not be necessary + + for (int ctr = 0; ctr <= 255; ++ctr) { + *ctrbyte = (unsigned char)ctr; + + shake256(V, param_k * param_v_bytes + param_r_bytes, tmp, + param_digest_bytes + param_salt_bytes + param_sk_seed_bytes + 1); + + // decode the v_i vectors + for (int i = 0; i <= param_k - 1; ++i) { + decode(V + i * param_v_bytes, Vdec + i * param_v, param_v); + } + + // compute M_i matrices and all v_i*P1*v_j + compute_M_and_VPV(p, Vdec, L, P1, Mtmp, (uint64_t*) A); + + compute_rhs(p, (uint64_t*) A, t, y); + compute_A(p, Mtmp, A); + + for (int i = 0; i < param_m; i++) + { + A[(1+i)*(param_k*param_o + 1) - 1] = 0; + } + + decode(V + param_k * param_v_bytes, r, + param_k * + param_o); + + if (sample_solution(p, A, y, r, x, param_k, param_o, param_m, param_A_cols)) { + break; + } else { + memset(Mtmp, 0, sizeof(Mtmp)); + memset(A, 0, sizeof(A)); + } + } + + for (int i = 0; i <= param_k - 1; ++i) { + vi = Vdec + i * (param_n - param_o); + mat_mul(sk.O, x + i * param_o, Ox, param_o, param_n - param_o, 1); + mat_add(vi, Ox, s + i * param_n, param_n - param_o, 1); + memcpy(s + i * param_n + (param_n - param_o), x + i * param_o, param_o); + } + encode(s, sig, param_n * param_k); + + memcpy(sig + param_sig_bytes - param_salt_bytes, salt, param_salt_bytes); + *siglen = param_sig_bytes; + +err: + mayo_secure_clear(V, sizeof(V)); + mayo_secure_clear(Vdec, sizeof(Vdec)); + mayo_secure_clear(A, sizeof(A)); + mayo_secure_clear(r, sizeof(r)); + mayo_secure_clear(sk.O, sizeof(sk.O)); + mayo_secure_clear(&sk, sizeof(sk_t)); + mayo_secure_clear(Ox, sizeof(Ox)); + mayo_secure_clear(tmp, sizeof(tmp)); + mayo_secure_clear(Mtmp, sizeof(Mtmp)); + return ret; +} + +int mayo_sign(const mayo_params_t *p, unsigned char *sm, + size_t *smlen, const unsigned char *m, + size_t mlen, const unsigned char *csk) { + int ret = MAYO_OK; + const int param_sig_bytes = PARAM_sig_bytes(p); + size_t siglen; + memmove(sm + param_sig_bytes, m, mlen); + ret = mayo_sign_signature(p, sm, &siglen, sm + param_sig_bytes, mlen, csk); + if (ret != MAYO_OK || siglen != (size_t) param_sig_bytes){ + memset(sm, 0, siglen + mlen); + goto err; + } + + *smlen = siglen + mlen; +err: + return ret; +} + +int mayo_open(const mayo_params_t *p, unsigned char *m, + size_t *mlen, const unsigned char *sm, + size_t smlen, const unsigned char *pk) { + const int param_sig_bytes = PARAM_sig_bytes(p); + if (smlen < (size_t)param_sig_bytes) { + return MAYO_ERR; + } + int result = mayo_verify(p, sm + param_sig_bytes, smlen - param_sig_bytes, sm, + pk); + + if (result == MAYO_OK) { + *mlen = smlen - param_sig_bytes; + memmove(m, sm + param_sig_bytes, *mlen); + } + + return result; +} + +int mayo_keypair_compact(const mayo_params_t *p, unsigned char *cpk, + unsigned char *csk) { + int ret = MAYO_OK; + unsigned char *seed_sk = csk; + unsigned char S[PK_SEED_BYTES_MAX + O_BYTES_MAX]; + uint64_t P[P1_LIMBS_MAX + P2_LIMBS_MAX]; + uint64_t P3[O_MAX*O_MAX*M_VEC_LIMBS_MAX] = {0}; + + unsigned char *seed_pk; + unsigned char O[(V_MAX)*O_MAX]; + + const int m_vec_limbs = PARAM_m_vec_limbs(p); + const int param_m = PARAM_m(p); + const int param_v = PARAM_v(p); + const int param_o = PARAM_o(p); + const int param_O_bytes = PARAM_O_bytes(p); + const int param_P1_limbs = PARAM_P1_limbs(p); + const int param_P3_limbs = PARAM_P3_limbs(p); + const int param_pk_seed_bytes = PARAM_pk_seed_bytes(p); + const int param_sk_seed_bytes = PARAM_sk_seed_bytes(p); + + uint64_t *P1 = P; + uint64_t *P2 = P + param_P1_limbs; + + // seed_sk $←- B^(sk_seed bytes) + #if defined(PQM4) || defined(HAVE_RANDOMBYTES_NORETVAL) + randombytes(seed_sk, param_sk_seed_bytes); + #else + if (randombytes(seed_sk, param_sk_seed_bytes) != MAYO_OK) { + ret = MAYO_ERR; + goto err; + } + #endif + + // S ← shake256(seedsk, pk seed bytes + O bytes) + shake256(S, param_pk_seed_bytes + param_O_bytes, seed_sk, + param_sk_seed_bytes); + // seed_pk ← s[0 : pk_seed_bytes] + seed_pk = S; + + // o ← Decode_o(s[pk_seed_bytes : pk_seed_bytes + o_bytes]) + decode(S + param_pk_seed_bytes, O, param_v * param_o); + +#ifdef ENABLE_CT_TESTING + VALGRIND_MAKE_MEM_DEFINED(seed_pk, param_pk_seed_bytes); +#endif + + expand_P1_P2(p, P, seed_pk); + + // compute P3 (modifies P2 in the process) + compute_P3(p, P1, P2, O, P3); + + // store seed_pk in cpk + memcpy(cpk, seed_pk, param_pk_seed_bytes); + + uint64_t P3_upper[P3_LIMBS_MAX]; + + // compute Upper(P3) and store in cpk + m_upper(p, P3, P3_upper, param_o); + pack_m_vecs(P3_upper, cpk + param_pk_seed_bytes, param_P3_limbs/m_vec_limbs, param_m); + +#if !defined(PQM4) && !defined(HAVE_RANDOMBYTES_NORETVAL) + err: +#endif + mayo_secure_clear(O, sizeof(O)); + mayo_secure_clear(P2, PARAM_P2_limbs(p)*sizeof(uint64_t)); + mayo_secure_clear(P3, sizeof(P3)); + return ret; +} + +int mayo_expand_pk(const mayo_params_t *p, const unsigned char *cpk, + uint64_t *pk) { + expand_P1_P2(p, pk, cpk); + + unpack_m_vecs(cpk + PARAM_pk_seed_bytes(p), pk + PARAM_P1_limbs(p) + PARAM_P2_limbs(p), PARAM_P3_limbs(p)/PARAM_m_vec_limbs(p), PARAM_m(p)); + + return MAYO_OK; +} + +int mayo_verify(const mayo_params_t *p, const unsigned char *m, + size_t mlen, const unsigned char *sig, + const unsigned char *cpk) { + unsigned char tEnc[M_BYTES_MAX]; + unsigned char t[M_MAX]; + unsigned char y[2 * M_MAX] = {0}; // extra space for reduction mod f(X) + unsigned char s[K_MAX * N_MAX]; + uint64_t pk[P1_LIMBS_MAX + P2_LIMBS_MAX + P3_LIMBS_MAX] = {0}; + unsigned char tmp[DIGEST_BYTES_MAX + SALT_BYTES_MAX]; + + const int param_m = PARAM_m(p); + const int param_n = PARAM_n(p); + const int param_k = PARAM_k(p); + const int param_m_bytes = PARAM_m_bytes(p); + const int param_sig_bytes = PARAM_sig_bytes(p); + const int param_digest_bytes = PARAM_digest_bytes(p); + const int param_salt_bytes = PARAM_salt_bytes(p); + + int ret = mayo_expand_pk(p, cpk, pk); + if (ret != MAYO_OK) { + return MAYO_ERR; + } + + uint64_t *P1 = pk; + uint64_t *P2 = P1 + PARAM_P1_limbs(p); + uint64_t *P3 = P2 + PARAM_P2_limbs(p); + +#ifdef TARGET_BIG_ENDIAN + for (int i = 0; i < PARAM_P1_limbs(p); ++i) { + P1[i] = BSWAP64(P1[i]); + } + for (int i = 0; i < PARAM_P2_limbs(p); ++i) { + P2[i] = BSWAP64(P2[i]); + } + for (int i = 0; i < PARAM_P3_limbs(p); ++i) { + P3[i] = BSWAP64(P3[i]); + } +#endif + + // hash m + shake256(tmp, param_digest_bytes, m, mlen); + + // compute t + memcpy(tmp + param_digest_bytes, sig + param_sig_bytes - param_salt_bytes, + param_salt_bytes); + shake256(tEnc, param_m_bytes, tmp, param_digest_bytes + param_salt_bytes); + decode(tEnc, t, param_m); + + // decode s + decode(sig, s, param_k * param_n); + + eval_public_map(p, s, P1, P2, P3, y); + + if (memcmp(y, t, param_m) == 0) { + return MAYO_OK; // good signature + } + return MAYO_ERR; // bad signature +} + diff --git a/lib/mayo/mayo.h b/lib/mayo/mayo.h new file mode 100644 index 000000000..7cee7298e --- /dev/null +++ b/lib/mayo/mayo.h @@ -0,0 +1,442 @@ +// SPDX-License-Identifier: Apache-2.0 + +#ifndef MAYO_H +#define MAYO_H + +#include +#include + +#define F_TAIL_LEN 4 +#define F_TAIL_64 \ + { 8, 0, 2, 8 } // f(z) = z^64 + x^3*z^3 + x*z^2 + x^3 +#define F_TAIL_78 \ + { 8, 1, 1, 0 } // f(z) = z^78 + z^2 + z + x^3 +#define F_TAIL_108 \ + { 8, 0, 1, 7 } // f(z) = z^108 + (x^2 + x + 1)*z^3 + z^2 + x^3 +#define F_TAIL_142 \ + { 4, 0, 8, 1 } // f(z) = z^142 + z^3 + x^3*z^2 + x^2 + +#define MAYO_1_name "MAYO_1" +#define MAYO_1_n 86 +#define MAYO_1_m 78 +#define MAYO_1_m_vec_limbs 5 +#define MAYO_1_o 8 +#define MAYO_1_v (MAYO_1_n - MAYO_1_o) +#define MAYO_1_A_cols (MAYO_1_k * MAYO_1_o + 1) +#define MAYO_1_k 10 +#define MAYO_1_q 16 +#define MAYO_1_m_bytes 39 +#define MAYO_1_O_bytes 312 +#define MAYO_1_v_bytes 39 +#define MAYO_1_r_bytes 40 +#define MAYO_1_P1_bytes 120159 +#define MAYO_1_P2_bytes 24336 +#define MAYO_1_P3_bytes 1404 +#define MAYO_1_csk_bytes 24 +#define MAYO_1_cpk_bytes 1420 +#define MAYO_1_sig_bytes 454 +#define MAYO_1_f_tail F_TAIL_78 +#define MAYO_1_f_tail_arr f_tail_78 +#define MAYO_1_salt_bytes 24 +#define MAYO_1_digest_bytes 32 +#define MAYO_1_pk_seed_bytes 16 +#define MAYO_1_sk_seed_bytes 24 + +#define MAYO_2_name "MAYO_2" +#define MAYO_2_n 81 +#define MAYO_2_m 64 +#define MAYO_2_m_vec_limbs 4 +#define MAYO_2_o 17 +#define MAYO_2_v (MAYO_2_n - MAYO_2_o) +#define MAYO_2_A_cols (MAYO_2_k * MAYO_2_o + 1) +#define MAYO_2_k 4 +#define MAYO_2_q 16 +#define MAYO_2_m_bytes 32 +#define MAYO_2_O_bytes 544 +#define MAYO_2_v_bytes 32 +#define MAYO_2_r_bytes 34 +#define MAYO_2_P1_bytes 66560 +#define MAYO_2_P2_bytes 34816 +#define MAYO_2_P3_bytes 4896 +#define MAYO_2_csk_bytes 24 +#define MAYO_2_cpk_bytes 4912 +#define MAYO_2_sig_bytes 186 +#define MAYO_2_f_tail F_TAIL_64 +#define MAYO_2_f_tail_arr f_tail_64 +#define MAYO_2_salt_bytes 24 +#define MAYO_2_digest_bytes 32 +#define MAYO_2_pk_seed_bytes 16 +#define MAYO_2_sk_seed_bytes 24 + +#define MAYO_3_name "MAYO_3" +#define MAYO_3_n 118 +#define MAYO_3_m 108 +#define MAYO_3_m_vec_limbs 7 +#define MAYO_3_o 10 +#define MAYO_3_v (MAYO_3_n - MAYO_3_o) +#define MAYO_3_A_cols (MAYO_3_k * MAYO_3_o + 1) +#define MAYO_3_k 11 +#define MAYO_3_q 16 +#define MAYO_3_m_bytes 54 +#define MAYO_3_O_bytes 540 +#define MAYO_3_v_bytes 54 +#define MAYO_3_r_bytes 55 +#define MAYO_3_P1_bytes 317844 +#define MAYO_3_P2_bytes 58320 +#define MAYO_3_P3_bytes 2970 +#define MAYO_3_csk_bytes 32 +#define MAYO_3_cpk_bytes 2986 +#define MAYO_3_sig_bytes 681 +#define MAYO_3_f_tail F_TAIL_108 +#define MAYO_3_f_tail_arr f_tail_108 +#define MAYO_3_salt_bytes 32 +#define MAYO_3_digest_bytes 48 +#define MAYO_3_pk_seed_bytes 16 +#define MAYO_3_sk_seed_bytes 32 + +#define MAYO_5_name "MAYO_5" +#define MAYO_5_n 154 +#define MAYO_5_m 142 +#define MAYO_5_m_vec_limbs 9 +#define MAYO_5_o 12 +#define MAYO_5_v (MAYO_5_n - MAYO_5_o) +#define MAYO_5_A_cols (MAYO_5_k * MAYO_5_o + 1) +#define MAYO_5_k 12 +#define MAYO_5_q 16 +#define MAYO_5_m_bytes 71 +#define MAYO_5_O_bytes 852 +#define MAYO_5_v_bytes 71 +#define MAYO_5_r_bytes 72 +#define MAYO_5_P1_bytes 720863 +#define MAYO_5_P2_bytes 120984 +#define MAYO_5_P3_bytes 5538 +#define MAYO_5_csk_bytes 40 +#define MAYO_5_cpk_bytes 5554 +#define MAYO_5_sig_bytes 964 +#define MAYO_5_f_tail F_TAIL_142 +#define MAYO_5_f_tail_arr f_tail_142 +#define MAYO_5_salt_bytes 40 +#define MAYO_5_digest_bytes 64 +#define MAYO_5_pk_seed_bytes 16 +#define MAYO_5_sk_seed_bytes 40 + +#define PARAM_JOIN2_(a, b) a##_##b +#define PARAM_JOIN2(a, b) PARAM_JOIN2_(a, b) +#define PARAM_NAME(end) PARAM_JOIN2(MAYO_VARIANT, end) + +#if defined(MAYO_VARIANT) +#define PARAM_JOIN3_(a, b, c) pqmayo_##a##_##b##_##c +#define PARAM_JOIN3(a, b, c) PARAM_JOIN3_(a, b, c) +#define PARAM_NAME3(end, s) PARAM_JOIN3(MAYO_VARIANT, end, s) + +#if defined(MAYO_BUILD_TYPE_REF) +#define MAYO_NAMESPACE(s) PARAM_NAME3(ref, s) +#elif defined(MAYO_BUILD_TYPE_OPT) +#define MAYO_NAMESPACE(s) PARAM_NAME3(opt, s) +#elif defined(MAYO_BUILD_TYPE_AVX2) +#define MAYO_NAMESPACE(s) PARAM_NAME3(avx2, s) +#elif defined(MAYO_BUILD_TYPE_NEON) +#define MAYO_NAMESPACE(s) PARAM_NAME3(neon, s) +#else +#error "Build type not known" +#endif + +#else +#define MAYO_NAMESPACE(s) s +#endif + +#ifdef ENABLE_PARAMS_DYNAMIC +#define NAME_MAX mayo5 +#define N_MAX 154 +#define M_MAX 142 +#define O_MAX 17 +#define K_MAX 12 +#define Q_MAX 16 +#define PK_SEED_BYTES_MAX 16 +#define SK_SEED_BYTES_MAX 40 +#define SALT_BYTES_MAX 40 +#define DIGEST_BYTES_MAX 64 +#define V_MAX 142 +#define O_BYTES_MAX 852 +#define V_BYTES_MAX 71 +#define R_BYTES_MAX 72 +#define P1_BYTES_MAX 720863 +#define P2_BYTES_MAX 120984 +#define P3_BYTES_MAX 5538 +#define SIG_BYTES_MAX 964 +#define CPK_BYTES_MAX 5554 +#define CSK_BYTES_MAX 40 +#define M_BYTES_MAX 71 +#define M_VEC_LIMBS_MAX 9 +#elif defined(MAYO_VARIANT) +#define M_MAX PARAM_NAME(m) +#define M_VEC_LIMBS_MAX PARAM_NAME(m_vec_limbs) +#define N_MAX PARAM_NAME(n) +#define O_MAX PARAM_NAME(o) +#define V_MAX PARAM_NAME(v) +#define K_MAX PARAM_NAME(k) +#define Q_MAX PARAM_NAME(q) +#define M_BYTES_MAX PARAM_NAME(m_bytes) +#define O_BYTES_MAX PARAM_NAME(O_bytes) +#define V_BYTES_MAX PARAM_NAME(v_bytes) +#define R_BYTES_MAX PARAM_NAME(r_bytes) +#define P1_BYTES_MAX PARAM_NAME(P1_bytes) +#define P2_BYTES_MAX PARAM_NAME(P2_bytes) +#define P3_BYTES_MAX PARAM_NAME(P3_bytes) +#define SIG_BYTES_MAX PARAM_NAME(sig_bytes) +#define CSK_BYTES_MAX PARAM_NAME(csk_bytes) +#define CPK_BYTES_MAX PARAM_NAME(cpk_bytes) +#define SALT_BYTES_MAX PARAM_NAME(salt_bytes) +#define DIGEST_BYTES_MAX PARAM_NAME(digest_bytes) +#define PK_SEED_BYTES_MAX PARAM_NAME(pk_seed_bytes) +#define SK_SEED_BYTES_MAX SALT_BYTES_MAX +#else +#error "Parameter not specified" +#endif + +#define P1_LIMBS_MAX (V_MAX*(V_MAX+1)/2*M_VEC_LIMBS_MAX) +#define P2_LIMBS_MAX (V_MAX*O_MAX*M_VEC_LIMBS_MAX) +#define P3_LIMBS_MAX (O_MAX*(O_MAX+1)/2*M_VEC_LIMBS_MAX) + +#ifdef ENABLE_PARAMS_DYNAMIC +#define PARAM_name(p) (p->name) +#define PARAM_m(p) (p->m) +#define PARAM_m_vec_limbs(p) (p->m_vec_limbs) +#define PARAM_n(p) (p->n) +#define PARAM_o(p) (p->o) +#define PARAM_v(p) (p->n - p->o) +#define PARAM_A_cols(p) (p->k * p->o + 1) +#define PARAM_k(p) (p->k) +#define PARAM_q(p) (p->q) +#define PARAM_m_bytes(p) (p->m_bytes) +#define PARAM_O_bytes(p) (p->O_bytes) +#define PARAM_v_bytes(p) (p->v_bytes) +#define PARAM_r_bytes(p) (p->r_bytes) +#define PARAM_P1_bytes(p) (p->P1_bytes) +#define PARAM_P2_bytes(p) (p->P2_bytes) +#define PARAM_P3_bytes(p) (p->P3_bytes) +#define PARAM_csk_bytes(p) (p->csk_bytes) +#define PARAM_cpk_bytes(p) (p->cpk_bytes) +#define PARAM_sig_bytes(p) (p->sig_bytes) +#define PARAM_f_tail(p) (p->f_tail) +#define PARAM_salt_bytes(p) (p->salt_bytes) +#define PARAM_sk_seed_bytes(p) (p->sk_seed_bytes) +#define PARAM_digest_bytes(p) (p->digest_bytes) +#define PARAM_pk_seed_bytes(p) (p->pk_seed_bytes) +#elif defined(MAYO_VARIANT) +#define PARAM_name(p) PARAM_NAME(name) +#define PARAM_m(p) PARAM_NAME(m) +#define PARAM_m_vec_limbs(p) PARAM_NAME(m_vec_limbs) +#define PARAM_n(p) PARAM_NAME(n) +#define PARAM_o(p) PARAM_NAME(o) +#define PARAM_v(p) PARAM_NAME(v) +#define PARAM_A_cols(p) PARAM_NAME(A_cols) +#define PARAM_k(p) PARAM_NAME(k) +#define PARAM_q(p) PARAM_NAME(q) +#define PARAM_m_bytes(p) PARAM_NAME(m_bytes) +#define PARAM_O_bytes(p) PARAM_NAME(O_bytes) +#define PARAM_v_bytes(p) PARAM_NAME(v_bytes) +#define PARAM_r_bytes(p) PARAM_NAME(r_bytes) +#define PARAM_P1_bytes(p) PARAM_NAME(P1_bytes) +#define PARAM_P2_bytes(p) PARAM_NAME(P2_bytes) +#define PARAM_P3_bytes(p) PARAM_NAME(P3_bytes) +#define PARAM_csk_bytes(p) PARAM_NAME(csk_bytes) +#define PARAM_cpk_bytes(p) PARAM_NAME(cpk_bytes) +#define PARAM_epk_bytes(p) PARAM_NAME(epk_bytes) +#define PARAM_sig_bytes(p) PARAM_NAME(sig_bytes) +static const unsigned char f_tail[] = PARAM_NAME(f_tail); +#define PARAM_salt_bytes(p) PARAM_NAME(salt_bytes) +#define PARAM_sk_seed_bytes(p) PARAM_NAME(sk_seed_bytes) +#define PARAM_digest_bytes(p) PARAM_NAME(digest_bytes) +#define PARAM_pk_seed_bytes(p) PARAM_NAME(pk_seed_bytes) +#define PARAM_f_tail(p) f_tail +#else +#error "Parameter not specified" +#endif + +#define PARAM_P1_limbs(p) (PARAM_v(p)*(PARAM_v(p)+1)/2*PARAM_m_vec_limbs(p)) +#define PARAM_P2_limbs(p) (PARAM_v(p)*PARAM_o(p)*PARAM_m_vec_limbs(p)) +#define PARAM_P3_limbs(p) (PARAM_o(p)*(PARAM_o(p)+1)/2*PARAM_m_vec_limbs(p)) +#define PARAM_EPK_limbs(p) (PARAM_P1_limbs(p) + PARAM_P2_limbs(p) + PARAM_P3_limbs(p)) + +/** + * Struct defining MAYO parameters + */ +typedef struct { + int m; + int n; + int o; + int k; + int q; + const unsigned char *f_tail; + int m_bytes; + int O_bytes; + int v_bytes; + int r_bytes; + int R_bytes; + int P1_bytes; + int P2_bytes; + int P3_bytes; + int csk_bytes; + int cpk_bytes; + int sig_bytes; + int salt_bytes; + int sk_seed_bytes; + int digest_bytes; + int pk_seed_bytes; + int m_vec_limbs; + const char *name; +} mayo_params_t; + +typedef struct sk_t { + uint64_t p[P1_LIMBS_MAX + P2_LIMBS_MAX]; + uint8_t O[V_MAX*O_MAX]; +} sk_t; + +typedef struct pk_t { + uint64_t p[P1_LIMBS_MAX + P2_LIMBS_MAX + P3_LIMBS_MAX]; +} pk_t; + +/** + * MAYO parameter sets + */ +#ifdef ENABLE_PARAMS_DYNAMIC +extern const mayo_params_t MAYO_1; +extern const mayo_params_t MAYO_2; +extern const mayo_params_t MAYO_3; +extern const mayo_params_t MAYO_5; +#endif + +/** + * Status codes + */ +#define MAYO_OK 0 +#define MAYO_ERR 1 + +/** + * Mayo keypair generation. + * + * The implementation corresponds to Mayo.CompactKeyGen() in the Mayo spec. + * The caller is responsible to allocate sufficient memory to hold pk and sk. + * + * @param[in] p Mayo parameter set + * @param[out] pk Mayo public key + * @param[out] sk Mayo secret key + * @return int status code + */ +#define mayo_keypair MAYO_NAMESPACE(mayo_keypair) +int mayo_keypair(const mayo_params_t *p, unsigned char *pk, unsigned char *sk); + +#define mayo_sign_signature MAYO_NAMESPACE(mayo_sign_signature) +int mayo_sign_signature(const mayo_params_t *p, unsigned char *sig, + size_t *siglen, const unsigned char *m, + size_t mlen, const unsigned char *csk); + +/** + * MAYO signature generation. + * + * The implementation performs Mayo.expandSK() + Mayo.sign() in the Mayo spec. + * Keys provided is a compacted secret keys. + * The caller is responsible to allocate sufficient memory to hold sm. + * + * @param[in] p Mayo parameter set + * @param[out] sm Signature concatenated with message + * @param[out] smlen Pointer to the length of sm + * @param[in] m Message to be signed + * @param[in] mlen Message length + * @param[in] sk Compacted secret key + * @return int status code + */ +#define mayo_sign MAYO_NAMESPACE(mayo_sign) +int mayo_sign(const mayo_params_t *p, unsigned char *sm, + size_t *smlen, const unsigned char *m, + size_t mlen, const unsigned char *sk); + +/** + * Mayo open signature. + * + * The implementation performs Mayo.verify(). If the signature verification succeeded, the original message is stored in m. + * Keys provided is a compact public key. + * The caller is responsible to allocate sufficient memory to hold m. + * + * @param[in] p Mayo parameter set + * @param[out] m Message stored if verification succeeds + * @param[out] mlen Pointer to the length of m + * @param[in] sm Signature concatenated with message + * @param[in] smlen Length of sm + * @param[in] pk Compacted public key + * @return int status code + */ +#define mayo_open MAYO_NAMESPACE(mayo_open) +int mayo_open(const mayo_params_t *p, unsigned char *m, + size_t *mlen, const unsigned char *sm, + size_t smlen, const unsigned char *pk); + +/** + * Mayo compact keypair generation. + * + * The implementation corresponds to Mayo.CompactKeyGen() in the Mayo spec. + * The caller is responsible to allocate sufficient memory to hold pk and sk. + * + * outputs a pair (csk, cpk) \in B^{csk_bytes} x B^{cpk_bytes}, where csk and + * cpk are compact representations of a Mayo secret key and public key + * + * @param[in] p Mayo parameter set + * @param[out] cpk Mayo compacted public key + * @param[out] csk Mayo compacted secret key + * @return int status code + */ +#define mayo_keypair_compact MAYO_NAMESPACE(mayo_keypair_compact) +int mayo_keypair_compact(const mayo_params_t *p, unsigned char *cpk, + unsigned char *csk); + +/** + * Mayo expand public key. + * + * The implementation corresponds to Mayo.expandPK() in the Mayo spec. + * The caller is responsible to allocate sufficient memory to hold epk. + * + * @param[in] p Mayo parameter set + * @param[in] cpk Compacted public key. + * @param[out] epk Expanded public key. + * @return int return code + */ +#define mayo_expand_pk MAYO_NAMESPACE(mayo_expand_pk) +int mayo_expand_pk(const mayo_params_t *p, const unsigned char *cpk, + uint64_t *epk); + +/** + * Mayo expand secret key. + * + * The implementation corresponds to Mayo.expandSK() in the Mayo spec. + * The caller is responsible to allocate sufficient memory to hold esk. + * + * @param[in] p Mayo parameter set + * @param[in] csk Compacted secret key. + * @param[out] esk Expanded secret key. + * @return int return code + */ +#define mayo_expand_sk MAYO_NAMESPACE(mayo_expand_sk) +int mayo_expand_sk(const mayo_params_t *p, const unsigned char *csk, + sk_t *esk); + +/** + * Mayo verify signature. + * + * The implementation performs Mayo.verify(). If the signature verification succeeded, returns 0, otherwise 1. + * Keys provided is a compact public key. + * + * @param[in] p Mayo parameter set + * @param[out] m Message stored if verification succeeds + * @param[out] mlen Pointer to the length of m + * @param[in] sig Signature + * @param[in] pk Compacted public key + * @return int 0 if verification succeeded, 1 otherwise. + */ +#define mayo_verify MAYO_NAMESPACE(mayo_verify) +int mayo_verify(const mayo_params_t *p, const unsigned char *m, + size_t mlen, const unsigned char *sig, + const unsigned char *pk); + +#endif + diff --git a/lib/mayo/mem.c b/lib/mayo/mem.c new file mode 100644 index 000000000..bce37fa3b --- /dev/null +++ b/lib/mayo/mem.c @@ -0,0 +1,19 @@ +// SPDX-License-Identifier: Apache-2.0 + +#include +#include +#include + +void mayo_secure_free(void *mem, size_t size) { + if (mem) { + typedef void *(*memset_t)(void *, int, size_t); + static volatile memset_t memset_func = memset; + memset_func(mem, 0, size); + free(mem); + } +} +void mayo_secure_clear(void *mem, size_t size) { + typedef void *(*memset_t)(void *, int, size_t); + static volatile memset_t memset_func = memset; + memset_func(mem, 0, size); +} diff --git a/lib/mayo/mem.h b/lib/mayo/mem.h new file mode 100644 index 000000000..87324b8d7 --- /dev/null +++ b/lib/mayo/mem.h @@ -0,0 +1,25 @@ +// SPDX-License-Identifier: Apache-2.0 + +#ifndef MEM_H +#define MEM_H +#include +#include + +/** + * Clears and frees allocated memory. + * + * @param[out] mem Memory to be cleared and freed. + * @param size Size of memory to be cleared and freed. + */ +void mayo_secure_free(void *mem, size_t size); + +/** + * Clears memory. + * + * @param[out] mem Memory to be cleared. + * @param size Size of memory to be cleared. + */ +void mayo_secure_clear(void *mem, size_t size); + +#endif + diff --git a/lib/mayo/params.c b/lib/mayo/params.c new file mode 100644 index 000000000..392d6d946 --- /dev/null +++ b/lib/mayo/params.c @@ -0,0 +1,42 @@ +// SPDX-License-Identifier: Apache-2.0 + +#include + +#ifdef ENABLE_PARAMS_DYNAMIC +static const unsigned char f_tail_64[] = F_TAIL_64; +static const unsigned char f_tail_78[] = F_TAIL_78; +static const unsigned char f_tail_108[] = F_TAIL_108; +static const unsigned char f_tail_142[] = F_TAIL_142; + +#define MAYO_GEN_PARAMS(nm) \ + const mayo_params_t nm = { \ + .m = PARAM_JOIN2(nm, m), \ + .n = PARAM_JOIN2(nm, n), \ + .o = PARAM_JOIN2(nm, o), \ + .k = PARAM_JOIN2(nm, k), \ + .q = PARAM_JOIN2(nm, q), \ + .f_tail = PARAM_JOIN2(nm, f_tail_arr), \ + .m_bytes = PARAM_JOIN2(nm, m_bytes), \ + .O_bytes = PARAM_JOIN2(nm, O_bytes), \ + .v_bytes = PARAM_JOIN2(nm, v_bytes), \ + .r_bytes = PARAM_JOIN2(nm, r_bytes), \ + .P1_bytes = PARAM_JOIN2(nm, P1_bytes), \ + .P2_bytes = PARAM_JOIN2(nm, P2_bytes), \ + .P3_bytes = PARAM_JOIN2(nm, P3_bytes), \ + .csk_bytes = PARAM_JOIN2(nm, csk_bytes), \ + .cpk_bytes = PARAM_JOIN2(nm, cpk_bytes), \ + .sig_bytes = PARAM_JOIN2(nm, sig_bytes), \ + .salt_bytes = PARAM_JOIN2(nm, salt_bytes), \ + .sk_seed_bytes = PARAM_JOIN2(nm, sk_seed_bytes), \ + .digest_bytes = PARAM_JOIN2(nm, digest_bytes), \ + .pk_seed_bytes = PARAM_JOIN2(nm, pk_seed_bytes), \ + .m_vec_limbs = PARAM_JOIN2(nm, m_vec_limbs), \ + .name = #nm \ + }; + +MAYO_GEN_PARAMS(MAYO_1); +MAYO_GEN_PARAMS(MAYO_2); +MAYO_GEN_PARAMS(MAYO_3); +MAYO_GEN_PARAMS(MAYO_5); +#endif + diff --git a/lib/mayo/simple_arithmetic.h b/lib/mayo/simple_arithmetic.h new file mode 100644 index 000000000..cca0e9ba5 --- /dev/null +++ b/lib/mayo/simple_arithmetic.h @@ -0,0 +1,138 @@ +// SPDX-License-Identifier: Apache-2.0 + +#ifndef SIMPLE_ARITHMETIC_H +#define SIMPLE_ARITHMETIC_H +#include + +// GF(16) multiplication mod x^4 + x + 1 +static inline unsigned char mul_f(unsigned char a, unsigned char b) { + // carryless multiply + unsigned char p; + +#if !(((defined(__clang__) && __clang_major__ < 15) || (!defined(__clang__) && defined(__GNUC__) && __GNUC__ <= 12)) && (defined(__x86_64__) || defined(_M_X64))) + a ^= unsigned_char_blocker; +#endif + + p = (a & 1)*b; + p ^= (a & 2)*b; + p ^= (a & 4)*b; + p ^= (a & 8)*b; + + // reduce mod x^4 + x + 1 + unsigned char top_p = p & 0xf0; + unsigned char out = (p ^ (top_p >> 4) ^ (top_p >> 3)) & 0x0f; + return out; +} + +static inline uint64_t mul_fx8(unsigned char a, uint64_t b) { + // carryless multiply + uint64_t p; + p = (a & 1)*b; + p ^= (a & 2)*b; + p ^= (a & 4)*b; + p ^= (a & 8)*b; + + // reduce mod x^4 + x + 1 + uint64_t top_p = p & 0xf0f0f0f0f0f0f0f0; + uint64_t out = (p ^ (top_p >> 4) ^ (top_p >> 3)) & 0x0f0f0f0f0f0f0f0f; + return out; +} + +// GF(16) addition +static inline unsigned char add_f(unsigned char a, unsigned char b) { + return a ^ b; +} + +// GF(16) subtraction +static inline unsigned char sub_f(unsigned char a, unsigned char b) { + return a ^ b; +} + +// GF(16) negation +static inline unsigned char neg_f(unsigned char a) { + return a; +} + +static inline unsigned char inverse_f(unsigned char a) { + // static unsigned char table[16] = {0, 1, 9, 14, 13, 11, 7, 6, 15, 2, 12, 5, + // 10, 4, 3, 8}; return table[a & 15]; + + unsigned char a2 = mul_f(a, a); + unsigned char a4 = mul_f(a2, a2); + unsigned char a8 = mul_f(a4, a4); + unsigned char a6 = mul_f(a2, a4); + unsigned char a14 = mul_f(a8, a6); + + return a14; +} + +static inline unsigned char lincomb(const unsigned char *a, + const unsigned char *b, int n, int m) { + unsigned char ret = 0; + for (int i = 0; i < n; ++i, b += m) { + ret = add_f(mul_f(a[i], *b), ret); + } + return ret; +} + +static inline void mat_mul(const unsigned char *a, const unsigned char *b, + unsigned char *c, int colrow_ab, int row_a, int col_b) { + for (int i = 0; i < row_a; ++i, a += colrow_ab) { + for (int j = 0; j < col_b; ++j, ++c) { + *c = lincomb(a, b + j, colrow_ab, col_b); + } + } +} + +static inline void mat_add(const unsigned char *a, const unsigned char *b, + unsigned char *c, int m, int n) { + for (int i = 0; i < m; ++i) { + for (int j = 0; j < n; ++j) { + *(c + i * n + j) = add_f(*(a + i * n + j), *(b + i * n + j)); + } + } +} + +static inline uint64_t gf16v_mul_u64( uint64_t a, uint8_t b ) { + uint64_t mask_msb = 0x8888888888888888ULL; + uint64_t a_msb; + uint64_t a64 = a; +#if !(((defined(__clang__) && __clang_major__ < 15) || (!defined(__clang__) && defined(__GNUC__) && __GNUC__ <= 12)) && (defined(__x86_64__) || defined(_M_X64))) + uint64_t b32 = b ^ unsigned_char_blocker; +#else + uint64_t b32 = b; +#endif + uint64_t r64 = a64 * (b32 & 1); + + a_msb = a64 & mask_msb; // MSB, 3rd bits + a64 ^= a_msb; // clear MSB + a64 = (a64 << 1) ^ ((a_msb >> 3) * 3); + r64 ^= (a64) * ((b32 >> 1) & 1); + + a_msb = a64 & mask_msb; // MSB, 3rd bits + a64 ^= a_msb; // clear MSB + a64 = (a64 << 1) ^ ((a_msb >> 3) * 3); + r64 ^= (a64) * ((b32 >> 2) & 1); + + a_msb = a64 & mask_msb; // MSB, 3rd bits + a64 ^= a_msb; // clear MSB + a64 = (a64 << 1) ^ ((a_msb >> 3) * 3); + r64 ^= (a64) * ((b32 >> 3) & 1); + + return r64; +} + +// This implements arithmetic for nibble-packed vectors of m field elements in Z_2[x]/(x^4+x+1) +// gf16 := gf2[x]/(x^4+x+1) + +static inline uint32_t mul_table(uint8_t b){ + uint32_t x = ((uint32_t) b) * 0x08040201; + + uint32_t high_nibble_mask = 0xf0f0f0f0; + + uint32_t high_half = x & high_nibble_mask; + return (x ^ (high_half >> 4) ^ (high_half >> 3)); +} + +#endif + From 0dbb932014f5347fe950874daf071f595e3ccb7a Mon Sep 17 00:00:00 2001 From: ms8421ms <109365501+ms8421ms@users.noreply.github.com> Date: Fri, 13 Mar 2026 22:10:29 +0100 Subject: [PATCH 03/19] chore: create zen_mayo --- src/zen_mayo.c | 191 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 191 insertions(+) create mode 100644 src/zen_mayo.c diff --git a/src/zen_mayo.c b/src/zen_mayo.c new file mode 100644 index 000000000..7d5b30f55 --- /dev/null +++ b/src/zen_mayo.c @@ -0,0 +1,191 @@ +#include +#include +#include +#include + +// MAYO parameters and build configuration +#define MAYO_VARIANT MAYO_5 +#define MAYO_BUILD_TYPE_REF 1 + +#include "api.h" + +static int zen_mayo_keygen(lua_State *L) { + BEGIN(); + char *failed_msg = NULL; + lua_createtable(L, 0, 2); + + int sk_len = CRYPTO_SECRETKEYBYTES; + int pk_len = CRYPTO_PUBLICKEYBYTES; + + octet *private = o_new(L, sk_len); SAFE_GOTO(private, "Could not create private key"); + lua_setfield(L, -2, "private"); + octet *public = o_new(L, pk_len); SAFE_GOTO(public, "Could not create public key"); + lua_setfield(L, -2, "public"); + + crypto_sign_keypair((unsigned char*)public->val, (unsigned char*)private->val); + public->len = pk_len; + private->len = sk_len; + +end: + if(failed_msg) { + THROW(failed_msg); + } + END(1); +} + +static int zen_mayo_sign(lua_State *L) { + BEGIN(); + char *failed_msg = NULL; + const octet *sk = NULL, *m = NULL; + sk = o_arg(L, 1); SAFE_GOTO(sk, "Could not allocate secret key"); + SAFE_GOTO(sk->len == CRYPTO_SECRETKEYBYTES, "Invalid size for MAYO_5 secret key"); + m = o_arg(L, 2); SAFE_GOTO(m, "Could not allocate message"); + octet *sig = o_new(L, CRYPTO_BYTES); SAFE_GOTO(sig, "Could not create signature"); + SAFE_GOTO( + !crypto_sign_signature( + (unsigned char*)sig->val, + (size_t*)&sig->len, + (unsigned char*)m->val, m->len, + (unsigned char*)sk->val + ) || sig->len <= 0, + "Could not sign the message" + ); +end: + o_free(L, m); + o_free(L, sk); + if(failed_msg) { + THROW(failed_msg); + } + END(1); +} + +static int zen_mayo_signature_pubcheck(lua_State *L) { + BEGIN(); + const octet *pk = o_arg(L, 1); SAFE(pk, "Could not allocate public key"); + if(pk->len == CRYPTO_PUBLICKEYBYTES) + lua_pushboolean(L, 1); + else + lua_pushboolean(L, 0); + o_free(L, pk); + END(1); +} + +static int zen_mayo_signed_message(lua_State *L) { + BEGIN(); + char *failed_msg = NULL; + const octet *sk = NULL, *m = NULL; + sk = o_arg(L, 1); SAFE_GOTO(sk, "Could not allocate secret key"); + SAFE_GOTO(sk->len == CRYPTO_SECRETKEYBYTES, "Invalid size for MAYO_5 secret key"); + m = o_arg(L, 2); SAFE_GOTO(m, "Could not allocate message"); + octet *sig = o_new(L, CRYPTO_BYTES + m->len); SAFE_GOTO(sig, "Could not create signature"); + SAFE_GOTO( + !crypto_sign( + (unsigned char*)sig->val, + (size_t*)&sig->len, + (unsigned char*)m->val, m->len, + (unsigned char*)sk->val + ) || sig->len <= 0, + "Could not sign the message" + ); +end: + o_free(L, m); + o_free(L, sk); + if(failed_msg) { + THROW(failed_msg); + } + END(1); +} + +static int zen_mayo_verified_message(lua_State *L) { + BEGIN(); + char *failed_msg = NULL; + const octet *pk = NULL, *sm = NULL; + pk = o_arg(L, 1); SAFE_GOTO(pk, "Could not allocate public key"); + SAFE_GOTO(pk->len == CRYPTO_PUBLICKEYBYTES, "Invalid size for MAYO_5 public key"); + sm = o_arg(L, 2); SAFE_GOTO(sm, "Could not allocate signed message"); + octet *msg = o_new(L, sm->len); SAFE_GOTO(msg, "Could not create message"); + int result = crypto_sign_open( + (unsigned char*)msg->val, + (size_t*)&msg->len, + (unsigned char*)sm->val, sm->len, + (unsigned char*)pk->val) == 0 + && msg->len > 0; + if(!result) { + lua_pushboolean(L, 0); + } +end: + o_free(L, sm); + o_free(L, pk); + if(failed_msg) { + THROW(failed_msg); + } + END(1); +} + +static int zen_mayo_verify(lua_State *L) { + BEGIN(); + char *failed_msg = NULL; + const octet *pk = NULL, *sig = NULL, *m = NULL; + pk = o_arg(L, 1); SAFE_GOTO(pk, "Could not allocate public key"); + SAFE_GOTO(pk->len == CRYPTO_PUBLICKEYBYTES, "Invalid size for MAYO_5 public key"); + sig = o_arg(L, 2); SAFE_GOTO(sig, "Could not allocate signature"); + m = o_arg(L, 3); SAFE_GOTO(m, "Could not allocate message"); + int result = crypto_sign_verify( + (unsigned char*)sig->val, + (size_t)sig->len, + (unsigned char*)m->val, m->len, + (unsigned char*)pk->val + ); + lua_pushboolean(L, result == 0); +end: + o_free(L, m); + o_free(L, sig); + o_free(L, pk); + if(failed_msg) { + THROW(failed_msg); + } + END(1); +} + +static int zen_mayo_signature_len(lua_State *L){ + BEGIN(); + lua_pushinteger(L, CRYPTO_BYTES); + END(1); +} + +static int zen_mayo_signature_check(lua_State *L) { + BEGIN(); + char *failed_msg = NULL; + const octet *sign = o_arg(L, 1); SAFE_GOTO(sign, "Could not allocate signature"); + if(sign->len == CRYPTO_BYTES) + lua_pushboolean(L, 1); + else + lua_pushboolean(L, 0); +end: + o_free(L, sign); + if(failed_msg) { + THROW(failed_msg); + } + END(1); +} + +int luaopen_mayo(lua_State *L) { + const struct luaL_Reg mayo_class[] = { + {"sigkeygen", zen_mayo_keygen}, + {"sigpubcheck", zen_mayo_signature_pubcheck}, + {"sign", zen_mayo_sign}, + {"verify", zen_mayo_verify}, + {"signed_msg", zen_mayo_signed_message}, + {"verified_msg", zen_mayo_verified_message}, + {"signature_len", zen_mayo_signature_len}, + {"signature_check", zen_mayo_signature_check}, + {NULL, NULL} + }; + + const struct luaL_Reg mayo_methods[] = { + {NULL, NULL} + }; + + zen_add_class(L, "mayo", mayo_class, mayo_methods); + return 1; +} \ No newline at end of file From 5f38cc26b36ffe2063f9e32d097544b6e7fa7465 Mon Sep 17 00:00:00 2001 From: ms8421ms <109365501+ms8421ms@users.noreply.github.com> Date: Fri, 13 Mar 2026 22:11:25 +0100 Subject: [PATCH 04/19] chore: create zencode_mayo.lua --- src/lua/zencode_mayo.lua | 57 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 57 insertions(+) create mode 100644 src/lua/zencode_mayo.lua diff --git a/src/lua/zencode_mayo.lua b/src/lua/zencode_mayo.lua new file mode 100644 index 000000000..b2b8d5907 --- /dev/null +++ b/src/lua/zencode_mayo.lua @@ -0,0 +1,57 @@ +local mayo = require 'mayo' + +local function mayo_public_key_f(obj) + local res = schema_get(obj, '.') + zencode_assert( + mayo.sigpubcheck(res), + 'MAYO public key length is not correct' + ) + return res +end + +local function dilithium_signature_f(obj) + local res = schema_get(obj, '.') + zencode_assert( + mayo.signature_check(res), + 'MAYO signature length is not correct' + ) + return res +end + +ZEN:add_schema( + { + mayo_public_key = {import=mayo_public_key_f}, + mayo_signature = {import=dilithium_signature_f} + } +) + +--# MAYO #-- + +-- generate the keypair +When("create mayo key pair",function() + initkeyring'mayo' + empty'mayo public key' + local keys = mayo.sigkeygen() + ACK.keyring.mayo = keys.private + ACK.mayo_public_key = keys.public + new_codec('mayo public key') +end) + +-- generate the sign for a msg and verify +When("create mayo signature of ''",function(doc) + local sk = havekey'mayo' + local obj = have(doc) + empty'mayo signature' + ACK.mayo_signature = mayo.sign(sk, zencode_serialize(obj)) + new_codec('mayo signature') +end) + +IfWhen("verify '' has a mayo signature in '' by ''",function(msg, sig, by) + local pk = load_pubkey_compat(by, 'mayo') + local m = have(msg) + local s = have(sig) + zencode_assert( + mayo.verify(pk, s, zencode_serialize(m)), + 'The mayo signature by '..by..' is not authentic' + ) +end) \ No newline at end of file From f1c99c672bd5042c9b308504faedcedca3c59e31 Mon Sep 17 00:00:00 2001 From: ms8421ms <109365501+ms8421ms@users.noreply.github.com> Date: Fri, 13 Mar 2026 22:17:01 +0100 Subject: [PATCH 05/19] test: added mayo test files --- test/lua/mayo.lua | 30 ++ test/vectors/check_mayo.lua | 43 ++ test/vectors/mayo.bats | 5 + test/vectors/mayo5.rsp | 902 +++++++++++++++++++++++++++++++++ test/zencode/generic_mayo.bats | 145 ++++++ 5 files changed, 1125 insertions(+) create mode 100644 test/lua/mayo.lua create mode 100644 test/vectors/check_mayo.lua create mode 100644 test/vectors/mayo.bats create mode 100644 test/vectors/mayo5.rsp create mode 100644 test/zencode/generic_mayo.bats diff --git a/test/lua/mayo.lua b/test/lua/mayo.lua new file mode 100644 index 000000000..6b1167308 --- /dev/null +++ b/test/lua/mayo.lua @@ -0,0 +1,30 @@ +print() +print'MAYO ALGORITHMS TESTS' +print() + +local mayo = require'mayo' + +local kp = mayo.sigkeygen() + +local msg = [[ +Lorem ipsum dolor sit amet, consectetur adipiscing elit. +Praesent vel velit non velit ullamcorper pulvinar. Curabitur +non est in sem placerat fringilla. Sed non rutrum nunc, +et consequat leo. Aenean at nisi in purus commodo porta convallis +vitae nulla. Mauris magna ligula, hendrerit non augue eget, +eleifend pellentesque nibh. Curabitur arcu mauris, iaculis +convallis felis dapibus, luctus varius dui.]] + +print'iterate 100 tests of sign/verify' + +for i=1,100 do + local sig = mayo.sign(kp.private, O.from_string(msg)) + assert(mayo.verify(kp.public, sig, O.from_string(msg)), "mayo verify failed") + assert(not mayo.verify(kp.public, sig, O.to_string(sha256(m))), "mayo verify failed") +end + +for i=1,100 do + local sm = mayo.signed_msg(kp.private, msg) + assert(mayo.verified_msg(kp.public, sm):string() == msg,"mayo verify message failed") + assert(not mayo.verified_msg(kp.public, sig, O.to_string(sha256(m))), "mayo verify message failed") +end \ No newline at end of file diff --git a/test/vectors/check_mayo.lua b/test/vectors/check_mayo.lua new file mode 100644 index 000000000..d70e79460 --- /dev/null +++ b/test/vectors/check_mayo.lua @@ -0,0 +1,43 @@ +-- this is a simple rsp parser by jaromil@dyne.org +-- an rsp file must be loaded in DATA +-- the kind of hash must be indicated in KEYS +-- public domain (and thanks for all the NIST) + +local function newline_iter(text) + s = trim(text) -- implemented in zen_io.c + if s:sub(-1) ~= '\n' then + s = s .. '\n' + end + return s:gmatch('(.-)\n') -- iterators return functions +end + +local mayo = require'mayo' +local curr_fields = 0 +local test = { } +for line in newline_iter(DATA) do + if line:sub(1,1) ~= "#" then + local rule = strtok(line) + + if #rule > 0 and rule[1] ~= "" and rule[1]:lower() ~= "count" and rule[1]:lower() ~= "mlen" and rule[1]:lower() ~= "smlen" then + curr_fields = curr_fields+1 + + test[rule[1]:lower()] = O.from_hex(rule[3]) + end + + if curr_fields == 5 then + -- Here starts the test + assert(mayo.sigpubcheck(test.pk)) + assert(mayo.signature_check(test.sm:sub(1, mayo.signature_len()))) + assert(mayo.verify(test.pk, test.sm:sub(1, mayo.signature_len()), test.msg)) + assert(test.msg == mayo.verified_msg(test.pk, test.sm)) + + -- These test are different from the dilithium ones because of the way the signature is generated (deterministically in dilithium, non-deterministically in mayo) + -- Here we only check verify works + local new_sig = mayo.sign(test.sk, test.msg) + assert(mayo.verify(test.pk, new_sig, test.msg)) + + curr_fields = 0 + test = { } + end + end +end \ No newline at end of file diff --git a/test/vectors/mayo.bats b/test/vectors/mayo.bats new file mode 100644 index 000000000..168624cd6 --- /dev/null +++ b/test/vectors/mayo.bats @@ -0,0 +1,5 @@ +load ../bats_setup + +@test "NIST qp: mayo" { + ${ZENROOM_EXECUTABLE} -a $T/mayo5.rsp $T/check_mayo.lua +} \ No newline at end of file diff --git a/test/vectors/mayo5.rsp b/test/vectors/mayo5.rsp new file mode 100644 index 000000000..19a1468d0 --- /dev/null +++ b/test/vectors/mayo5.rsp @@ -0,0 +1,902 @@ +# MAYO_5 + +count = 0 +seed = 061550234D158C5EC95595FE04EF7A25767F2E24CC2BC479D09D86DC9ABCFDE7056A8C266F9EF97ED08541DBD2E1FFA1 +mlen = 33 +msg = D81C4D8D734FCBFBEADE3D3F8A039FAA2A2C9957E835AD55B22E75BF57BB556AC8 +pk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sk = 7C9935A0B07694AA0C6D10E4DB6B1ADD2FD81A25CCB148032DCD739936737F2DB505D7CFAD1B4974 +smlen = 997 +sm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count = 1 +seed = 64335BF29E5DE62842C941766BA129B0643B5E7121CA26CFC190EC7DC3543830557FDD5C03CF123A456D48EFEA43C868 +mlen = 66 +msg = 225D5CE2CEAC61930A07503FB59F7C2F936A3E075481DA3CA299A80F8C5DF9223A073E7B90E02EBF98CA2227EBA38C1AB2568209E46DBA961869C6F83983B17DCD49 +pk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sk = 4B622DE1350119C45A9F2E2EF3DC5DF50A759D138CDFBD64C81CC7CC2F513345D5A45A4CED06403C +smlen = 1030 +sm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count = 2 +seed = BFF58FDA9DB4C2D8BD02E4647868D4A2FA12500A65CA4C9F918B505707FA775951018D9149C97D443EA16B07DD68435B +mlen = 99 +msg = 2B8C4B0F29363EAEE469A7E33524538AA066AE98980EAA19D1F10593203DA2143B9E9E1973F7FF0E6C6AAA3C0B900E50D003412EFE96DEECE3046D8C46BC7709228789775ABDF56AED6416C90033780CB7A4984815DA1B14660DCF34AA34BF82CEBBCF +pk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sk = 1D836E889E46259BCD1CCD2B369583C5B47CFBB919EC2B72C280247CB15A55694FD6BCF6161023F9 +smlen = 1063 +sm = 3247FD18E34FE9E5B749ACF96B7935BB3F8922914A7EA1C3B2E340E0D27036DF9B784ACE163A5E902EAF189F745B1221D47EC9DB8B84C8E714BD3E3986552293A833636F9073B325DAE863F8230C764DD5320FA7DF423C70997D443057DA402C090BD4F86B43F8B5FB67FB35592241326F2BA8E7AA3AE97F4FAAA47824B2B886EBC7A701525AD38CF3F7FBE1A25CB1CED05FDA4C8AA8F6EBAD1DB387CAAAF17C02963D31D7C43C21B0B5F9821BF798BF74042C07DA4B7F51ACCF4BE0951D8A7F89996EA8421DA45D71EADC18DCD555040B83C9FC6144B7D2FE1C56546CAE85077048C4483D8752A13E1A7D72EBB84A0ABBD11484CE69A8066E931E18C31D15790ECDD42B8E540927A9D59E9F08FEE4C87F2875273E8F2A4DCA065C978281B1D516B57DF2FD7C51F533652075654DB043577CF72923FD6D9B988BD555F8AB648AE6951AF759608A367207137F7F4F0BFEAFB833832B867EB3B0E9924EBC1FD676756A533813179894A14E8773395490846741088FF87C23A54E60FE9E36848143E530A420557D676AE4F036388614745A5388D2077311C22CEBCA496A1FDEDF1F5FE8C13CF88442B93F7452FE1B3C9D24313594ECB24355210ACE7F8A0609BCA368BE1DC6A614E05EC22E089EED75223B9AE42B66995DA331E2DC348BBE0A37D78BBABAB35C890527D3A0C5C59C5CC3BCC91976CDF6B56B502B109668B998E2BBC44F29D0B49B3E060ACAD77FFA15E09BC0BAF298FB14FE125A022B1366A74A0F570E5DCD11ACEA51B235BB011D472BB96B6F4453E084058CEA87DAC45275431A305A16507067C481E1D239F3B8F1DB59E31282B5530FD0AAC8C59D0D86C9DFFCB71CED8363E9DB67E1F879E00444C87C8E275B272E1A5EC9EF2A4DB0922CFE08058E43921843855F2B9B7267250DAE5E1400ADA8FBEFAF8CF5243C34511C28DA7059149F75860821C141E220F405ACA7AF2EBC61B1F6E67DDB4F7913BDCF54CCE02FA108D14BFEA99109376C63A526DAF02A591EE7914623B134C2F188CEBCAD33CB1A7E28D497AFE0C172827AC477B517EEF72B68F225CF32242C023F20A52260530B8E1F022A5E54BBEE9544A5581191B47F48C4D8FD88D76BA852FD2C89B8D0C5DE148480EED859B5F5B1814B3BD8E857CBAC699D01758CBD3073E095BFE3B3943C6966414299A5361BED68471F91A4DC504549212DC491C0824B89281698A9FB3478DFE08F22455C604196460E6DC0E4E8BFF711B3F94E1C4D0E1433F0292D20C1FDBAC96F34C8661BC2FD8FEE0E5C26EAFBFB394404A09FB21D71CC1E8577723BA400A817B169E0424111F0599B5C86408E16E1250223B1815307CD59C0DE6B01722B8C4B0F29363EAEE469A7E33524538AA066AE98980EAA19D1F10593203DA2143B9E9E1973F7FF0E6C6AAA3C0B900E50D003412EFE96DEECE3046D8C46BC7709228789775ABDF56AED6416C90033780CB7A4984815DA1B14660DCF34AA34BF82CEBBCF + +count = 3 +seed = 58C094D217BC13EDFDBEA57EDBF3A536F8F69FED1D54648CE3D0CCB4847A5C9917C2E2BC4D5F620E937F0D329FCF8A16 +mlen = 132 +msg = 2F7AF5B52A046471EFCD720C9384919BE05A61CDE8E8B01251C5AB885E820FD36ED9FF6FDF45783EC81A86728CBB74B426ADFF96123C08FAC2BC6C58A9C0DD71761292262C65F20DF47751F0831770A6BB7B3760BB7F5EFFFB6E11AC35F353A6F24400B80B287834E92C9CF0D3C949D6DCA31B0B94E0E3312E8BD02174B170C2CA9355FE +pk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sk = 539577CB7F2088FBEDFF1B53F235D607321857DB32BBA645F8DF3A89DD426552FF690305D543EE0F +smlen = 1096 +sm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count = 4 +seed = F1902A7815F37BC7F5802D8CBCE5B48D82EB85691718062BFB84D8C06AA41D6E9039B0A107245DAFA4EC109A57332914 +mlen = 165 +msg = 1CDF0AE1124780A8FF00318F779A3B86B3504D059CA7AB3FE4D6EAE9FD46428D1DABB704C0735A8FE8708F409741017B723D9A304E54FDC5789A7B0748C2464B7308AC9665115644C569AE253D5205751342574C03346DDDC1950A6273546616B96D0C5ECE0A044AF0EDEFBE445F9AE37DA5AFB8D22A56D9FD1801425A0A276F48431D7AF039521E549551481391FE5F4EBFB7644D9F9782D83A95137E84EA3AEB3C2F8099 +pk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sk = 2CA59C6CF33C53803749F69EF5ABFA9482FCEE7EFD87FBF17135ECC3FF3FD7F749FD2F99CF65690A +smlen = 1129 +sm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count = 5 +seed = 75224ECC026C18159FF92256844D0ADF953F0A4DD8D74D4EBF1DC5EE8F5630B011A447FD4DC34A2404D620CA0E1F273E +mlen = 198 +msg = DBE5B6C299B44F8D60FA972A336DF789EF4534EC9BA90DF92AD401D1907951EB6285EDA8F134277AB0A1145001C34E392187122506AA2DBB8617D7943A129EB5C07DF133D7CCDE94A7CB7F1795C62493ED375353D1F044257DA799F7D112C174FBC35687E2F87FEFBE2D83D29D7314B30A749FE41B1B81095638F112BC4563420AF235280E466FFBE7050C4937C60FC18D1A6025BCBD489F0C538E088E906ABE8597E2C8EBB64F01D225C847AAE4B77BAE6EBA9269962C4B94A9732CEAA2CB4093D442FFBCDD +pk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sk = E17E72290E49A44C9C534F211195257CF13B0D45405782CEDA2D7F982A551721B47CFCF1B7764296 +smlen = 1162 +sm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count = 6 +seed = 447F03C8CD27EDAA1FA0436DA492812F57AC946479A9F1F90EC4F5E913A05F8AB0DD7645026A96510F6D40AF05D85B07 +mlen = 231 +msg = 0073BEE97FC97C0FBC750D474AEB93189F061E1A5CF6600C04FB0464338EC7E85252F94FCBC7B2BD00E438480D9AF3ADD92A92E3E2E8ACB55077C3278FC7503988A76E9B6062996B20889AA55B343D5A003C8A8852D738F955799FA3426BE5CCD3AA6B6EDA04D4884941FFC0B69C5ACF12B347A74D0580CC3335BA816200F87674A4C1D98097C70F2F27C74E94A661850610ECF4847AB5B58344F958C5719E06BA396225BBE21ACB0FDC512B885D391E11B0C0ED5CE6B5DD8FAFF91F50025C69D43072F7706D80D9FD786E1104125D79A5F4B5FD838815D44FC8B1AB678078CC174DDE970D448B +pk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sk = 3B7388E675DE5C59A78AF095481C7DD999C6EEA898595B1E7DCDA7EDC3A2C25C5E03F7AABB1929A6 +smlen = 1195 +sm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count = 7 +seed = 8C151C556DA912A82DEB32144C8A8C9090CFAF5C12AB822AC3C72618837A41C2453B715EEFF3724CAFE69B1ADCAE9DDA +mlen = 264 +msg = A1586245D81F96BD8EE81AA30F10C0ADB343D74CF72C4DFF71550C12873AF89FA1874D4731C996243C3749AF3F6188FFE9FA45430549045134EB29EF3CEC37E72904AA082B1C6161E6B52361E49AF4933A8D8C0734F21CAFD7467B0C02876F43211D6122E3E735FE36064DF7A0C91449237C2BC7C3A78AC7BB0F9567F2576F05802C872ADF183A87AA3B8217188F2F3535F877724F35B29E545DE4BCF258F13BBC7EDD8C6587F733C9691F74B4151CF8C060C3AE9E8D49FE7C77BF477DC9F23FD0F0B67320275529034B84F94176730923C03AA50F9584D9C2D60B8DCCF85A13F243F30A51ABEFBBF2CDA602BF3D75E849EB92422B808416C7E56B046CE38E4677AD24D23D7237A9 +pk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sk = DC9F40CABE2E8E4F3D1538FBC1ADA27B61B99081455AB0C4C41B5B3DA81010007C91B5BAAB3E6DE7 +smlen = 1228 +sm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count = 8 +seed = 9B42F41492530EAC81992F17613EFDF155F407D7E67F18AE193EDCE714D65D1031E7AD10839AAB46D0850EAF5997AB4D +mlen = 297 +msg = 9366ED7B3B623C411448B634446F1A3FAABDD163A6CC1E2BCAE4A98703CD8CEE441405892FBA051BE2A586A6950A5EF73A255E5F86B0D7212E0C51C3BC79BE4B88E76ED6F043FEF3204FAF044BFB1ED722D61EB5D0B74C66A257E8AC3A2206273C80D2EC2123A4DBB715D60118D99ED7322E38F1562F82379138DA3DDB8BAA7CE61AB729AFC3748C0134633CF45A9973C05C75D04E82F631845427626B5799DC07DDF830BA01E8BC6236BB6D03B37D949DBB29EEC7DFE60FBC17EA590956D251539792016E2A8B01E70476961BC9ADA43CDA682D0CAA4FCC58810BBA1A673EF8F6BC90BAEE701E8E4F7C04A346CA56C7B2862FF57756CE6CD1EE22D677BCDAA896EAE96F87870E032C18B6C6A0C1A191FAE2ED487CE55296CC4B6339EAC9E8A742BD0A44C3525CC750 +pk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sk = 1DADE637AE98C393260F5BBBE288373100DD7AF37EBA913C528D2B7B998767CB5A71A4A716DA094C +smlen = 1261 +sm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count = 9 +seed = 11134936880F5A11ED3504CF7B273E55A351FCCB10943BBBD186623EE6C7A13A6565C3080D1F536BFDB018F99C4E46CD +mlen = 330 +msg = 0998114C84F84080E7EEBB47D248980FAC9D28F1ABB6DBAB3DD59A5CFD2C7CFF7F308372874DD5447C7B02E30165501C0C673128E4C543A414222BDF47E7F4E8DCA757B0F4A3281C0D10C4F02AB52AAF5B9A715E012607BA310947A60A5F62D6B8CFA96386D27CFA709189202421C078934AA2D955468E550AD4D0D4ACDD98B168A9568E232192E92789830317FBC959087FFFE353B6C168F3EFBE7164444F1D6CBA5246E31658C65440A841DBA78257E78502843EC1A6E9710229C8EEB85D6CDDC7D543285624AA1F756A5DD4F1A5D4FA52DB8C5C34880ED448FBB6D254509FBEEA0FA022F276B6A66BEF7ABFEA6049FF74291BABE781F718683397077B29FA9E2B46BC6B09251E587CC5B182195DD4060CC4A319BFBE251A5B660A739DFE5D0E5B93F3CB7E440194F1C8BDA922CB1A3EE3D27EDFD61C1D31A7F4534E84889EC83B51F1641892766434 +pk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sk = 8866693CEE12B909E32A0C64381796633666417E1246B51A2643564B464B41132869FE5A9BA6CF27 +smlen = 1294 +sm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count = 10 +seed = 98DDA6B97E89A479D5EE214E660DD6B5D8F6CC638A1CD4F462A0EC545F5B0B0A1A403AADF566F7B1C0C5FFCA29B36FCB +mlen = 363 +msg = 4CCA95CB9F254C2EAA7DCFFEF662EE03320D5FC626A6484304BF62FC20F341FBE26E1537D7BD20E95440F7CC95EE84E1297C807A0BC9006DFCD5C22A5C1FC0865F5D70E5D63AD677FFFDEA52BF85D1A4F159F7ED16A745B4D971B620048B5F518EB2DC672CA35022578059E1ADAD7C07FE910A5D566B8321D9A12F34C250BE35CE964DDDEA23C90EA77C9C1BBE3532FEEFDA3637157786EC7D37775AE5CB0BB92EAB45A0FB1E833E8A6F3D06B85946E31A79B64A02B31FA640ED514A85882C89F693A06354DFDDB0B5E23E7792134C69C1D3908882DF3A7694A05B241B87FB2DBD1A4D9F26943B69F3CDF730301663089D1EBFC23299DA21300F735CEDF7B109F3E0BBE273776E6AAFA7054A6CD9682B967EB7903DE549E9558E62DCF3AC444DD7042FEA362EFB555BB97FB464AD7FAEABA3197C14A6740477DB50CE3FB8B762F48F880381D510FCC836E5880B48F08BD6333202E838AB73F2E106CFBFB218AAB802DA8A00F13F78FFB70C +pk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sk = D6DAD5B2746422F4487B72536D70DF88AF4B2F9040AA45999F8D7784EF696DA0D4C0F4A9E14D52AC +smlen = 1327 +sm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count = 11 +seed = D34A0AAD27ECAD31A5E08E9A2D7901A9B85F864D9B1B46F40CDCA0B3615B2CBA04EF82AD7BD8CF627C3E861477030BE2 +mlen = 396 +msg = 5C4B2E1A344DA1418B0F4BE3FD99505FC30F2A1E5B696E943BEE2451D7B268F722E04F8E00FDD9E1A470F8C977A6D45A5F621B8815E352FA14F64977D1FA08082A48AF495719EA6AC1C0B3D898603B4CF7EC88E68DD7190884382896D953D612CC21ABECFB01A04A1BB1BBE8986D34625756396CCD84BD1A6B5454DDA98824CD4844D98F356AB485EEB19F9196ABB1C3088C0C3C5846C88760B696D91A232D6F4CFFC85BFF33DE1A3433A27A209A461FCF37F2289F98BEA7CCF183DB1FC42A7EDF958E7913F8711DC375E43F09BE7C7A2C2B1318AE2A9CF5988FBC2CE0735A2CD9FB6C8496C34406C538C01BD494193240BFF947FED47B7CCE99A1747973F1FAA5223AC564BBA0CA8973D1310B5BFA1452CACE9110BC22A8D4080A8BAAA8ADFA3CFB6685679B648484E3A43F9B1B2531949BBB8FAE1846F6D45D9272FC2CAA2913B5D9F8D322E9B18A685122D74634C60730C101578BEF2480711FEFFE02123E76D6C846559E2EA99A98923EF095630102A5573EF027E0AB6E52555A9EDE0D15A73C8B2FEF87CA6FD9F903F0 +pk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sk = 68E7818F33B97BA6166768C395BD010CEF7BCE9995891D164303B53C1123A991B083F8CD4CD6A9EB +smlen = 1360 +sm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count = 12 +seed = 4FDA9FB6929E3F391901D69FA0AA2F25A9657D249A620F1B9E305A5965676BA76794CAD3355EB632579C3958CA7D443D +mlen = 429 +msg = 49755A7B1A7CDC5C9BDF5149968061D3C95EE67BFBAF02750C45094303A9D9CD23A08F19B9C768ADC63FFD1527186D09CA4E0356BB882E263BF015CBE3716C05B31A69DDDB790BA82C341AC9B6BE68A81B8BEF8D882304BAF0020D761A0DB04412033DC369961A5213B04E81736A580F1162780599CC029E262D67F31B2773AFB457A1ADAAA292163144F17DE384234F3303111FCD89BCB30333C6C6486F775ED099043C34E6C86450B650F1A02D03781B1D20691B767D166DADF1DCC4D8604D976EFDC9168373A7316DDA9B9FB02A4A321218D9F54E287B7167A08BC0153843BD6355AEA1310824DD5D5EC458BE694AF176119D9E588A29C650FF5500293659EA478B39A62149F819CDB7E7CB32E1D7B1284F159E2AB1B1EA41AF4D0AC94FF3111FC1CCD818F9B2CC7A259701405FDF6A51D2D3EF62789297BD16A659F14968EF902C4A23DA409BF13A4913467B5C991854B2CA6CC006D3F4197A6AA58BD5DD95C36928DA9583332C3FB134FA3890FE7E299F1C17205366C4F4230724C43E4803912E72B816658BBB1B63780865A1F66A2A49B96E93711B1BE97B827D12173402828B1A065B94310D5BD6098D +pk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sk = 35B153A7706109D4A13D7C4B26AA5B56D9E3FAC53B47E91B0C10BD4E0EAAFC192EFF9575979B498C +smlen = 1393 +sm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count = 13 +seed = B0E6A23FAB10A7A333E3720BE00D31507917F39C5EFE1C98CA18BEB5C3101FB4479B478A1558C4C00398C55C9822FC44 +mlen = 462 +msg = 439529DF1864297E33956AFEE00A60099B658A67830A6A6ABDDC329E87831D9F9B647917FEDF1AE182A40402143285516FCAB83F447354C72FAE81AC26E7005C2AA561763C152E66BD80F14565F47DEFA440DBB491E7994AB9FE35995D5FBB3800CA030B43DF611141637A5246AB9D9CAC02EFE14AF60736B6BDB2BABB97CF21E831E5D04D41C00F090B154977900EFADD3A9313389A3F84CB3AC38E8B57B70A43DD08A8243F8154013FD5CF29DE5A8DF0B197C12B17E0610FCFE3625CC94067E01E23D23A243AD1C1F805CC50E1447D1DF93C25B8D76396BB7199E64129522462C5FC8B30C132D4EE9E0BF6F52961FCE7ECF650647E7064AA5A6574649A323E144D7C5491DE4C0A1A76D08F93F87A2FC7F6955FEF86991E62E2CB42908E83B0C0A8BC180B7453CED293F1E20F300431EC1D395E8A537F0BC36A673D491F14381DEA90D8F176D06031B0A7AFB40EA8F76D37FA82E2572B9799A5FC7CF4C49BC20AD78EFA8CD989A84D72ED680AC3C0F64155C56ACBFD7C7D628B418A489F961357F77BD62204ADB079DD3106485A37FEE535C9CF82E832D8AADCBF686976B806B02AE733DB46DB0BF162E973931C3E338CC86DB38C66262D1B2EBC7691B8281E0B20BF36305FBA996D20ECFDC695 +pk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sk = 0E1A1634FB2396E187CD8980EF29663C42DC3EF963CCD491F817A84283A11FA0D7EB14C77D536464 +smlen = 1426 +sm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count = 14 +seed = 0A98A2BD2B9FF42CFC18D3396BAD052E1D0F3372854DA69A318B142F7A1AAC609C3861263BD8FB0549DA7266784DB8B4 +mlen = 495 +msg = 8CB18850E27D8416B88A9A71F4A66BDF447814DB6C82098C371B53F61600EF5DFD88E4FB34200207C3F6F55166AF4878D38FCA7E2DC18FE662E3EA491B58A86246CAE16090FB7ADA53B9A67B3D0E3787D3323EA921274C60CFFB19A889BCF0300FE10E242AAE025F374DD83FBE9D007C8B9D9D75574C74146331DDEC6F0E49C10DBAF15654897E33E2B4780DBA484224AA6FAC79015D5792FAA2D532BB7D239B11D91420B98690B1FBDE9632223927E0804BFB284368A426C414C3DB8EA82F0D246413861475ED2DCA9E80FB4F3C34FEF7528069AE1975AFC52AC5AD2CDBCA1459E140F655556093210D7905A1A1E6CEEAEF0194A0B2EAB2C1EE853484E715D2A1DB551FDC620D5331164C74CA4848B61D408D2F2A943FA09EFEB63D524691C99DCC0B22CC61B98E6FB8039E5E0B2D7DE2CAAA900A44184BD56C9F02141A3AE8AFC661E3E898ECD3004FDB0704272BA780CD5DE35153B6FE223843024273642DCF8E4B58BE2AB1F61668680084AA0B75A32E766C8AE5EB30D4E02A12E6798DEA40F80D8DDFAD2041A52922701C689F46F49F84CFC05ECA6D7D4C356D50B6A0BA61966245D45134D6A1F5197540A1C39C36BB0B78831AF3F5156E669FD9213B64E0CF1C5A31E88AE79AD61757EC67B551B9F0A760F646BF81F6B92403A62840CC29FA4F3949B3A9F0A9A4286EE7808A +pk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sk = B0BFA060F1C1A70F1AC55E321E6186A6613605DD732574B5FE6E14F0FF6F7A8269E424D352D3BF6C +smlen = 1459 +sm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count = 15 +seed = 9887F1FD854241A301EE0120645CD8E119B43F7BEE11F77A835E9ADF518C3A51CB76D86653FBE73AA716264C146797EE +mlen = 528 +msg = 9B64813C058F07A09A796FD764604EAF58CE144363702896DF0AB5FF26D5DE000D14BB8FD358FF5532D3B909AB62C18AC30F1900F84EBD3F4F18BD532D16C7B3470F0F8BDF72938C916DB18BCF1429DC1635B1C152C5F89A9EDB17116C11815A6C06273A889132923DA908FF39F4940A840D3CB575DC4D637AAFD37968EC61FC4EA04B4C320491A73ECFBDD8E10F1DFE902FCCEF93DD287ED872F67146BB8CA5A6ADCF0350E8BBA7F2F9762C4AA748FCE19748EB17334146C152FD63FAE3DFBB1A2C2B3C78960369551FDAC5D54643BEEAA59C1FEB0C21DBBB19977D848CD82A7AE0005F45956E0FE4700F14FBAA0C12FB8C65A6AEC95C5A5C8E79A6DA9C4E446872575C06AE49A31B82245E1757C7CE84D6D5DF3F642D3434B7E1A15A8B8A9DB460826B6CDCA69022DBF87595B582DDBB90A81E09A13C2AB1C125E4435FF30ABC9C56A00EDFA979F79D9C895E800D2DD6372FAE5FAACD83ADF8A6D55279D52DF547E9BAB39D99076AD7D297371344D35BD584E0FB5932F92FD5183B9250CD180FC645BEF6028C405B0EF35DAF783428173F1F2482AA1363640F66AF0FE8ECACC0DAB84ABD2A1FB53AF44445698CF1DDF4C2EA214DD339BE004E75BF76E95CA5C16981ABA5540689C1C1F1DAF4D0F89D62CCB3496340D61E7D5F5156FD3EDD02EDFEC8FCDD0B231697B0E66F4A3AAF46117532F5EE2CB4D2B3B82B0BEAE0A45A482CE9A976CC99AA82BEB0FE08CB68C4 +pk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sk = A33BC0A7A08C13C0D4C1174DDD886AAC4C5666E1F4831F006C9519D36B2CE8826FEC9694C13BBD77 +smlen = 1492 +sm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count = 16 +seed = 5B485527C3B9A5E5B7579950049CD357975D4BCFEF83FE33C087ACBFCC10A0BE4225E7F8A5F77203B5FC7C0B5FC0E78B +mlen = 561 +msg = 922320F7439E492F13C272A5738FF7122DD7A6B2832632E1F7A653FEF3B8639BCB9E84F482F22A948EA17DDE6958489593D2CB268BB52DF8ED612F2317BD6847D1622CF0532CB499ADC432233B93B6F7B1866B38975AC87859AC49F91E8D235846775F9E6E6D052339C741EF6178016EDB3D0B1E3F3536667B3EA2D489F88D254B8582421A31461374F465D7AD62E896BE0857134707A70477FABC09FE0A5CC3B3F32911F5FF3806B878205525AF69007F50535DF05C33AF3B0D00E297AC7EAA012E1D863DD5DD5FA47FB09467DBAD8BC42EDBAB42A9625BFDB9FE578343297506A3B71CDC8D5919955AF4605FCB0C7164D96A187AFF65D0F6210FEF2D11BA08D90C4458542BE72E084577BE9E451B8B6F4909884BCC5D25316ADCCD0925664D4D91C2E56433C1B68C632B0CA56D856DF1EDD5E113D1F026B30DAC4FD648A504F8F6809C701C97BCAC2B99286CEF5C1C923200B1BF6141EE1CFC51C5E14554BC02D7E058970254D2C02948360ABC4DFB439E66946A8AD615147BD8A6CB0886211E8B15DFF3C72B6F8908CE56BBC1B40E838103202E9F188D98E07555DB61778F895F76FBD838B6D14209D28EB393668924AC0E61072CBD9F93B864904FF4302DCEA131B2CA16BB04959ACEE096B1963CE07F59AB505FCC8D89FE08FC58751965F2F5CA753D76D58705652D3B1505E0F720EDE3142DE9776FFE4AA0C8A25E76C7A04843377C59F1002844E89189E22F621467B813A98BF07540A1649264F14A6844D65692617F7A4D93FA9A23829E256626 +pk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sk = C7E33FA5329142B668CCDDE1057EB7A8619397537F2B4C6D6755B3B9FF936441037AD0EEE026ED63 +smlen = 1525 +sm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count = 17 +seed = 327CE565CFF6CD9A25EDD84F482FA0758B78CBC246567DAE98B818314AE28CD438E339043EB3FF16E1C2B4B104A717B8 +mlen = 594 +msg = 576289D10AB03D5699EAC322D349F55C547101E4424BFA43BBBA3747B79F075AE1153A7A0AC8BB51D24FC46B7604E42EFE4343FA34AA4EB16D918F25E8A4D67C860CCA3F7480E1221ED3AE13A138F079FC252C6D7BEBC55CB81B86E74F339614BEBCF7E8F4440DF8678B01A4A41B3AFB1D112FE1C4C8D8C6BFE9D3EE2A335D477C60FBF43B2E5FFFE1546F5172EF51CFFB2A772E1575EAC79B24D49FD77F0BE351233E57EE6DCC7E2E29994873ABD434D34ACE83400C026E27E27888EA0BDD1BDE5A3E55AA8B5F2FEB57B8B0A96CD831906297C8169D04F15843A3249C50523CF56A4E19492EA16927DBA8759B88A99E0D20820E51FC9B6A6863115CF05C5BC3F4C869EB5A87124DF5DB102D737F3899CFAA5FEA4DD62DC4FEDB1AAFF67906ADAF8968020EFA5B10190F70E5F2C0F0457E4341BD449201D3A80AEB791254EC1C46DDCEBC3896C6DF702509BA62CD446D275806438EB4C03132B2E6BD01BD2F832D1D3C053C48C5A9DB1C4A22B130C4C9E96A2BF4C2A8F7DE0217A52D9AA5AEEE5E6A49708237EAB60B4019A51390C3EF10572A73D436875BB8D7D78543F96376E4BF3BCAABB92F89215E8D1093F3B287945708B5514BD7E62654D3BDF34B29009C64829A0CBF33C54D7AB0E81B81BDDA93028B341AB1DFF3D752DC4A1E5F9636A5C46E137EA35919D99E6571C5370C6E804BD2E2ABF566F035D65CF8F97E3E8F2ECAFA153BC6D8EC2831667A37FC96D1C2DA40BA84D0FB041DEF32AADAEF3F98CAFA957F6552F79D28A36B8BA20A9452671DE1BE8AF5D66714232507EDB9FF657F3D7E5FA7320FC0359A5F99280D446283BC +pk = CA84EAE99E11954C43315B855365FF337C7FBAD67D853003F20D10C07A6F4693DADD138B4923E7A30F83B364FA778E5B825DE880D5AA5AC426FB279C5F906287FCDB59A52347B21B3D924ED90B7431EB05C911D5F429CE73CA8564FCDEDD458A0636D9256B4D11AE8B257EFDA57A6E05E48A5ED7947A8F34D1C8671D9F19C1C20D19082DFE505D01CBA159445A8A7B3BC71C6557886AA6673639D1C7FAA74D1478CED48BE7664BB0A24586EB79732EB268F971BB0FF72334D5367CC840CBA2A51D11C05211CE952AB1FAF95AD5686DD199BA8557DC13E905D467D52903A283D63538B506485CEEF5B44F12B03985D34C234E6FF52D2FE698BD5B8B8312216994B29DB1643F637B5B3A94417C923FA4DA76BA71855EF9CF0D30C44AB135FE6BCA0E7C889F2D9295AE9EB897B6DD0D84BC5AA0677617996AC6771C7E644380D21A6D57811BD434C38145E62A9E46F4F2556C789479F1850C9EFC00554955EC8B5E9E3F39BB7A6D7F090678084CA371DF371F765A57017809E05F247B2288DFA0AB589B3ED7675BD232C0B7889A3C7946C45CC1E77B1510EB4C19A8C27AF9105599FB015C2FCE0DD2F97B5056DF2B02316657670BE1ADFFA97F4F484BFD26D12735E45F5D08A61BECC83CACD8E06688FECEA2C71BC0BCCFA0046BCF7E97B039BE2DEDCFEB6428C81CCCA941EF9E7461B07E3BCE5F4DD98B42FD988AEB871F4D922BE267F5AE594CABDC205A47166B7A09CB0E8ECA937B4BE32A94C35F80CE57771EAEF2408C9DEA5C4AFDFBC6A0DE9497F256CE51FE0BF945DC8433E28263BD355CC84D7CDB38A57F97433090B11EE006CDB1008F5C2457BE28FA8E7566FA8E8E081FCE0D8CDE5AF761F314139387EBBDB1511D24E4A8D2BDDC8BD07E76820364F57AF027AE6842ED2C9BE74F7F9459B43ECD00E5490E78EF8769026B22C04805DBBF8139949FF16A74E1619D386FF3FF4FD1AB106F099E00426D95DAEB4834FE765A41B4AB624AE5040000F1DB94C2EB16AEEBE8A32E2D4F1F2C65DCBA2A6D70F2C31FED8CB5FC7D176BDC87D9CE5476B68029FB5EA5C5FB9482F55DFE31DB496F15EE02950DAF828C5DE47767D4BC813F89E884A726CEF64A29E160C2FA28B3119E764A0260A13605D25E68F14614B9C2C5AB807C68D2818D367A227BFC2281F987A422433F76414C303D002482F0DA95C04E6997108CB6867663499F8DD6C96EFD54B41B42E271F70B84B9E0E3679286C101DB52E864F92BA73485355FDCFFEF9E39FEEBC1D41FA9838597E445B24A82BAA60E25F3C9085DE7011AC25EE9BF72518DFD0999C8ECDFB67BF34B0A69D6506D730BDEE3ECF573FC2999E34C08AB74EEC5A37165CB60A6BE510D109DAD8FF15A09F884396F5AACB344DA2618FFFD8E0340E4D55FE83FC367DF88FE3C539DE9D29E9D166759397CA8D3AC1A702A321867BB2CD8D8E73128F7C6316565421EF8D522564413935B92C5A9CDF71B285944B9A5EE36F760F752089286504F04AD8130699485415BB6092D062503C9266EE6A7B067000347B0571ACE9B9B6A4491834F4E2D2DD6CCB9F5129CA66ABA1FF81E64DE00FB9FA70C8CF80EE58F776FC945FBD341BA4D7E45ECC88E7F2A3C5787A0BFAFD1345220B3C31F0135D9A824DB5CDACEF5A91E8BC37510798F93F8F4C0D14635BBEE8C65134F1C103587DAF1A05E291F9B28CDD20F5C5CEB1EE245B2AE8ECDB63F27708F871C220FD9ADCB4785838C59BD70843FFA3CCA3C6D89DA38781F4DD46C8015D0581320C32C2047E1D6BB1DE54B2F593F9CF1F7C4D9FEEEBE707A3F52317FA9F68A56263A1E5937DADCE5A98483BC0C7AA0CA32EDC3A13736845CD080FCC1A924144235A3EBFDE56F2BB7ECE702D03C12CE7FEC6F9C957B3F5F3AD4C5EBE8D808DB487060D1E63EDDB25980DE0C108002C608A3D0AAE7274D13ECEACC7C0BB992815D0539E6EA3D68F5725362510D0DB30A31E0DFBD8F82DADD3366F32546EE48D567F417701A1B11F2829F3A9B4904E83A93B5BDB0BF4E083CF001918BC8B1F194EDB49A6846C2E73C02F38C1E8FE813A9281B757A5C3133259003C2CA6B47C23E1B8481A97F0DC40C2DCCD52B2E78DAC6A38C81928B7F0E99B49CD2444F9B88073EF8CC0BF3CA53B45DC7676165AA55ECFDC6683BE1DD47FA9A46D817A059AB228994C9D1729FA157FAB76953BECA7118C4E892DF81475B1149D75F422DEE129239822BF1ACC29672A499563EBFC1EC64D7FE4806D36F8E132180FC97890C9655484E0821327CD78C8CC3ECB029D5A953F8F59C59D6527820EF2E599FC731C491DC31B553E7DA91626825FA195CC1E883185D499F6FECA22FE2E9BCE0E3EDCB57A7571A59DA79B3D9185AFD567AA964B31A2DD28C5B42B54574A548E8F940CD02726ECA554322F7E04DC18CD895C1237BBF36F8CED5DA7A41B57BEA99FACDF9A75F4E2FF105848EC097DF0BA6D599FCE8D5219C0E3CBB5AFE3FA5CB5586F48EF8B3C5F52FB6641E20D574FF14C7D86CEF730BFE0FFAAA0C3F09127AE5DC0FA0616E03F5CFBD03F6A982A8257F8822F1F3E4269BC0E98627F2E31DFF10105E0DBDF451677A85F4A5E7B640A6C54DB1ABCB60F658AEF447E03820C37CF736B56E543CBF7A008792B921281073B64219B769F0EF69ADD8A6ED9D06689E18A4A5FAF2DB3BD382B696C16CEF18D0265D0A418ADFEB83D53C45B166413A401DE918EA68322A97C6E66287DC6C098CBCAA05B831F3B4666FF1CDB24DAAAE181DD1A58DDD562F7FE15E2146FAE985F1037CE24146A55BCE376CD655786A1673D2B620D2EC4237AC5182B24634EA75427C45DF0C3AA364EE88F41F41E7D4D3165D31496FF7562A00FBE6BC52300A6470422C85C06D12CE095329DD791DD250402AF834AB449E1F3CC2A93BAFC5DD5296B06108CC102E52DFCFA7E76F4DA41CDD867694C8B8050ED0FE7EEC4BFF8588476213AFDE379F027574CDF150A82C75373D6F0440BCD1D751F2992A5FD87C35076C81E7CF95D701ED1AE3206341A4313B4B819F6EF1D9D504890E7430D452E4A0AECFFDA6EBD2145D1126B339B63A4FC48B27CFB0549684383F3BC735FB38EE1C1DD57C51F64B227B6900E7B0966A2DBEBECC90AE8E903A24AD16C19D6D82118E4D693391760D94AF445CDD775641BEC1D71C1447A77F62165963F7A8D28BA0785B3BCE9C7171EDF1EB39426318F231CDBEB48699AD81BD8ABAA22C5F89E1F76FAE97E51D6625D2650988E205D83F4F6FEBC22F05E4CD1AE98E5A8887D06DEAD8A542CF371E7E5390D24C6806E6D881102125000CB9C3183A58579FC8429041F92A26F0C89E3AAE8A4F541E92C874C402661E909CEE38EE611DDD8847E4640C76D80AA5DD3BACA54D1BA017A249A7F921FFD76F410B234F5B2E94A435A3387F2121FD92521381F7B8D598EFE26FBDFAB519D5C3243DE42EC6C8343483423EC04C4ABA23FBA04F5A6B68D2EB34E7058CC8EEEEDA004CDDF6AE0F42724EE3AE39D7D64CC5A1850837F7CF58FD0AC6C52CBC6231FFEBC5697B2352C39C6F25CF1A7ACB8E08CE4FBA34F8E0A1A661C7FDEBF7A5D4CC606B1DE3088DA0CF8C5BABEE267FC7EDE3F3F879F82C013B05E1D457B4D432905B6599695D12DF3DA78D9C595E8D812C0CB833A69D261FEBA7D5095C79C46764A4F33F3D0D8203FA067E9B7BDEBB3A70DD0128FD3455291366D1C387DBE6E0C29D44AB79DE2A2A0B1E25F9B515D845F2720FEE50C3CDA71B28F33E7E7CE81B811E20893CC38375750A48B53BA871974B6EE8C4EF593EDD5A75DFF1B6274AD2D7DEEF48827F31B7851F11B039C5DDDAA29989957B5F23E0B6163EED7463F1A639421887F467D8913162290F477B590ED2A76DA9BFEA5565091B94D7F50A2E29356581753482E02575C230D1E63146B63F53F2639B6B55B3A1AF1298E16889F673385176BA8CEA44DCA8DED9DFF4F2ADF6F0A5CE620DDB16527156AEB0DCD416895FE239C2987942ECF412E4D0BB5B88E67999885C08134B2E3C2EC71D16D06A02CBA9406D3F46098EB3B9C9B5E6EEA62D053A4B1A291AC45287EB2B22DC28AD157D69E7CBE908559CAF9AF25FD8A187B8A031063415962E28F471EAA63D7205CB583718FC204543952BA16CB74EB80811FDF09C46DA3351477F7FB94E148FEF2D5FE1399A38D42D983CE29C3979127E21F2F9AE5CCA547CC39DAB9AA34A01176E625ABBE3DE7EE5F52B8D69F1E29736352933F00511D9D13EFD4C7F2E7D613FB33E9BDEC93E3FF1A32A9E2B34D837CFC0F784735F84B7769E66E66E169C90B14D51E8B36F381E3D1221F014FEA6B53E5764E2ABCC8F459A335856CC4207FEA72F43BE6AE8785B53AF827EBB97AA50078FEC6A2A07AA91FD3C381D795E223652161790E22653A99D8F3F89E59B7DB9D373AF59188DEB538FC7CAA7521DAA278F54C5FF0CD8D4679EC219382973EF3B9045D845E08C179C26A88376D9FD71E3908E2E9F9EDE35A375A8F9724280A3AAFFAD747C5B8427E227EF18E57C04D7BE6B703957A978AF1E972ACC54E1804AC36DFA84D66471E5B3CD60AC32398627584F47B1E7C10447F710C1BF39A9DCECF15993DAD19E8672658DF054F9BEF2CBA6281071D45E0567DC8897C0C38F1306A4CB465931062781CE83C177D49A8D8882AC06BA51091324528091030503E1841EA44D62CDB777AFFA3FA31043A0467FA8C39E072F31831BCF2414E979A5A7186D50B6DCE813C90CCE04F2C786226D74E53DF56F6DBCAE88165D2B0F762938D70410AC75AAD04326B80BBD3481EF3841BADD295078B42CCEAE5DC4B3820CCA8C6169FA1D65529B1130C6E520BF7E20D253844E432F77F4AD98ECE87FDFE2F498788F2F97810836926436F9F6846B0AED1FA0861BF9FAFF8D561B0B6313B9DA750B8BAAF7F78B3EDC7D4E323B3D487C97D36DC2A0B13B8F3EF722C2FB1947B15FCE3046D55A126A3AB0FFEC890E6D54AC12AA6B2166EA10694E68CDAF4A72E5764805CD8E450F9BEA65EF73CF9F6B28D88C46038B51A4001E892B1327431F8A08D4E23DE333F0B2D03E0F9F02A5D89E6613190A438488CDB596CBDBA2062C1285426FC3225C4CA908C46D3C593B26AC3A88A1C0827C08916C8FD38583E08D2AAE28DE3937E61DE4697DA5133E06F6322FD182259326D030C38B6235C5BB6167469732E976556190DAF3E7BF29BDA1940A07333999EB9EF8C64D47C569D5E5CF346B38ACD4508EA3CEA7B2ABA1D08397FB38973A1287400D06138050B8BDAAA04DC3228CDB4949B15893C7C75F643517095892246E2DBAC052FB6E19EB19DD91A0EEF61496503330BCA3A2C140114C0C23C3A6C0C6782A37ABC2CDD5D57C2BDB74DFDA827EC4C1A6269F2FEAD4672019B61AF373FF1BF0EAA2B2315128EAE8E641770CE2ED051FF55C9A48D66CA2DB15411CDD5289DBB1A8ECFA1E96507D186C5F56D0191E6F8D79EB0D5A03B22B4BF357AB2FAE3F67A6E93AEDACD8A75DDFE8671EE764EE32068F9C10CF86CAB3A4ADE14BA42A8E1A0D2321068BBEBB6D258ED1DDE393226367560AE851701C8AA76A70D6480B87F3A680C60EBE49A1C1534754108B5E2EB44185516E401CB61E2702AE197B1EB6E260068F13624E3888111C3F8034A8A3E8898C557F13D7B48F3296289E19BE3A1C92722DE7A585CA91B65F75B11258D9C04421F3379CDA8D950913405353040F4BF350EEC2AFD34036DB54C48CF3A1229EE51177A26D8215F2FEB83B6A2B8F8BE10B3B2FC4554D3176E6E01F37C56868E3CBCAC870CCD892EA5CA7A31469C85FC9D6A57726DA541204C66873011FA2B51D9D4724CA0EFC984B49795990AB21F138D14C0D34919624FF29AA84AF0972D6B4241C79B179F2C7758D8D8B79249F2F11F63D3829C1F95D5C15B4BF4A812DEF4ED589F6263016BD7F0F45C49907C136D81BE7C1591FF2806279C0A9A930B6BF0E018977FD8650F9B84416FC0B1C04BA240B252B113BEF2219C509A0DB8DAFD9AD14CE6E40EAA5D128D78C74764A471A2E9B3C59E464108ED3AA395D22D768DD1E8D9BB749952C6E1E7CC1F95A986DBFA4AE3D88FC11B725A7D4D4347F55232CB4C4A78D50539660FC1DE2B9318E1E31061163090CBDAE829FC5177133A735F9EAD4CBFB99D85C754DF985419A3F7856809C9BED159950D03FEDABE72C2D9691BFC0B590486257761527CE011C5D85F7CA2A6AEFCD651CD353A54E523CFDA55A79A590F7B36FEE0282B00F4D9F60092D56F50C080CBBD809391A360A27F53C8630E14AD09E68D015F9E9AF2757359BDAEDF4BB62C21C2E2FEA24360CFBDAAE34DB14C0E8534E757C928EBCCD9709C8A4207267FDE9230BBEA1D3EA79D226728AB14DCF9460BD737E2599AB136ED78BB43DA78CBD7F7F40E0AFA7B7EFE090E99B2597AB9F547E5AE4BDB86E3E5EE942095EDB31A44A79E85BDD936229FC03783C904D0DBF5970F4F638755E0744799224F173E58858726869AE96DC9460EA4605010E35853EC593FBC5FEAB534CA15F7FC7353E62A7093CFFE865835A82F8C428278EABB5AB2D9885888149D6FAD61E1F420D4E83D15BF816C58D76A8DFCFB74BF1C13446D7DE4E89F7AE0A2B2F18AAB9B4ADA4DE50B103CF94E74C031CCC4ED222BC9A45018B527B17C79F6E4706F99E0029A6F525BD9CE0CF039E389AC383667ED3387A99FF1D4BE0D050B56A9BAA60EE3E85BCDFFA5B73FB1A24F8EAE5AB9605D2095C037E5CA846F9AE907BC74ED47409453EEBAC6843F9455D84D225829A9A476C66B989149AD07B820C61CB63E03C30BF68D68E02EFC90ED2CC9BEB168BDFE830344D5C2FFBC70958D9646D3515F20C0E4ED377F061EC00EB6C5096959AFF0D16EB28E44224758696624129153648C6754F0378B129785C6099B95A2345121855C749CC52AB13AF9D61137599DD1E38807FB5D08CD1D311C4E383D05581245BFFCE2B5575F2917C51316E2E106EF72FD001F37369634ED188704D77873A858E6BF19644719AA1A555429A0B56884E91FD7A9A8C54079DC5A12FD79546C0DBD602E4B05D87775621ACF629A04274A1DA1A78C9458B3A113AFE90C90743A2D9973000CC2461D6B7269DD470E1097F3520559B3B36F709E03A95BCC49E0AB327FA8A7935448BB1D8AC191916506F5345F69E3185F50054809A913CF94C38ABE2FDFCA5153D8C9B8521A86D09598A54DA34A0CC8EF46D174184E198910368423F4F6DCD7F0011D3E1F8A8262C6DA51CA3DF03156AF4DDC54B186CAF41C0224DBC880C83FCE91826F30F46D28D5E1174042B73B4E669E61FF58B1FDB1A096E8B7A1F7811B9000DA21A21039B34BDDC5EB5E1F0655CF0A72A0F44C0E80FC64823FC6446D2B123901F5688BA10FCEE61868409A7137BE7118C9BF672AA1C7E401AA91EE70FAFD84D7BF68113B76E0EB5071EE38B0EAA06328E2DA46894BC2844C961229448423D4ECB171BDF91E7266692804DAB36F7696CDBC504C12C1A753EDD078E8A792E58984D5703D6843EA7FDB7BEC0903AA23EDCC0619BB7969601D88A93BCF6744867AF4C3684BFB86FA1408C2BFE58B81EA45FADA5E3BED38CF9BC0DFC0D71985706D014FBE6C75AFE1D86DFFFB8E8192121C831A97286952E8310672CB57B09881127D6B66E0DF9D91004A6ABB2F31D337A0CBA4CC9638762C0167F11EE4F5EF027A0D0B644EC76F32D9BFC576FC652F52EEEDC052CD7F22A81E84B49A8A285F7084FA0F1CF3AE52C41772F8215A6DDCB10D41495AD5419DA35AF2BA2AB33F040641593DFF19621C6CCFBA99C9467C3D13CAF3523FBE3F46FBAAEE709A17F216C585EA9A09DC788F8AF2A33F3E590C5C62A637AAB6E00B6 +sk = 7611B5B7D4195D5F8B97244B6811748EFEA929EA272E66435A36D0BD16E3BF215BCBC73D669E35FE +smlen = 1558 +sm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count = 18 +seed = 790FC03F956D1301A735504075B67A05944A762E0A4BDA77BB8C036C5CF911E2B561EC1CA6AA355D5CEC919AED42A1D2 +mlen = 627 +msg = 021E9C06A2E4EF63D1A61958620C40016783879080D44311E04F2A446BCAEE5A486D17FF0F356BA70FF1C2B55BF957A59202903AE349878CB822E04275E0AFAABC0803BB6CDE3741E0BF9FCE0C5D5C814977474533DC63F9ED4F32AC3477A3EC9893EF55186728C85B03F4C2E61CA7733E1706766AEB8FEA80E233E8761B57FD5A3CEF700196674B34A3A55F68B3368B688FB1DDC976FF48BA6A98E2D66023F291A3C617A56CCBDB8732B8C34369ED11F4CCEA8FC8F673AD9FA0FD8990BEF70AF44C617FDFA096695D0C94EA8E17554F4461DC776DB2F416448B17680FE4D29B09E57603D8EBF55771AF84D8D4B9097302901C25CB6D73932E67C323D12C8ACB0E74CB89755F7EB3999D4EAB5E1B775E6B5C29D9733697030A26F3B93B3F286DB0F2DBDA71E1F103878063E77919D8892EB6A34F821B603ED4A898A9F30D00FEEF20985FEF1A7B7AF70DD29C269E88687F005D551EF05EB0603FD38745AED4F5BF4C2FC09F0604C98AE3A89E46BBFE907B87A1672DE547D651F035F392A8D4DB5E7260F43953028E312B95B9F25FFF2C0C579218390411D13D9A25F22DE4C7AA05FD11781DB08977160D48E02372C7D826F5CAC37D1A9B4230BE99A2D13CC2E9B2B17F0A1044EB9E0A2FBA376D35CDD2BC05F57DCE4BBC3BF07A09BCDE369929E6250EFDC61689466B040AEA376B09453A2C16813BBB685B54A225C49008BA6811E8BB5B3627F8C281244FDF5533216D126ED0E64FDABEC533424BFF77FE722CC438CA7587C19D965F0BF085D8692C27C5C84A9DEE53256D978948D89ABDF9842E0B765BE6A507D8630CBC5CA7FA0FBCA1CECC78D2E536AA7B2B902C4379777AC0920D69C57CC4E6032252BDE99E1A555E80D4 +pk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sk = 5A1E3E05C72CEF1A73EF98840DA035E4FD2552912DB8DAE28A79011DE4BBC1A4D8DEB96F5E518AA3 +smlen = 1591 +sm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count = 19 +seed = 716354F7DEAE272CD26929C0932CA257AED1DD23D67260726B5213D82E61466FA99BB6A7D81DEE9D0EBE03DEEE4DBFC7 +mlen = 660 +msg = 7BEDAFEBABBBFB863CE496475F54E69A905AFA45899C3D7C16CFC73E31597D2404AE7014612E4CBFA238EFAF5B396B0B7435ADA5DE817E013188C280423C68924E1FA2A33CA56E6B85B7CCA7F00D3A6151F0629C1B92A13573320E0025863BBA7F3EEB987EE1B1A6230B10765DFC1FEEA498AE4B83521188E7503B506259103CEFB370E3651B06DD4F08013FF3AB9E2430626B0BD584232948462D85C0F82DA07B96FC65F62A43CD2F132D1A1D691C085980DAD8796CCE2FA0B268395EAC3DA2CC400F30F75BE87316216980CE213B48651DDB9E294F8CDB2CA05D3F2A507E4A03E2849AA8062918AFB5BCE9E4C3ABF2FFD4751DDDCF08AB09E36A29B830F3BAC6FEEBEA084575472E6F4B239AF89965A72954769A83E391DE467934237B07D8884A6B14CAD034FBF9BD7531D50D742E234E227E1A2DAF77A2FFACC579525134B15186D81AE6E5538871024BD2897475D6EE5B11BC51EDBB928D98475073785A75B331BF3D2297165AE6CF95C3A05F06DF747498462054F58A5AC736F96014B1A8CDB319D030D06DAD9CAB2B913F35FC392E1FC4B027CDBE775D64B04F1076A7C8F44C360745F98E87B84C18AB76F84F373F635AF4C8A87DF08DD4507899BAD892FF8CC1EE534D3277B5B82095628B84A7D5582149CF46C50AA963B56B4B91966B106B4B2EAA45D83A10993E8F933370AB29C6606B7CCFC41B21C6B99F2B9AC643E24300B350FA199EC10E64E4AF19181F78E8C43B2FA796241DC42CC8992BDFCDC39E7BC41BE68CDCE4FBC47C996DB42E8249EEDC146C216B514430C705FC939B9EEF677AD87F9CEE3398551FA0DAF774302324A410F4A4F4FC035CFBE960B38C390441E92D9E5624A8745976BC88FA538E398712361B77AD4CA5FF038D9F6CE157EB8A6137420D4E57018275DCEEBC4E480A5D +pk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sk = 8F3920A235EEC3659CFCFE62931474204EAE264959702F901D461B66D9BB563D25E3F0DEF77E152D +smlen = 1624 +sm = 68A988C91068E92D24709B4742B289A7E38AAD9893D203F3E40A0A075DCB4D47AE31A1BFE6F108D87EEE195D3012701D05313112C5CB59DD550C63D93CF5242AF526936901D7C32638EFAEE963300C41AFD5C8B856153FEDD2EA3CEDE47837694A3ECF955816C7A9DDE47428379E98C839C5D31091CBD8756857925701DDF8E70A52249158984A965FBCA1519FBF2831C9D1AF4CDC02686797A491E4A556B21F122C422CD4438AD0297889D53B3DE2C957556943170DB31526F87264E7359A4E353D708A5A972DC75C8A282DDF6726171F0765FA22A5E267F624DCD2C5F57AFB4BC1ABF407CA7E65D080A5F6651F18B5C518A1A9A2BF22D2EE0FA39BA55018E0EB4D2195C63B5AABD9DDBA98ECC84F1A7E9D9D0CF9376168901A4E436102E2E418FCB008104435167D8CC44884BF733CD6037C9B7F2CA13AF905333D90F2D90F8E05FF5B2B46D547F698398D209438E3A6CDAC30D7D83CD646714FBEC820DCC12913DFA073668E451FC5A7B2D4C75A17921B308F8B93C10BFEDCCC6B0859F29A8E82A2DCF1A73FCC5700524583FF546A4CFC66890B18CAF6AE7B9D97C4278F5B2251321A58E7CC22AD38CEB074BC534AFDA0CF785AF26C4752D0C368C18CC91F25AE9040277008C27F1AA6759BEC33A5C51EB7A7B704E7640404325E1953166821DA05FA7A6BBEE3DBBF3F0488525BD6DC15DD766B3B146BE8B2470BA297EB149F7CEC011683DD2B579B2CFCC59879A655930D9CC243C84816F322D832041118F49C607BC80388C651DD9868C906B370FBB66269F864C80D0A0325525868ED567415BED711C988667B81E0C7B4EC24FB97B27F8012AC10126D0C50EA80F96B835DAF91D5BF41DB727EA83D7171CCA552E0737B1276DDAD97D93D2B01152F3257331652E03A7622523E992E64DFF072182488A7F61A11827E1ED987E38B8724E44D4D27210DC6DA854775C56ACB05EC1CB7197D868DB7A70774C2C806A2E06FD23CE6A5E572ACDCF81053322F4CE443025AEA7CC212A7F62AFDC525964A17C9D623AD1DF31786F34613BA9BE75B682F7564FB9F882B3C5ED159758A19BC61FEEF922EC7CD3EDCCDA22D573CBD988CDCFFD87733E4DCC69625DA3FC8AD54B60388F14032EA9EDA20708D3F14B0C9E17E5B9B2AE2EC975CE6B3F5DE9AB7DC4DEEFD8B02299E801FA27F8EBAA4C3D6554E8EA3A656BF7E2C67BD865FF73B3AB47883B56980FF796E634C6C2C0696683924CF127B1904309182B78B2C54E8A3CFD568DDDF6D86EF261C8EA83E9216B45E6AF98A34A48BAC5B14BD2609277C5F809BF74DDC5EA292CC1908E53DB424CA017139198E8562E11241CB6C8DC784A30C98A98DE482FA7BEDAFEBABBBFB863CE496475F54E69A905AFA45899C3D7C16CFC73E31597D2404AE7014612E4CBFA238EFAF5B396B0B7435ADA5DE817E013188C280423C68924E1FA2A33CA56E6B85B7CCA7F00D3A6151F0629C1B92A13573320E0025863BBA7F3EEB987EE1B1A6230B10765DFC1FEEA498AE4B83521188E7503B506259103CEFB370E3651B06DD4F08013FF3AB9E2430626B0BD584232948462D85C0F82DA07B96FC65F62A43CD2F132D1A1D691C085980DAD8796CCE2FA0B268395EAC3DA2CC400F30F75BE87316216980CE213B48651DDB9E294F8CDB2CA05D3F2A507E4A03E2849AA8062918AFB5BCE9E4C3ABF2FFD4751DDDCF08AB09E36A29B830F3BAC6FEEBEA084575472E6F4B239AF89965A72954769A83E391DE467934237B07D8884A6B14CAD034FBF9BD7531D50D742E234E227E1A2DAF77A2FFACC579525134B15186D81AE6E5538871024BD2897475D6EE5B11BC51EDBB928D98475073785A75B331BF3D2297165AE6CF95C3A05F06DF747498462054F58A5AC736F96014B1A8CDB319D030D06DAD9CAB2B913F35FC392E1FC4B027CDBE775D64B04F1076A7C8F44C360745F98E87B84C18AB76F84F373F635AF4C8A87DF08DD4507899BAD892FF8CC1EE534D3277B5B82095628B84A7D5582149CF46C50AA963B56B4B91966B106B4B2EAA45D83A10993E8F933370AB29C6606B7CCFC41B21C6B99F2B9AC643E24300B350FA199EC10E64E4AF19181F78E8C43B2FA796241DC42CC8992BDFCDC39E7BC41BE68CDCE4FBC47C996DB42E8249EEDC146C216B514430C705FC939B9EEF677AD87F9CEE3398551FA0DAF774302324A410F4A4F4FC035CFBE960B38C390441E92D9E5624A8745976BC88FA538E398712361B77AD4CA5FF038D9F6CE157EB8A6137420D4E57018275DCEEBC4E480A5D + +count = 20 +seed = A32E6FF879EC8866A5F5E4F6318DA8FE6743812ED2CF5FB94F5C3AA3EDF953CBC32665810B71B2CFEBF343A571CBC570 +mlen = 693 +msg = A86EE95388DF139F9C5A84108D1E63F7A7842909B818E9A0425C257649ABF125386FB5286031E7E6D0EEB85C452E254DA39BBDA51F0D2167EC0A51992753DDFA76874AA80804E705CF8BBADF3B82B6D7FBA3D1CAD130ABCC0B44D6D893356F3E94BF8E82AC532EF8C5E5F4200207BCF6B754F14E57A889FFB753F516EF8DE2A647FAD8E449264F0BBB4CF48BD01501736DA49509C3426A3D4108B98E6A4AA6C4430E8EE76540051FBD1DFBFC01750E26547F8718EF7D897A0342BB000FB99AA63B781C9A4B831DA798C014E58725E03D2F8B1A029C3337F4099239244AA320965B2CB5075052D901B6077A18C1ECFA5F272850A475B5F6BBC83F3C09A27072F80743B23EC6A9870913EE2805B4D296B2F81A9D733E5C8D5C0B477E51F9328AF3AF8ABED960408AFECD27FBDD08FEF50F4B07959646E0A02104A69674294A79DE0B25B65F4DBFA797E5FA56D66E8BC07D5E2E7C7D2E845699ACEA3BFAC60B2C0B988CBAB949A5B598D8E2F1AEC66196E115AD7F237A1C7FCFB95A1BBD6939A250E7BB0F4A02C23CB1BD81090CB770E3A70CB081D121BD0BD5ED1DC06D61282B98BF2DD7B13D2C6CF833891C67951D7D0F429EBDE3F1DA943ADB8AD285E6F13F798D6CD9A0A06BCD6125EBAA48F8F3BD5100A122F617817E3C42EBC3C3B154258FA26B9FD886EBFAD42DEDC6A2C4F9986BAD88A2A79D7EE603554E9CFC5FE33A3A171CF7BA94FD43228019B2F6FF96A8ABBC58D2098AD95A95442F6858EB69E131D7BCADAD81B9BB69D7682A978279B631E22927DECFFBEFBE8FB2E51D46A3FCA66225D30451CEF9953EF94F30B99F2B26EA75B84935EA4FB257DBE5734454B8087B3A4E115C6D31E72709303E9F0BB8C86FC6B11B93B53F9781BB92851A5CB5DC00D0B4E15683DBE4EDBE986966FE1F711F24DE9A0E1BEAEA8E835C70CDDC589773D31191B74AF780EB69867829ABED6D3FFA94D577 +pk = D525FF41A73504DE9FDB570188BC16BF64295A12F89F3A67C844848EA878C983B12C25FCD6608B9FC2A7EAC77F6A1940780E88E8F109D855F254E30EC6E023DAD93837A11CB183FB6FFC31D018C965DB5723431828EB413ED7653F814BF2978D330DF433CB32836FEFE2F5DEF6CDB90529B9608CA8F9FAD1F8B35F0155D2E57636E748FE9F22BF9F09F08150BE2B9A997B0AFCCEAEB9A1A170FB2B6EC4D905090FE69C9430F2FE8514BB944F8C75611523F18EC79192E5EEC707D6C68757424B8784A9FABBDF68F20BB58DFD9A7B385902E62EA29683F9BBC4D5D731194046EC0DA139BCD6693AE26FB9BDE6D1AED4ECA321089F8747D96BE29A753B159A7068BA80A95B50CB85C41507DA3A3D7E02C77B1A24E35C4629DF1D71ABF7927BEC1B5F72396F9F410645F303B3FB46AEA3A78F5429F191D8AC38B5681647E24672B546ADE2E142F2F0EC0658E6E5578C3758D87E0602126DEF41A1DBD7A0DDA959DA92134D83C655EF40B26139F8C176E6A19C9F793794BD746B14710599467E8A00A1E08EF292A7B5339577B89FB4E5E4D0440D01137C0530A1104CB823D5CC3DF971C48A6BC0A82F0A9AA7B61F61D4D0F20EDFC158D7B292721D6B713B35E26E8404BB43A2C21EEB2B23D66ECF405D86A0F3678E38E4A058D1699C69BB2142AA874EA0DA8EFC05019CAE930821E0200F0535E62EE28387DFB338EA378987554FA0E45810AA1E7A0360C7279203179F5C56BA2EC77B26BED895901CDA7387DFCC27BA4AC739820ABD897F4ADE5D97BA4FE44E5CB3494A9D99D0C8912A27E68C5AE68E0CC30AEE5ADBAE08DCA530291F711AA00B5A8CD2B831F5EB823FCC7F3E5C4DBBE49ADC151895898E1CBB2ACB41569FE947E67CFF6AB9B1B1473CFD045535F75BBDF8BA9445556F8CF8AB28E79496287171BBF2EE6041E2FCD6E1AD5F0D838CECC863B9CA46CD2A0A0F70123F4A714AC73CD899651A3D02CA4F84BF0C401BE7F86B79D65BFE159C7A4DD54F26EFCBBB10FB7D907D254CB7F280F7FBE47AD3A40C407F72A4A0D17B9FE22DD29BD5AA512A6BF18CE571A452B962444EE4801248E95D83732289F430B0D46EE72B67C1D94C6E7643DE36E3A3D257F73E746D58E07CBD2F261B2E42B7537ABA677967DDA2EC62F6F563FF6D20782FB009C97022EBEE71C47DE58BC36BD76485AA8FE5A86CF51AFA78919675CB7B6D1185690C6EF0635AA228577C25DDB3114BEBA9D8DE9111D83907E0FDE5093EBFE70DFBA19A8850183D0D293391491F818A925B43C3300C7D1B05C54C53C4B0956C334D1EE88935C4226B175FC7AC2C9227DE8E1CF19F0C549606B07B43C744609976813CEAE748B6F6AEC27E89BEE7A746B1697D4D80933A5145327830B5CC08914B7D0D08A0B70ED9A988B786CB5F48F184370506107190AE80E9F60D9BB7F41EDC93DA447C79EAAB73D583C2CEC88EF6BBCE53CB9C623B9D606E1806CAE3CEF8FDA18E1DCC4DA2BD3345ACA4C632CA29DD227146F7FED145ADAFF71D28C45E8724BEB315A8BD2E23F78308D607E68DA91B1DF8F187B11D9E080A2DA4B35EC30E491FE8CDB86FD5B193FDD7BC4A565CC6F21FA6845A2C42E24C459F04471F01C88C278F9B14D57E7379ADD5C70550395958FE9C6EFDFB21547838306247E07CF1E3D463AF4026FCC3028DBAF4E753E0F15A6B176BC1A818EF89BC81CE4B7D7B4AC26BF4ECDD363F3DA516696AC163505C593280B8D9A9B542FAFD9723AD3B15A69142FA62142E22BC7673C5D6F5C595D1443F6328096F144827736D880A439140C258871F10AC1A392910C41FA0671E6A1C227A97007C576B98388C24004CFAC2205704988D4A0992F5999DE39D739380652AE36CCF3E8E8035F0A01A1E9F83E59064BF80B18B2590247BB3317C9CC49C68A9AFFDF39D52DC6F6CE43874922F175E41A19F9CF0714DD7CB50F3CB9A8E5F3E92DE8A252AC29B14CFFE2EB9D3675ED682BF8ED432C74ABE5C5FC7C60F73B24D020A9E0CF0784D00F585DDAA3AE02BFB8FB436C91EB1717DEC5C8CEBE356FD47EF5DC2B6F302353D94603A0C357FAD4802A6A7318F16A243A8420D960A29F6EE8142E066BD0A280DE3291200D0AB94D11197099061CFC7BEC183A55B5F7C7C466A035E6A8F3E795B09E04B6F3466B33460B8A21857DC2B207328F06576E2037AF389E74A95242D564932FAEAB4232987186980B7A72CFD8D7FCA6C83401B014294073239F7B0F10F923A1F9D7A4349F5CBAA9B5655EEA03CFE8203C5653ADC2F424A7E6FEF0C2F69D14867F2C5F9732825DAAF439285C181CFAF3DD4167D06CC0C9361BFBF16B599D0069A787B4883242C11C1C19F3BAE0864D38445CF89BBED54964D18319C34E18E8111C53AB6D74FF81EEAE66CB2E39ED7B41A7E4F63E543317521F2E1F9C4E24BD832BE4DA9CB71EB90674EEB60BE7081C1323DCF8516DBCAE50CA303A4A24A537026682C39F7B574617C5409BAA58C57BB3BEB1F19405475654222174ABA60024F5C3A91679FCB04295BEC9EEA1AA8A1D56E6A2F2AC6FACCDEFA3FE8850030A0C39C9B13C598F5E73C3C5C154272AE1571EC18B2D2AD99492822D47A8541F69D7BB51C8E7735D3C105D25359885AA045840195DCBBFBE48CB8E453037AFB00DF111C309E44D2F60B8A63E976D50B1F82655E2603C5DA9A5F7C83801EFD9CA40175BB3B0EA63728A9B526DE3C4E57835474E458C6C3973794EA64B2B491AB30C52AF11775564C89BA8CB443AB4DC36F7878B3DF4812358DED5DD0E2AB826DA76ED9BEB818E1390107BD711F7415EF3FB697A28388619C24EAAC89EA081868237B5EF648E8DB6DEA55A14E3D3DB08BE2069D2FAD7D1A12D41D7F283E0A693E409FA56B2551D5DC3F9F41365CAB5418D38E958F1F57806BFE1437FF9F9DA65079A04311AEDD29DB8696121571F369BCD377FC9B3CB959FA633F60F8F358CD0BEADC883136C7BF12D0B7AAAB7CD8BFBE5D9801C147E14D96B623575FAE59A093D0106792320C15EAEF4AE2482550DEB99E398681A73192A7C872AF50646BA5121CEE594334E978DCB3F20D29377C9147BAA7E512218D35342952FCE171148D589A3B6ED052FD5E7A4D051F618DD64791418CB39497B49F79F4AED9E79AE59166403042894CB861862D596A5F583020995BCBE7BDE67C97ABDEF6B5B79283CB35E731204310258865E9EB4457BD0661E4BAAA09D7A5E448669481653C892B119D6645915A36810B53A6F457CFB03ACC3FC2295C564733579F3296A322E68781664BFAF6ED4EA772D44E99750C5FFB1586168CBB9DCFD589A639651022ABD6E38EA4B47421ABB403DD4D41FF954CCAC1B39B44DE0937729AE14AC1AC617810F13B6304D18D395B703ADD2034749E9768AFFBD36965B4107B17114569529E97625C820F18B3E7605DF77652FC3D8DA8F8CBD4DE8C7C47476EF85E2368E3AA2255BF15E54037EF8F9C96750B0CB3BAC2F031AA807D8650B94E4C0F11031F8864DEF33BB462AADA7574F48465FC57CA7B27E6DE829F1DBDD05C6E88BE32E8998BE9FD69ADD44A437141F878A087BF6150BD7A344652E0B9D889224F423CA5A86524AE083270A1D02B7AD224C49219C6C91F4EBD09FACBD0B79C1961106571FA975D48B6446F4B0AAE501FD3EE86AE69F4AC92AE13ACB8E6C6D02E424070B93FA03F7D9B9725D6767D615CAEBCED13D0DCF2D82989D872CAE1D349D857EF1571FA6DFB31C4B8D7D2C9ACBF0EC51B0B6995BDCE636B7742D33E937D617E4B391867EAD8BF6F6837F64C58C7ABD74640D11E635D9E472AC34A9B9728513E509106D853A65B4A3B61D438EF648326B414C0C1502CEEDCCA775EDA6F2CF1DDD87798131B24921C1D430D103CC0DEFBB5D77F9B343F857E62DFC135B705CE11D7F34C620225B70B99A1EB77E3D31851CC75D083BD61219B24BB3729EF337B1DCB1D402A6CD5B8B71773655DD2CDB98CA10A82E2F0ADB32EBB10D25223C4843FCFBBFA535D8796670F86F7A64D7E6C972F387F6D88DB55369892328DECDD7450EE97356400F7D37FB08B127C7E8F7E2CC4CA7082AB44399BD4D1BC14D77D863508196E7F5231C4DD0931EFED3DB62E539F4EF2E6599E09BA32CBC4028D8CBBD115B3B6A18EA3023D531BD24A776A729F51B047CBD9BDE7F9533975A492604E163465DB06A9C29C314BA9315A73C551715E2E16BBD9DE528B9D1375EB7782165B852715DE85359B2E013A4756457F8B53753962808CEB06B739A7EA07E55622E894904480A9F51DCD07D3907A20C5C4EB9FDD6529154B81D5111172E0A760DC03B88A6D7B2CFFE14EDA925564835670A355A5AC9FF9F54173A671E833E20640CC24524ABBEA1F5EBA488BCD699F3731B3F4254DA39F8991E40F818BA06AAEE709FB23BE3F3B1CBB24D8F2F22EB999B35D66EDAB851EC47D3CDD7EE6333E31823536FD939B879785EB0BF8B8DF413A7E484D826208815C6691D6845B373C7EE54B5D347594F706B0163F1077C4210CE6D0C876ACBB17C10DAFA74426CFD9DCFF3BBD62CFB622B477BE5B79042AA5EE85F86D737EAFBA951C5AD9F02CFBD27AE5462CD7744049ADDE47AEAEF1403FA78577FEF167E2EB6BFF29387AF6CC74E4B5E9EBFBE21B67064144A546FE799CD7FDC87E29B79947E303F3DD508C88AFC2D5D7605B53E1E12C378AECA435DF648C60B8AE9242F5A0766E7BB7074F68105757FB12E13D6141F5B2E3C0B5B1148F63DA264CEEF7559EA265047BBC17F328121425D4631932E70C96EE05052D74FDE741C6B75C94DCD549C7D69A78895C3BAEED97B3E93A2C3268C4BE07673D5F603D7B329A2B51EAAFC13F5E1078BD853BCCCCC0EB6FD5C946C32533B0143DC279CDE56E923AFEED772C4DC9353134E12C522B64B8A3E59518AA720C1CBDF46A290B183FCDCA3A7DC83D2B696CC0CB3D2FA4D0B713AA1E7A66990062103A961216701D1A89FC8077E1BA9A631D0E103DAC82BC7CF6F39D5DE5C98BF3A8BF0B6464A777476CE5243ECCB6806F83D30C3E9327CAC5202DB2C7FADD66A6619932F4CBE5DCB07F0D9B5DEC69C8FEF8CACC178A770CF51187195630A14538ADB287DDB5E96A5A9290CA0C242E7A9F14BBC71A266E25615D067FC7D51EE6FA9F4D84E5A54B9DFBDF51DB7BF448CCB92769AE4F4EBBC6740D808098C432D79391B33B3760EC180484E81B9D1F1BA9A294C48EEAB4BA4064F6243E1133F927D9E1CFB5BA13ADE50FEB191B5C595B53032F7F7E24D4137D1FA688522446156F7FC7ADA06C4F3EDC80D0A46C0EB964DB0024AFA9C14CC79360C830F617F869E1D071C720DABD61E873ABA2914F91E7A40EFA85A8BDBC0B56BE27E1A04AC0526426DA0891747B358A733C9FC89C2BBF6A207C2A4760CC4C5349AA1C2BD2D1932C4D3259AA5B67A5516081A11CC14C4A758A9C54CE7F2025DDC8C570A6292CEA903DAF25E5D0D701EB1C4A0B04BCBD91A3416084D5DC9D96C4008B8CE494B09B0A41805EE2CD616F9C28A4726866AF30228D6776FB91D34DF6169FB67F9F1143C0E9752BAD6C7918D9C29B5F837E6C9CC131AFC67DCF64A624425D6E69C35B81492A8D16FD6CDBD58CA536160A2A84C4E7DE1282ADB05E88853D14136F70A981853F592DB565974FAA75765351015A99BADA6ABE4063F7BFF6C5223F5DAFF05E4B03B592DA18E96F5F4993554BB8E4BED4A81431C4D805C5F5F264A8ED753CFB66548B173394C1CE968EDB35BDBC6D6CA4E61C3816BC42D9AE42AC32F2C2E4A4FDB86044CF4941EDFE039628610793A978DFFD68DAEFD29957AEC546D14C4A8D556792326A5A37108278FD99C316DBFD7218BC34F5755C308DACEF929D4D5A6C98C02639C931D72ED50DA9C120CF4B33D5296B229F219B257B58DB9B836BEFD073538ACB5523D461EDC0355AC67FC5C784E43DB5E653930B450BE646D8B5E40B98BDB8D1CB26AC16468B7F755B0B57499E7ED17C393F4858F15007119DC73EE6C2263716AD90B1C3AFD889EC6514CBE8D2B80FED66C5258B59867C5FDE46C6A65019983A46F653C3C48E2EE10F232D9265262C3E24C2A71ECACC18B11CDD8CB691331C7C32457B395CAB98558EA1AEAAB0C1F00400D52A3F035B8733E046ADF27F9A0773D110AF17A919088FB4949CB60B0B58A999A0BCAB9BF44DA7CCF98612FCA5433118754AB6B918BD4E6028F3446AAE0B932E44ABBA5200A1C3E010F47F516636B981352A32D97A73ACAF0A1FB273DF3F438D2FC70D144F25C00D61D8EB48264E36BEB8FD8F4A171FD994F3FE7CB0C752C59AEC7C14BE626263B012ABA7A3AECCDA3AF1A546B7147C4A49179D106436809FC9D00FB93E29460C5531AE05B22CAE4C5AC3193DB08A62A03071AA3D615E70968B9F77BB55E12E34E96908734D9C224DCC800E22608CB60E8468ED27F3C82BE0C06ADD0AC61F5D58596214326ACADC6E759E6FFFE2C2DF10A9549801DD3B12581B66D0D2BCF75915FFF7B693DB973A1DDA55BA07A07F55AD23E2763A72B99DB4C43E8C25E6527447BB3C3E37FD811B02BF49E37E798C2F357990863A5BB1490E5E8A1B3DEDEBA8D1293BED440289276D8DBB59BE9A17CCFEB2F48182DE78D7C8655827523D8D4462B0FE6FCC3DC7B03CEAF7E22729A0D0B7677EEE447C3E19159AEAC35CD6564212652B2135A21B310692A70A3AFCE5EAEB64DFEC208236C560FFE6AE7362147B5148FBEA9A680FC534FC07F8F7C7FBB7BE14598985ED949BD7A7F2D53A4362DCCEC150E1EF12A63490FDE8F9174CE00169B5F3A9A0B3E7C70EB92D8C23D5512BE19C009CEE21438548EA1011E6BA238232B0BD1A84F2BAA97C520780AC587D67F4B66C6427023BB4204F3475F561745F3FCB4CE6FD39581029E756E6FD82551977CBB3BF8C64255E94310211AE2237474B59C19A4FD1C5019C0A0A4DCB0B3AC98E93CDB59D551E0E8682AC2086BE158919D49503B9EB86A9A61FF4691D36D1A159A2FEDFF6863172800B79773F331003BA84B116543AB354D3B41607F7AFA8A4989ECABE1CC2903ECAF3692BD8A32BE047F1D4A1860C051008597A1DB5C1E65310CC2B80AE1B97AB86D36C7DA5DA32AAC40889EEF63B66D11509CAAA11FC43534CB2586431D6F52A04B15D5E1E6148C47A65E8EDEF58DD4093B43D6576FDEB6E17DA103DB7FAD377747CA3B253233B73066BC28C2F8E097E3A64F1459EB01140C3880D759B3E392556D121BC6630E119B8BEB136D6A9A143C28663F9CCA6BD88E73CB670F6390B5EECDFB1622A2C531F7FC1B4A852CDF2C104DFB65EAD79C409D3EAF1C2AC4A1479AEBF8C018FC6C1BE821020DD8BA164BD32656DEEEFBEB419BB27698E7595C8D05225E1A7E13151FDE2766601D14EF4371DB8521E38C63443209FC04E0BA67171F5DEC614666579625A81A5C72E1A2F6B17B8AFAD2347226456158F74E6DAB16C8EE20428DCD46900DF7526119BA111EE3DA66339E4876A06823CAE6DAFB0399B4EFA14C690CFFDF89A023D7819AB7D5768658214375E99EB191A99F13FE04AF6CDF0674D4B78BB83760108C029474754921DD1570C58D583807DF965DA65F8A3CB64D90D801D481F701C1B97D6B80999974435D9FC5AF9A3F41C4C25197DD5B5ED7D2207F85FCD8219E2B4A729546816D3BEBFC704CD88C0032B52CA77BCE7734ADB16D2BA3B823AD58F005027F0EB70E1D71244657F885551914751F58F572E9D41D098EA5858DFAB8D6295EDE7393362302840E4FF55AB074066F27EFDCAA610FC22555D2087D4C64CF78316993B8BCC8D00DA52305C1F142E3A9B7E3F41565E179E8D1B5818BA58188D98B2897549A3C462FFC3B3F2BDEC57AD44 +sk = 0B2B3EB50681403A0B9A99B25041A489C6D45D2A49DE0EC83E1FD10922ABE2D5A604FC7845561493 +smlen = 1657 +sm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count = 21 +seed = 5A64401EF8E63AEE18E8CC0162845DC7AF388230E86728ECB330007F2546F949764273EA05B397FE71F567E1527FA445 +mlen = 726 +msg = F5ABE373CE1F6FB14F2014F5BC0071B17AB2C84E8845FCBF4B15C79FBF2E5E06CFFE6CAD9A283014A975F81C9216B261CBC79EDCD58D0E20C586D7C641E0EE97221BEFE54DBCC56A594DF103EC24B52DDBB6052D1644972640F39DEB98997FEE7A252A65070798B7E46707FA440375B1BA705B3ECC7EAC56D9C45297E585299C7D747B430F0D01E82081C70B4A87846F90267D5163181DED63E089A00AFD33B0E2B3ACE91182D8CC899223CE65A5D84B86BB3E8B34B13949BC800F2145468BA5411EACD6A6C331C340D4442D28EFA0DA959A2797C7181BD4BBE6E6DFFD134CEF373ECB0EC08590F06BE0CE292D3718E2C0EFC7CB40F1DB26F5F38FDC82A72F81AFBBC16591EE02DC818D63CAE69FF0A28F942F7E07F6B0A741F3F0EBE3D0EA5859024AA408462D3D268C23F95D717C0A685A4CA73AD90EE923DB57CD6CDD828B7AB0D4AFA6A9AD7E32D407A44D7515C0A6AF52A66AD72119BA1DAEC6514DE3F8B462EC473072226AAD61135B0F5EC646BA9A127C9894E51FDD1B2D38011A2A6D7497A55283133695D0AF9B3FF7C5A8FD667231F9E511E3B8C4C3ADC44D02DE08C47B2382DE67B32826754C6BE5231CE0FC657341E20247CC6CE574F3D1A9376AC8237B49E5030E877A4E33CDE25D838EAD659EB1678706C759707FC66CE84CC968A8334C18F1632348824A6985A0331A93B59497B70C1A03A6848F18F5992972BC79F07F4222D2612797F495463836AE6CD3858D5B9BDF744A1CF361B5D454D41AC899A4FA61081B937CBABBF0FFEC1B31C162224EA36CA2CD7FCE54EC1A504932ACC5BD0B17A156DA7488F7017E4916A687FDE7FCEBB2901813B07964084AB0447A94DAC3A0D3FDA05B9F497CC1555A8C74838E29CB8CE89D304DEBE419D26BA7F3DC6E9526BD895495A5FF1D7EC83F70D045E306E7C2487A52CD7553F062D31888EF7FD27F667FCFFA984AFE0B9A4C4E85CA943812CDC157C5486B0B5EA6DA05E4BB8697113190321A976D1806DA129101E60A28B7 +pk = 5F5186992D7F4AEFDEE3254BDC35065A71CAB07A11E277220E93FC92E98ACAAF34BC91808349BB5B04890BCE63763A7AF5F893F73ADF90BCC2463A8BAAA5D7F8C6E5EE17AD6D18493DEFFD94533B31EC044B1B93FA02A7D3C1B44D68FC73BF228C5A0A5FB301A5C0BD9B6E062E170DEBAD2933EBB481BF79549E2953DCDA7B641B0EF1DBEC67606A78943E818D8AF743ECCD9B29F90269566AF1A3A99BA60B7717B31200DEDA797A7A45B84D6D4AF6CF0E83715E2A721099E262FF4EA953DDE912B1AF4D45A1A4604225537B60006847E71F3B7785D66628FE43961412FD8CB19FA7CB2A798B34FB7811EF71A3CF0884E9015E97755D72F16464E6CF87F0804A476596E6AC8B72A0E2CDF6BBB360122532DCE98D3E3D34A48D7E42224D6B2746304F33CA9AE37E283F87D0C239823C4B3069B5FBD8A7381183CD1376CF2C90C1AFA8DC7A3B15CBDBBD54A77C1A9A556F77440B4A7F078DE6C5ECCB969BA5C9A1A0929BCD4F932CC5A7BD8F2036A68C93F56E58CEF70FA9D470883CEB271A70B2EF43C6F5727A087A63BC6160970A991D4A3381BF5FE0969E08EF18A8CA9C9E870DA643F85DDEDE3706A8D0D8C7F80BC7D23E0373214DA95582FADF6AA7236B030390F3A0929427FF769498452FC6B548263C010AC53644C33F5FCBC9F3B7D02FB83B49D65AA93F0D541819007C5DCD4E6419475E81D8B2B35E67C0508850DCFE8BFF3A5C88BD7F479576F6B44306F79067BEB79A5492CEEFD24DEFEDD459FCF1E77CEAD6C386EC9B129F505CAE8CA1E331E09EF972027AFC8ED0B006816B0DFC3339CF7B6FE4D04C3ABF60FC99CAA7AFBDF4083B1F82267FEFAACB74E5256CE36B4BB94112556F11AD2D573BE96AAFBCA85E76645BC53EA7652E551623BFE9441871CD1E9F226ABD5A2900ECD11191F53F44D3C6EFA28F9821260DA4F705032CFBC5E5EA0CBC27E4CA5C4C4F9F403995A5DF718C306D24F673BA45AD4A8730AA6D483A2107083D3C721667403A1BD8E3BA13D7ED0EF032B05B3FB437ED84A3849AC124B8918678DFE587FC86B2704921F881BDCBDAB830412E1A0CB4AA20BC7FD0DED2EF6B0A9A80BDFDBBDA416964E9E7F2617022FF5232BC847608A3328CA236EF71A4090EEF252423FFD9017EEFDA1E85341C5CDAF9284024A5C8EF217F25694376434A3684C00D2990C476E37F8C3897CD57E4DC44046B1DA4D02B56C5AF27167106C9BAFDD26FDD6D2BA469EE0E61AABCACEC80893730413EB58AEB3372E58C6ACF1B69EEEEF58E6350A940289B1657642C7FA0C7E43FAEE74175EDEB9B1D07EACFA72A72987FEB2508F323CF95C937E2DA0FB3A4631BF124DC852613BE4F04C6319CCD7708EFA430EF4C1B1C1C341992BD1F9BE0F2816DFFD02AF823AC2155AC718AC800F6C9F5960201C58E6E54A58B53611205F4847F261E5121ABC973C43C5232F0107FEFBACB15CBF62C381746478D5B37CBA63B5237ECE71CBA7B56F9FE11A6641D3B5FA4893D2245F9C3E66147CF3F3636FB0643F91ACBF021180063CCA93C800352A13ED1DA4127DB99F54ADA67ED598FDAD8090ED74C722EC33B173FD53D0708C599F27EB09C10C72A8F95944090C61FFB0A9F297F058063F17885E13A48B7EC2F365C93914426B98E8B5C090E028B1957462D1CD21C1D14E73AAA2D0C2A830A68A7D4F793382AB433ECB3D477AF0E0EF790A817B24D0FAFFFC2774F5444810268553D29D06B8253EDD6CE06E31782F680D8E2783C2643CBB082B00983344E18857C398D1597E9F538EFCC9113F46C9EB69DDB068A7AA4AA03FC0EDD065B4FF728AE602B339CB955EFB4E940E35B76CEE208083730688F8F699E88E4545B09FB32C7BEBB0EA32CBE456E77F6B0B6DBB79C6D50631F3FE6B02F2CADD86E2BB2FD1E8F75732C3561E6CE7A951AE0BCCF0285F006D0EFAE1CE35172E5DFD0978732708E5E092CC801B9C0DD80DEE23B1356350EFB0A298468B0CAE5ADBE0DC9934E5988DC746296BFE91743CB80739A39C8AE008BE4B36357617422C77FF5B3D1D1043117057DC5E35E47803B1653043A2108DAEB91FACE7BE74304E5BDE9BF9AC51CBD0ACF3D737FEF02DC3EF13C155C3C86872BAD994F1C9AC0B641A5765528B38F35F950888D7E5E7F0E8F1124C8EE1A0A9D702C5FBC49F924D571CC3E56C4EB4208614A5AEAD820B1A3C9E57424445D54930E442E511EF14B1A074C67DF950AFB55D2EB78FCF5E1EFA16858C76B75BFD631394D37C25C6890B65ED9D62ABAF79C4DE0CD060B00997A0613EFBEF996D08B2499B590D1C45566825CD716CC5537FDD6FCCA1BEE9A9B6B3955E3A64F6557AF368C98A3FA0F4AA2B9AA381DF30E9404D569BC4E1652B869B1D935702941CE07A3A7FE2357066C0E56C556EC45AAD35305CA541280F2B905B9B720F45617B6410B448D671312816C8FC03AB8C029570CD7CB3D8B7269554DFB8A6DC128EC04D442EE60603B0646DEC5E3BB251B62DB5E2BE62D0C27E06D04E4C7D98C6AA5BD9D64382C61D52D77AF0C322863DF503B83CB6CAD8E27EEBCB9FBDA1569A966E627BBED91990E69BBB13C5BF9A45E7BD10060F5B9821D576E140EBD6F10957D03F56B0ACFCDA145B124F169445431F674AC8A7AC79E10809704087177D852C14B67B0E86E7991B49620678D3B47294AF0BA26E57DF8075A688C9F162DF1BF6B35B9B8F9291EDD25E8307259FD04BE6AE8739B47A9E16954E715DB1C5CEEC3F1C3D772651FBAD6436493D62AD8CB057CF6DD671BB6EFA581AAA3C0FE1B57D0A8E3F9AC0C96BF3EF22C3E93D0C1354ED75CE968CA9690630E07D7179E7EAD298106DF1387AFE2680E39064239A4391FABB74BF9284F6E484E17DABBFD41BBBD80666CD036EAD30FE87FDCF63A1F0DE084F605310B858B1E617A32DC112A48160E39B9A7AD50985C411CFBEC0A724BA3839F65D18ED0D0719ED66D549891FAEC4CE7D4EA53FFC2402BF4A9B85695955CA238E375544A7E58B25FEA8CBA17530C00012E1E2CFE59EF4CB361926FA0868DA9FCED464FD54EC5F8970C5AE66EA40D92AB4870047C46746692558F8C20AB80C4EF9127E1400A662F06349B27F1C56A030D6EE839F3E183DCBF5DBBA4C011C9950F62AA5855D46692F354E3470C0B38E9345ED493F205F20042AB5E7EFB5C2EE930433693D975628A8D9862760C229410618B52214F1A2719A0B75E6689342B31BB7B641CE67987FBC0818EE6989BC99681BCD2E0FA152892A6B8B0CD827720786892C68D45E0628EFBC2381B859373298082C885D4DACC10EC636C994B82BFA7BFF1D04E9E4454FCF6F63C46CDF4B75658F8373D09381A119E54FEB4DBA7C72B189C89D492C754C08F01FDF871B2DD2EAFDA604A10646386FFB708229A0FA4667FBB2AABA2346A4A88CFF7FC619F991BA0B22818EEFC0148FCF7276D76CCF8E8DCD8378DA631D9B553871FA37B6E97B771B890059D45C1335D269F15C224772CC031775CAA5B0C1480D5B5D659D78928FFFAD59CBE472376396244CAD982C5BFCF59772E1E703150FEAC77C674199C4DCD79544C5C9367F7F7056FDB56C6422698C3A774F758B29FCD3CDDF7674606820C3C35CF40F063A54E3583EFC4B8D83F3CA4E7A4453628087F71C137D8E2B639C1EFDDD8F81AD24AECA5177F841B886555F47C493CA5F711C05E28A925447A8C3A74C7C1E34F97D5B954FDB6C87D44CD2153AD4ABE5AAD42BCA72401B4654F9206F97B0C3A01B4DFF655261D2FD2ECD6A268B8137B2CFB2DAFFD0B708B4825B433F69C54DF6EEC07359F4F7C557433734C8DA55301676B99564898C48CE2D356116F3AE0B077A1FC52E9083B6595BDFB197E5F717B0A6B9D30A62717A28D4A0723752EEB81F715FA32DDCEDF0BB7D8163FAAED43D56A03746FFAFA501E1434246113861118C50E4B3B13FAB1549E133A2722F81B87F198B8BF89115A52DB0F1074BF6D772EE3DAA9B66609973670A646CDDA5D3CD5C0AD17ADCA6E3D490FAB0F516D5FBDB2C51B2F0B4CF29324280F29157C9F6587545C58A24DCBD5A2ABF8F03F00FF85AC6F1324BF0C9CB73E33CC0060FDF30241D9C395D65B3B5C117B53A818624BA52F61B288A3D15119F24F28F0E2929687047B949852E994FFD6C67C6CF854E6A15224F1721009EE8895728877589DBB448045E8548A3A134CF46CE7CE282FD3B7D6CCB9F7491DDBEF37D61A7E85924139E16F889F578443A485A9F608A27388C24CBC4CC74163871FEF03B312CD34526451BC7CE575CD4FA8E5285E9FB9D4EAF2DA41B1222C54CE399C099D685B7CEAD3ECB91F867FD2170D29200225816F26D7A8B4DA297CE4855FC24BE058DEF28D5D23BD3EA3CB1E262066AE4A13E80A52A1F0043849F78E4F0BC7E3D93E17EEABA249463532A14C3F6812AB0E25A2EB6C30BBC65D73D464B9AF3F09642E95872D3FFC80B7DB311B5034BB2195EFAB8FFE8A82EF138A018B8E18738A561D6F4F3D57C6053ECA6F0CFC3389BBB875636A8C3323DE2049497083223AAB2562D7EB8DEBD7B92311EDFA4D4B59F9441FCF2FAAC9EEE25D0174F0C39DFB8E89FABA67D836065AFF90655F2AD407C8ADB389477B02B524B50E3852A0EF5EC5191308CB3C5C92C5A23D718F27F428AD1551FA96016CD22BCB414C08BD94AFBE11792A09BE52EB9FECB6F19EADEC7ACEAD8646DA2308D728F6E10CE0EF6A605BD276042C9B789224762A9FA59D67CDEFB39BCB0653C588700030A536C86AB4BD043B54E0BF441D7173129052D56C847668B40130B9CC979240DC06D3B72F64A0AC72ACE32E3D45EEBD792B16DB3EF554CDF0072F4CCA658DB03EF0090EC95320189EA31D563FB6436C427A427BEA7683E6EF2922100CA15F5F52A7A05A564FAFD02B5ADCDDEBBB344B1082B8408122625475A159E37DFCE63233AD001B07163E9E00BB2C91AFF30A75F1363F817B6A36D2DB64C53C0DC2A9CD590322147BBDCFAC2588132503395DCF599C1CC84100A433E1EF57ACBD3C2571AE520686D98E99F005EF228E483D30D32F97A6B9F89CA23ECB1A7FFBDD530CB2F6BCDE52220DA4F0519CBD28EB63239463E49D4AFDAC2D3CE4C3FF8A436EF225501EB8DB495B933FD71D46F17E956BD08CD8FB0E43F57906B1AD2F23C972AC60CA5FBC4BC6E55D93E8CC7FD47451086F517B2EF6900DF889C8302B9320C1AE35C564605CDC0F6F9BC022B0FD2E1B33FEF54FCAA37F33415DCA16418F1D01FA3A2D4D7989EA050D304B8795BA150A29144C667D6F91B79EE9404013CFB46582EE7916FDDCB97F61FC59DDF4BF617B4601CE5B5639E652A6C56FEFCFDB9C451572F0FFF10DB7A98AE22C87FAF5F13BB61B8D4BABB7EB63122B03C97B7BF9B331D514609681E0E8ADC3228DBE54FEA5D8C867692DBC40ABD7BFCD13A2693997FE86C709C5D21D290102B8EA52A6E4C159D862887B7D571BB16A3ECBE045ED595FFD3C2C41F01405D6DF25F3458765261913EC70C77A8848B121EA4B424C8C5B23BE14B5DDE26A3CE5F683F373A6C8086F352B03665E602FBD7AC757FC47D638ADF156789B7D463830472C855116A5513FED145AB9C478ECB77F25E1589A47B82B33E639BD3ADB827B25ADF57893F3512C154B563400453D5F3152EEF866F38E12FB2B99FFC1226E91CEA606F5A05A039008A053A0823FA2346C5A19AB20EE674B5DFC4B23A15387556111133B596B4E89F72D7277415841594CE6A66880B8A825DBF4BBE323C855AB039D6279AA7AD42E7F56DA1EA622566497663FEDC0CBC0E85691D08544ADE102DC8EA277610596B7BD8394FD663E1EE07DAF089F4957281F27561C27F399AAA42F2667CD14A01E4E7709A31495223EB1A825F531471BBF264240D285BD3E4FA5217D73CD4A2D172FB0FE249E19851105485E5EC5CFD991D8C3763835E0D95F50CD22051236CF6A854A169B39C0FE9BB29A4433D87646E599B19963463855FABBF36E94A82B95DDDF86D9F791CC50F1445CA59F3E9BCD0BE104BE6AE587D2406BEDCF448A35A95BBDC7824352B9B7238E86AEDCC2F25DE8191ED1302C09365B1E315B5B575A847BF3969B7B3E9DEB1963734CD1C6C1FA66CE12D674AA7A49B292A7391BC5E3043E86A42A30F51BD984DB58F6E7C92DEAE01191AC64B190E9A6119CE5511C3F09F7482C4D167AC63DF09E18DA0720371B7DDF9FC5B38A0FEA3A266699C4E0D3060198ED3882A4BB67CCBA1BBECAB1FAC9769BB8F31A14703D7E8170EB73B4E0BA9A6D2AC08FEC49BC64493E6D0B83A2017B39F6674032FAE37F19E5255541171A7E78264B490DCD6A4DBCDCFBF9F578A41719BBF86B7B92A80477CCD90B67B75C101D9FFB6801948551A366ECA2DBB570724B8ADFBC788ABB89FDFFCED94AA6B352CF01532AD34B5150E49C022DA17A562478091AF9BC6273BE83B2883EBE0251D1277460A20D01C3B08CED9491FB06A5D377635DD106AC21C60CB64C35D03AF67D50F688D2B21CB0B1FB28A793B39D36FB18B660F3AB8DB076A9C2DAA9516C097DBB267C567877EA425FEEBBFA29905CA8967336096732233BE72A4A5791F5F91FAB82B5BB255B822B8403B9EBC3C19E7F5D2DFCA7714578ACF4B46D0F80F35CBD13683C54C593694B59F5EB0F4E1F4D009A4FB5437123244ED7836C39A51FF4761EFC58DBF2C55047A923DC36C05BEE30C398D4FF26B0B3FC70BA2B5759E66D15F19463D49569E4841617299E21D0547069D7F698BB773EEA38DD19135F1EDC09004DE9F44E84CD4855801039229BDF6677BD8B672BA62D5800671E9425E6B1CFE4C68D89AB18678908D3099B35AFA293488FEF5FAF2050123529662D2472CB6E3094A24C3CEC8BEC2E3D18D0F0A953952E1795A8EF2379F60AC6EAF44171A86194470E31B9E9DCCB40764C50A16DD7A292953A07D69A5AF0BC49A2D20AA7461292717DF6F8D6AAD8E57B9E4CA1EF863DF4D85DF56122D1ACA0F6DD1CFD51B933020C74B43DF1ABAACA0D8257DFDE5C8DC5DA51B29450C94D8ED60D821D949F0F5FE5E21171B01A7CE289FE7FB21699642B4FAEA8975AD0BE04B1E3FB57747CF917463CA1199B950B24547F183F41362E3A74AEFCA75450A221E89AE6852A29A383003746CE9010D58CD5D1CB7DCC6A3FA00009729640FA693C7B6A65E7B1A8732CC10EBD009D9D3D0C193BDD50D90BC6E41D20A986643B03716DAC6207ABBEF52910A3E6523C9F82888063837DD795973CECBC68998BAC21D04C3DED93C41DDBC1E6C2C0B7F321670024A148A5FD55703758C5F4E79D24432D6A8D7F39F02F1A7B40D627127EBAC443C73454BCD5B29B4F72BD087688353717C4C68B30758EEF97E4C4FE6F649F8428603B4766D4C5CDE52BDAD1E2631200F4D415A43442DA6001CD983F2E2D8FB28E00B8B6C948075A9862C9FB835E9150C7165C9FF9FA7FF8C07C78D6578189DB3E7C823DFCAB14E90BA59FB5048F8C646ABDBACA5AC17697CA5419F63707632C3A431E91B292551B6B1F9B2977E09D231D6BF33CBE8B30C2F973F84EE8D9C4A6B8202700F24629E26B4F9DDFFBC56AF393678DEB09A4134DB766A5B3530E62E4C4B2DCB8BE3404314A7F850468B7490E38B752BD481937D1FE9D3F224134AF3F2B00E5EBA1583DCCB9E78F63B3E6411A7253A148A2E5383900B61978873160BF66797CE933C00C21D80A1AEAE611C4D7F6CB909F5CB1A0C5FBC39038A6D6A1C783F5007F0E0F017AD8A14B9D58624AE0B37DC6E1FC3E98D626425A49747AB170327A898591E8D969B82FFA9F7BEDD8699399A067A018EBD2426A22E78F87D1B1FFBFDC294FB78AE487361C9C6A163591B3F31BAFCF42C8D7AEA07824D28A40 +sk = 8217D32CD15658D39CDCA92C41B59F5780869A68838A3579DEA48B5E3EA768AAD478C3BD3E92624C +smlen = 1690 +sm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count = 22 +seed = 3222E4B55D6767E300FDE03DB3D8227E19FB8B08EA9B923FEDE18D699DC3694EFFA7C4DAE2AF57E4A0162B7C564199BD +mlen = 759 +msg = 4C4697A7D8195BC7D4B8F2FCF3A7E9419E8FC9AC6BAFC5D658260511C697286BFE44E2CE98C21C98BE42E5AF0FCEEF8AA54C5770AF287A81C7481FE3391A6111AE6243D545B2A651599B45931D7640579F8659A8BD6F77260F235F71476ED64714FDDB70C549CBE089322130F7B0A21F530508970D55CBA55BAEACBEDF684C7979078102ECFFC2C3F182F710280CABC2DECD3D3B5D3CE908CB2307B00FCC0C5412A12AECD041B5F70CC0149390312B9C81592BB0E2ECE83D4495944E29AA798DE67FD69E2BD0695DC573F78D8BB48E6B8679E1C50D1E6E58E218B77EE51597EB43ECF7301D86F457353D60E98CEDC95B4A76844E889BF7E9D03503757569E40D55AB43D63293EDDBB579FE981FFD4DAB056F85006FFB5E759B9C16F5F6B235D7DD78458A73EF37118EDF599AA504E9DB9AB5DBC90B8E478F3DC1F35A7C4604A383BBBB410CFB2C5F746F83EF94BDB2F244D421818C26827D5B7D665B8A802181EB7A9CE95B6633E24D914FECA7E969F64038ACC3009B15168426EDB67AF2CCF4E859F5C616891D355F7910ACFA599C396BBB2D2782CBF1432E6259FAA77730B6B86FE0D67730152CD2AE0F9B0314048CCD25772C01FC9773EBF06618A8CE1E940F48663427775990CDC41C4DD3E9AC6EDA1EA50E04F1D329E64C8532A7AE32238C131753D60A25810A5FFBEAA9007A6984EF69EED92B777E079CE0FF48C2AEE9C18D1DB9F49B5419EC6C0E2212DDD2E2FDEAF0FE9F2B84D9C50DDE86A70FC28BBF8918A973CC67A36E97CE3027D73891E7AEB24BAF4B12A9DC8AAB5D6AFA380BFAC3703D2D32F1E40FBB532FD6D7D710DC0741DFC7EABFE55BA5C311A00E3BE55C2EE74155E3A06685071A962D7532AC76D59FC187EFF01F8D339F74323732168FA5D14F4B2A72C9164A04A6EF14BF5DEB1833E4BAA19A55AE590F542D4448E0EAFF0E0AFD2FB30FD671631B9325F4A0BAC9A43DCD2840185A2F601117A625B0DAD5503578537BE2A535D2F556F371536BCF68C0E01C96301F08E1567DBF9D8504096A8FD89C086DB695DA191099FD1E8EA94035276D1D +pk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sk = CC625322C9D52898E7F60AE47BC2847E20F3722794DE41E30FDB20CA1A09320831C1EA74CD6B8B7D +smlen = 1723 +sm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count = 23 +seed = F41B3C6225245C06455272A6A073F363E5F19F09A0B146AFCDFC2B3B0EA64BAA3F90359F32B2D1017608B03064E90AB2 +mlen = 792 +msg = 72713EA55F1E5CCD5787F172657C6F6C74081DE2D70816E8531497965DF02DAC04D91C4D09DCF8904CB152E2138F829386F4351015DA253A5B5EB92D96E537DAE3CE809443EA90332D9C754EB11F4DE586A83B5DEE7B1B9BD547EE7107530249B14279BAA04683D74B69D7BFC8BBCD447FE7706593C01188FE6AD8D0E2572D49F83E93986B380D4169BDD94E3311941DD2B041DFABC5AEA1297C65BB5C8352C99FF838D46B93B3E5F79E3CC5BE5408FE5E59A10D488DD65A997B086FDD96CEFB0247B2BAF7B490317E34330A879D04E374C92ADA33EE243D84DA015FDDEC243B00BD7488AEFE373E8AB1890273A7A2285988E9DAF9C4E7C5A17F54AD6195EDE2C79657E1BCCED0641E20F7EE26EAF53DD8C82827F2D2783D44FB030C95791F41653E628062267A5CF534DF00116C1ED1DE9F360B97555C65CDD80724104FB1BD4DA5785B5D9C24438557E48AEE58D57A03E06D553B05B67E1C8D10085C2F153647F174F7922FB8D2210454F7014BDDBC627756EB7CDEF99B6E3A2779F82088E3F2DA14C2DCB5B185AEB5D6ACBFAD43E286AAE8F84A58E8DF6ABC64E4A8EFD69FEA18DBFA6808F25FD418DE8BA923500B74E34DDA3CA6AD8DC208102DC4A876D8B8CD2926AEA4B3AE11A546F6235ABEA152DBDF43E0BCDFCDC83299207F294A707C8B4D1F56AA64A205C718ACA69B862AFE7489F11B324E7AF6BE68380D2CA6E0AF0E2E20F890F2CF98907A9D43135C03E85E86C9EE417140EFEE9054B46C110A84F1841AE3CFAFE5B4A95D6B2B606D8D0A70BAEA85C9412BC2D54146E9F866800E8E8615A0D64D1D595677E8C88699E3CA6097D47E9FE64050FB55033FAD4D5F226DA8EB5DDF99369ACC7552927ED3AC7368B9EFEA2443926DF26D1C172858FD8A5D4E1D7D39E7F7DF047385D39131184087CDC45B299BD1F7048E918223DA3F960608E853EE49EA667465DBBD889CBDA20FFBB540C9EBBA5C2CD16A22A57B561E01331D6EA6BDADBD6A5D2BD1441EF4E1D9DD11CC62A0FA5BBFFCBED0D27B6ACAF0889EAA5863DD9BB35920707B71A0805630D1769FEA320516E71CB2B125AC274F16F7A6876F4B922C7C006F38AE1F7183CA768715D2AF +pk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sk = 950226D6AB0B774C5F439AFCFD0113B5DBF5905960C445F5E6E03E5D5C687A9AD52AAC230BAF053A +smlen = 1756 +sm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count = 24 +seed = A08AD391E0FC57A83B74CA8CF44DB67F8178262ED9B20AA0163CDD8274AC2BE05F558B112B094244370C1AAAB75077E6 +mlen = 825 +msg = 209658CD1D801079FFE8E950BAFD70A028CFCC35B9FB00D232C5603A1D51BA13E5DE59E0277962C4474E9F3F60FCD99C9B79665B3839D5C037B921A4DE8E144FA1D38182FBDEECDA6934E814D9186591F01C5E23349B34F4439B4D402C4072CB4D702966AB473D2C39443F41FBDD0C48E566D33E076422EE72FB47B2FFD661F367E9EFDDC988BCA02382EF93590D4FE3ECE8B1D9D8B3A653219C7D131B43E2FDE2851541F467C31129E6F9B9D124221CD52610B9F138EAC1D01F193148FA0415B29F5C86D15067EB1E26C9D51F05655E8545F734F8F244854AD76C6B04C230898BEA33EFDCEEF100D79F8E3B894BA583466749B82007067806E3A7B3BA954F6FC5ABFF0E099A24D14D865F6F4538736124ACC5EAD4169DDF2144AD558DA3C74CDABEC147D2AFA113EDFD1E2280766B18792310FB6B4FE5D0D9F65906B1CC43655BB3D6178EF9093AC9C8F1A91BF49008179394EEE79E1D8E3228F567770C1BA1E30BA4BCE2465AB68F53CE21C0D8AB2F6E535828F211D4DB957DC3AF8B7E00DABD8F1F74C959B2AFF45121C5B5ABD3136C6F55D5F5FFDBCEBC3CD7A430FF3813D23BCDC1254FE6949DA4E7694028B7FCB876099E91B92C65D85C39D4BE9325AFE81703E5B18CBD7BD9EB59A9BB9408ABD966ADE9A60303807AD1B2C14C04CDF8FAE6950A55B21C9EBB5E94713BF8C2890215C5DA94B59CB31EDC671093B15FF5014DB4CD3EA8060260DC1612E9FD6E5AB40F0656121F689C8E94212269A7B24305C83BF0583418755CE690913CB081F2893FB42BC4750F2C053C48C1552430793CDDE1A49AC9E21913210D727C4BEB5640AB9B7505EA4E59AF417A085394181784BF1BB0BC32BD71CC57CE77541581F14B8BA4B758500694796262B561A38C72893C77B548D779A3833EEB064CDDBA5471CBFFBC769E139946155BF376A56415AB743DE568CD21895ED6951B5BFE1B1629DD6510DCD4483F206954964E0517546DD96900A2540A51835818D1730B0C9123E7FD8B28E6843BFFB659945A273CEA944FF6E83C234B3E43DB4630614E0B67778EA760EE341FE68C525E90475A1560821AE6B2A85015292C36EAA2E041AC04FB55922C48204525187C7E0476A9FED04EFBBA96F369D8AE709506620127FD399613A9796C4FF96D7E +pk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sk = A6B534767A6D839FD19075AE0BA10147C46862BF7BBCBE83F2B72F72F1368A1F8458A22CC545D54F +smlen = 1789 +sm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count = 25 +seed = 6E0A8EF5156D693FD0140BC4A31084E79773A83F42C8D133AC8A9D62DE3CD74511F893DCB26041E6B35E2B175408FCE7 +mlen = 858 +msg = 8F37A065DD696AD437EC82909261B842EC0A3E66F8AC574105A3C82EC8B4926F2466FA550F8EA1B6A9A142C00AFA44BE6512A85350930DFFC99B95AA21012057051B68C48581AE439B9290A163AA4B6AFCF80FFB91A3321C7B9ABAD56D5DC1BE4E67E5576C9F3A7DB96071859B94EB22A73DD96C66AE67AB11D1AB62A86D826C682DFB8CCA3259DCB5B34BE635421CD4206E7D92147F14C36424EAA407B441F58E5C187E58A26B2AE144888A3CC1387AC7D0A681EEDDC3B7781AB282E8185CCF33FB27500CFD119E0415DB1E45237520A868C8457C88A1D3EE97EC9451DA35D7E74924F8902949E7EB14BA87C8AC672D7E4F3BEC1B2814DFA67A8DD2E2D4FF4661D64BC4C6D6A78D4E489689B6063CDFF5A3F1554501B424284A9F4B8FE777FE4E6AFB83A85E36200A9AB40B9C18678454B2A3F50A4862BA1E36F0C57AD004FF90192B5619614E37DBB38A1B8A65AC613F7796C70772128377065B84F122540106D1B4F9123C4E009B4C0A85D59B35F72DEBDDD154ABEC7F3FB25FD1FA04367386098DE610B26FA3ECB031A6072D14607E92FFBE195ABFF71E586A984131AF24E18AE94DBAB0544FD2AD217960F337111BFBD4046809EA03C7C47B7177757A4A43E1FD0134859BA735A8FC17597E593BB58322136602954D3A21096B0D1DEE5CF0AD17A5FCF561FFA21CAA70D33998840E4CFA18BA481704A8B82D2CC1C110FC9A6704751365AE9F338AFE4CF9C811697DDDFA8635A2F3CD02DD1845251014BF2F2D6C02A907BD783207C4773A937048A07C500D7C424B5F65A2C376523740DF9A0B60437CB8AE17D64DD51DD4E433AF83B20C4B6B890B97976DF09E3A86AC19006C229D59FC7A2923245B7B1F0ACF7C42E486D41CA1AC1D7051AEEF6003CE94182F97D099C74317F61EB47AE18C2BED6A3CB253C21EC835E435123E0A657ED926F880CE8E5DE3155272328A467278F52AC50A1121AE818A3EA3A2E1F7401CE23AAF66A4AC289748A7E98A5124C586D8957BB4EDD3F091492BB1A64D75EFCD45AD51CA420F15DA848B20DC6BB765E7B71359B3A9E95E121266AE4A40DC2E9A3D81EA1B1A643594B3D4E6ABB7D1202201DE92BDF0CC1ED977E2D5851822A01F48A6F23180822888CE345AC9BE0CC69BC448D41CA20B79C35B1DAD73E6C683E70C4439B404CBF07FCC39B0E5A1D33F3717A6BAD28A6DA4F091BC7A +pk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sk = 103164ED522DF0DB131C15E139C0F83D9B1B7A1B6ECF7F89A5248CAD7E68DE8CF226DED914D3D5C3 +smlen = 1822 +sm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count = 26 +seed = 49CC05312D1DBE216FF03B60575017A6A1464C06D2C5A4A6F973AD9F275F7C66163A29A803BE759B117043862D277C27 +mlen = 891 +msg = 30D61C6FBD64113FCED8C5205026EBAC0D9F3522182617CB00B6E70C8DA62ECC1BBC8E1FDAF17CC61DD01CE85A9072CC1D9D34FDADBA5B93E0AAB4C9C4C9E26D3F7F145FCB23673B6E0B373C0FD1A58F52486B72624EF91A539519EE5305772A006E49521744912BCF3CDBAD424F00428AA96CCC21D000EFB09DA5CE652E361A6FB649A060835E3B9DC9CBEC660C7531620115EC905DCA6EE2A1CE36554C0FC1D6DD6863B8F3843508ED5C214B6923E7F5C0304E9B0D5E5E433BD029116A33A60CB980737AC950577D0594BFE0AD2225CB8D3FA42F192B0EC05A49391632A32FA931C0FBD83A7B6EA24301AD0906E7911F9D900D19AE1247ABABB1C0E9B9BD165185D9D7413EA068FE8824CCE5B3AD51FE8E2BB2C4022C61B002C1DF4852E4910F38613787CA12371038B6364D920E07B4B417401253451DDC25624B5D038B2DFE29B8494EC960F87803CAA256A95C9868AF819747E4BF26FAABA6DDBAED93A7815C795AD5EB7FB4592DF678AC1375388CC7ED3A6230CBE80ABBB113C80B70C789CF0C66B943E67CE814F12D3D83F3B90A4320FEB7FB81DC93B05D7FE2D36584399214D3D7C71AEF322A5D04B5470703B3660BF86B0B17BA9FF23E45F7BEFEC3758786D2111C81BA4D81B83FEEA35A0668E5EB3694963BB4DB3ACCE4FCBA6F3F6FED9627580DD2D2DC103EF7E52BB9745BD42A7FBDB459B5C8AAEBA67686EB899E3177FAF0897C61B008ACE3304C41B4C79E2EF9C865E9958D8716BDDB69154FB33187D927B5296C1589FB1AE3D553F116FF6CAE56910CE6717C446B9947AB2A981A8F5999C1C6E517EB3FE584F5D10059910E22F40FBDDB709C9F686F51ABF7D7206A8BAB4A346B51523C362D749238D7EF6671A89CD86A8540604F134D760267E91EB92FC0FC275CAB69C776EF81DBAD35027E5307F1D34EBF5D6E4DF424D709666A1E649C044C4930098B2E6E3782A93976B55073C504563C7E052B6816C07F0FD54A759D2BC189FAC3FF54549FC4DE192EFB58A9E301863A77380967735910F63D35EF5FDBD8751DE4BC6BF2E3095628DC7F67C1F5571D17AA342593B2C7F953C3F0F22DA1862122031BBEAF0D00A029C043304E3E2609C4FED8A7404FA10E2EC846A70EB0E37C5BE61E698CF2296EC1FBE6FED75F6FE3113C23B29AFB5A6D7E3A9E46E2D89D8C06450CEA11492C1A97F7D6BE8FF6C014930043022B264FD32593952BC606F779598631E48EED86EC2A013D8EB866F311A400 +pk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sk = BC962D978F38881085C1B813BC90EEE44AD9E7651681C20BA46402F557C454DE40521D68E5BE376F +smlen = 1855 +sm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count = 27 +seed = C33EE43A9CBB4347BFAF71147B7FBDD88D212462CB06FBE695A35402C503CD15732B7D0E8BF829A555B9167BCFA2F2BF +mlen = 924 +msg = C83441B16B39BD7993766E7260D07751AF2F19A41E70689B0EEED0C118D9EF109866AAEF31B2D2962A25A3D1CA999214CDF0EB54598382EEAD64435B7122D275EA8879BD47B41EB64EA908867FD78ECFBE8E992A2636AA7477DE5058179565D3A2CEB8ACE5C0302018043C411D89975A64927B48CB622A13F1ED85CC1113897A68488161AFA1E636EC786A0AA37B928BA88A50164A9EC372523AA9EC8885AA9C95B29F7CA1BBF0652BAC195BA94E976D336B69A9F5346B4C7C81457F802DC9757C7A2435A617317340F764C1A2AE131A716318F00AF0EFA89D3B57D8F31E155598B3944D950D6A1D6485B509358EFB3745B95EDC30DCFF02574F54DFB2D31B259D132D18897DF868115679F06D41102CD4EED4EA290F711148B99B647B8555A4C0DCA1D2D0871C59AB1382A2D6417E6236D71E2BFA1A75CDA54F93E6C087D611878AC7670A04FD7D8CB0993F456E3BC1C3B5898076E22D2D9E0EEBC7D7BB8D142BD2B5F6FA42B40BF676FB69C532D7520A4A105EF0C1337F53D6E9B4BA17F1E76AF4CFDF08F794752D2BF71E8777E2A209F8891B1A53D7BF2A5786B00B9A0CD0FCE79408F26BEFA2535BE188A68201B1514074CD70660971F86E8D3E92790AE7AC591AA7A996149BCDF060C615209FFAB82E6000F41B2A5606FDAF4CD08CAB0C2F1103B2436B1FD7DEC477C6233FBCA3B07A0CA01BF3476BFE5334E32AAA2ED35D5747D673E7BB622E1AA7901C77F28A3AB2197C8B8253A1D28C969EEE73D17AD71C7919E7F217BA2BADBD1EBF986CFE981024FC347028C1109CD4204C7D53535A9B677E39A43193E054D0FD68104D88934DC7BA6CB3E942AEC744B935CDCFEEF4221784F96798E650FFB0FEBF2715D75339D0CB6C2E57C1E9D10F13E6786B7F041AB307B8CFA51A2F10B622995230FBA54B70D94AE278EC224D9D0950BA97BEBA7EEB0E2FBC4093E548D9EC09CA1A08E5F0483024D7C1927FF8DC270900D42D31B81B13A29839BD746CBB3591BC33817741A31DEA308F549A74F3A4E5478844183B8D7363AC1F4D4A5E907D9ED98AFD08FB8BAA84C324563495387A4F12C239FB63F0810447131311B2D2CA302C7DA2DA57C94C3B5E844F537886FB766EC0E977254DBCA8FC84AD77430428F0692E55D8E2CAB294B857AB51A2CE4A725433DF28D9CABA86C770743AD987BBA58C0565BD18590931E283292889294B607A5F19D9E905AA3940836E2A74A2E94FF3062E85A5C6C978B5EB2B254BBCDE128280E6CF02C11A0C2066F349E3C6C083965D5B8A9C000E15FF36C5BF3A6D42 +pk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sk = C3DE54854A4060EA09ED92A363F71C7863EBA64195E9AC79E7AD7EB6A183CFAC34A1F15B9EC854CF +smlen = 1888 +sm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count = 28 +seed = 19CB4BE2332F7FF0C078BC001FAB3C5FD8569A76EBCE373D1ED4FC8EB5D744C6464E2B5EECB9EE836CD5D87BEDA78BA7 +mlen = 957 +msg = 86D27C1FCDB8164F8909073F590D0A280E5EF193B0C42863BA518BC8A51E625658DBE2184C3353FAEB674C991EED3F1B0FE3BBE50A21EC70E9F57B97C38D6E436D3DD577D7056B07A401FF0EBBBEFAF8212B993A39281190E309ED0C50B269E4852DEA85432A5941269FDF63766B21D25D8816DE5E87FFA051009D232D6B258C5F43F45F2D48BE09B2CCD8FC963FAD81FB368502057AFA7C865D62D932F652802A299295B29411439DCF832E8367A749B4D7ADF7E8ABDE3EBFB844A9B1D32F77B2BF96B5D29FC15DAE83EA80A990AEF6590776CE1CB81587ADA80B9A7B45ACA3BBC54DBE67DF090104FA196701280B97607A333A9B56A728710CC1CBB7569B79FF034572495181A92D2380A7EE5E9CD1B0F758C2BFBCC4E11464F1CC7D91F117319C30CCBF4C11E60B5DEC724225B8D77B71AA58F5FBD498A3F49115687D58393BE648805BA1737BB921A08D738243920C3834F8782A8256B7DD22CCD5F4ECE86B8A0860BFF21C5C8F0BE987F2D510ED4DF9CF94BF698680B7CFA22A575A3D1B5B431734B59A4B31913019C1F42DCB76A9FF32BFBC6E16D2FADE26E3C17BAE49CC415E4B370D1FB43FF652BE62D18B0AFFDF286765F4F30FC8D6F2C4A58CD17B3BDFA013BB2DAA075BE5F522EF9BFC2E1506CC1C4D381B3342EDC19C955A5FE48A712AF5ACE66A028D03FC859711C9D33231E48D41E58A2C2AD81DA77529AD5E6B73E1AC96F0C8E53F153FAEA7903F917492A1D2B1203174A08551FF0F9F91E32BD0F31D606C80A505D5EB55265542DB3653C2621E7EB3FD677F49534F261205F834EEF1645AF419EF6BE5CFC16D54C7EEEA12D2EB9458831F77FA558E4D5C7FE446DDAAC3E1D502C941C95F572AD545ECC7CAD21F0DD50845CBDEDF589505FD34CD8C00D57243C3AA3615D84C39B0A72C28F40AC72DA25EBC6987DF5A7E390399463786E75D524FFB6C961BBC9301264BFE3C699101D18ADA4A72D193971D54089E6FFFA684CD3D77570CE0BB9179A156D3E2DCF266358499BFC158AC9A6913F622CA861C968EBBA0A59A12674BFE39389A2125A02563B082259483E80C89A3763C0A9C3DB485AEBF22C844539EDAA28A3FBC0053EEC475679B741D9AFC16B5FA109399FDD1FC3574DF8A1292B8D7401AAC1BE452D38F97D531813369EE4C50F36736B95AE9C3E4F91AE85E2D664337DAA40F75CCED2F4A4D210BB4EE25A56DC217DD176DB5ACA43C002AFD63ED8712D89E266674D9736FE4A9F202A81D177970411DCCD289B25798272D2647CE6451906A4F7D46E87A46CF6CD048B6BDB62488A24F48D1EBD61FFA474321B929E0A7B6F9D0F6D777ACC14815F343E1 +pk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sk = 828B9804524BDD17D0EB387368B01B0E95B4960057ED63FC2289D858201E207E01AD43442CF4C3FB +smlen = 1921 +sm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count = 29 +seed = 6BD93FD13C0299B3EC7403638673F3DBC449F3A617B691DDF73C072B62BF028913375D7460BED2CF9FDCA517690CBAC3 +mlen = 990 +msg = 56ED7708F98432FBC623424C2A3634780470A01784BECFF01BEA5BA192D02C33675084263C4315420A009579EF80DD15ECCBB812652421872A9577EF7D07896A727A64141BAE7173426DD5A3925159BFA927FF1039E70F729847B48365B4D3551476206AA049BA5AE8F605847AA03965F058FCFD478961EBEED06530ABE900042321059C297DACFE76CC12D52311B2FF8EE1231C77049E232D9FDB751FB27EB7EB6A373B4B1C06BD0FF46B1B208072C873E6F938E689839079E48C6D18F678769F5F28A903467F2FF2A8B02CB19DF675A8FC7560A7D38A918AB8BE083EC4E0EA148517AB90F38394833304F245BFFC47F9ECA771FB80B9C71CCD05FC3B0D66EB06D24B914B63D9F16AD2F2BC454B591D01ECFC527277AE71E3DC683161A53F129743F3428FB82A89DBD5D42F3EED237CD2F8D76DE2E56A2143AC6B2BA811F745CC72132028EECD4412B76FDD87A2E396ADCE72DC69B8FE053042E798B220974587AF96BA419DA6888B13FFE217C9D01434347F4162FD554B760883E8EB1AEE46C4C26B990C6BA10D2D939F513BF0EECADE8B5DEB8DE2BC8C8894ACA51E65AA696E390C11689F1C2CFBB70BC5F72C1872D99BABE8DE8FE2DBB446A8129AF0AB8D9613F0CBF3CFA6EA3CC409F4A97581D5012707756994B6C8D4FE7F64E0F0B85A85D0A5FE23224DFD7ABEBA8E3FB2E97AD87FA8DD477ADF48F64FAF486D0DF11AE9C3BD3A04ABC962C5B02CDA02D48F0B52D84D4920C116C22455DF291A96E6ADFF91E3CD35CB8B5B4E70E3DA8B87CDC969643A32B1F97131C5E0BAE7F6DFBFAC32218EAA596D444574EE85EF7C9998DC1088E5813D50A4377D29506817E4234F68B32AD68E00ADBF6462F8D4E215F15A19DFDE452F0A65360F7C1F20E11C42EEC55565CCB23CE248BD62E9DBE8A7D6639028A92B422AB444C5688B5D191A4BA8956F358D131E2FF6DFC607ACCC5D31AF9678F1A226530078FF9A73D681DEB697670DDC3E9096AB0FEDAB664473DCFFEDF9BE62A5C7C54FA2EB5059E9A1D38413B1A4FE6D531B799453BC7185ABAF78CABCF65F365B00827CEC5F29C4737047E3B2932A78757E9626A958486D1740ECF1EC17A01AAE6ADEC5104EB934F432207CE31D7096ACB3A0FE2F5DD7890C021892FE7D3F34596CF20B6B12FD55911ACB46D7386F99A9E9EE067A45C6A1FBB463E63D69CB582DA6EBD6330F4F80A1FA72F2ED24CE9BBCD967118CFC7E21F6BFB68A905F532BCF8B8BEFA03295D362B41D25CDCCFC9B41767858F651BC56AB2BB4A8675513C5D6F1C943A20A27DD29F941AD141DEBAAD219E056510BC984063FA0F389090D434157438BB1759690C453A2F55F72C033797A4B0C534EA2EA084B3B6F8966AC56B106FCC11EF08902F2ED +pk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sk = 4A84CA5C3954FAAFA11AE87FCBE701EBB5AFBCC5F8ECAE7786D10821E01ADA5A5B8B89B0DB95ECAA +smlen = 1954 +sm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count = 30 +seed = 1787C82DA9F2E6CA9ACF7D6CCA70116A1724902C81EDC1439F332C74807AF2BCCCCDC7AC1788BA798520B2999F39DC3B +mlen = 1023 +msg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pk = B942F3BB6CC8A8196635E95389CFB8FE8446DF92172E11A390466009BC70490EF0C804B1B000C1CA2DD548139B3A14FB921E88B0CA6284C38526907661D7667CE1E84B6B222593952D1D1BF5A1716FB2F0BA04EEE1AC17B8B8E1768BBC91AEBE1D1C8CA105D64855E3787644C46673C111F688EE5C5D13DCB2D94BF7561312818D9722BBF16FC4357D9EC870012E70E680DCF05FFCF0F45C16394DB802404C5D60A347C7AAA6E8B2B877BB07495754DFBFD9612146FDC9A702643C5C3E66528986CD194A03AA40E1DA3A5321EFBA31D1619BF7448BA0734AF3EBE10DFA8674DDAC10F5E651569E8187E031A226F7E9048F31BE1130F49AA43C7DBA424D97AC3CC6384CFFB701EFD320955D17F59E7939268E4BDC61B9CD2CACA88A9F5E1098AF923C4E376348009822AA58E170A636E817BE0840FAAE0B1054455ED4E075FCA47F09B8752915F25D8953E300B10DA2EB38767979D1F903BD8BED589486C95CCFBF87AEC451229E71874ADD80C42FE978A14C915E76E8E4341695AAEE2A5B12AAB6BC63ED96F2FA3555E2BA21ED88D0B12E84DA4FAFCB5B4307EF4F89F77D4088D6AFB89330854128FAC481353DBAF20C9E0ED7782939C5AA22C107B605693F010284BA12CC37E75A3FAB0278F2FDCB785108EDB9A6356A16E863C189E396497EBA852EA86D3898AF32E620166FFA4017AE8CC58C517789655A2581F8E1F5998FA2BB0DE1A79F653059F03C6FCE7089BCF12F56ECAB64201D9C135F2BC87C25BF99F1A1424E5D7286494AC9C4ABAD2288E08A8099EB29E3F2DE640DDC31326DE3EED0659B0EA2CC92F28420F8F2DEE89052DA0116753EB7A3D4A16E7CC4E657E5CCC7EE0EEAEF464AAD8CA564E13866573C7AB01E3CFC665A5500B8BADBA8C201D1325CC2A3534844C240EC9FF6E48E8AC8F92390352CB83660AC8019E1D9EFADCA1BB8448453AF3DE7AB99727B9A21F1A1680B04FCCAA078370319BDBA2659EAB37067D8B58EB0F5B0BBD4C9CB5B2F065E1DBEB393E7690D6606866033694A46F2E547E577FB79E074A3B38E27C33AAF1BA1F319D41496B510DCCC6FC66B16E9CA9E61A8E0428DBDF45DFCB0AB5E2538DBA98E4C393D39EE37D3D11D55ACBA0FC55A449FE548A0E0772DE51634B9690F4601FDF0C5864331081A5D6E6F2F8B2370C3A32CD77C70D2EF8829C9DD0F3997E680261D5005AE9438ACA2651ADCCDA0D1C8E47605AE100FED4539FEE5614B0BD95D0614B5F2EA75A5A7ADE7E10BD039089B2C79ED687860E58F248DFC0320F4F95DE5E1709C8AE54943C526B42B92DF008C991DC451FCC13FC2D0539FF26D2225F79F813E1D27F7DE0792098449E5F6ACDE50F9DD567325CAFC17544CC025CB3ED2E2D66B1D60CE70901CB814D2BAA7447D51001E1B26ABB2DD1F87F43CCFEB4895B52CD8A21D518F65359C00B84CD1F0FC64F301C14F564B6B3F76609C3E3140561B18D77A2C0820D894A5032EE15F11DBF4A67906A13EDA0BDEFEDD8E51691630AA6EFA6BF3CD2DDDD49FAEF4526720B477158C2BEC4CD733CC6201E5004A6FC9FE3BF7781A941D1DC77F479D178AAFEDA3D524642FC41EE0BCCDFCA993B9D13B08111CDAB118904DEDECC80C51700C868C10E6B955DA8ADB8730203EF7CB1A5FA580AB91E05BC135BEB6B822AC1614FFE4F7060A58527E5C13BB0D47F15D9505FFBAE18299F3ACDCA9B6093F84A8058D721D1495DA81DEC5717B99DA0FCC2292B6D764D5C0F215517C42858755D9CE625294F34AB5896CE3D14968EA91392E0A4F1CE5A0C347620E718A9FE50785DF0547033B30C144B34AF82041C216BA6D4716EACBA359DF9D55C772B4CA4ADB353AEB21538E64B3B6168E88F3DC42128462F453E5C0AC38D2007BB35E3E65141EB02D36C36E6424E336323D302E09A30952350F7D87363EDB181D75474F4D2A026A5180B68E1C202C00142D09403BC20E3AFCE6A9B84B9F0B8E7A7E7BC38722EFFFA1C6D8AF1D8395E1C9D100231565F8992C4C0CC836887EC10C09A133B853B406066213B85AD7AB973B1042F793AD88670CEC3FB37FF718460C16AC7A21E28035C648499E30CCC17E1310FCF40FEBF726DACFB1E8F9312F491E9DF65152657FCD9E7F3E018CDD89DE7AE93AEEA757B6CB88212CCF14DCA50738DBF49F39A5337B038D2CADC66445A3A2C0C39B1C91BBE6A6C2B3A8BA45AB69598163A0813D11E55E34B94A52B92F6A50425A276EC5607EE96DC40E3E18C827B29AAC7284B71C203F0490C25189A4B9CD18BE6FF1CACD61B79760B6756D36FE98D9180EEFAAB5A9EAB8E8BE118C744F317EEE5D7B0070E0350EFD9B9D26BDF286441146EF2A27DAD5DA306EE0CDAAD5CE09A17210B2BAEBF08BB1D7FA819CDC3381BEBDA1308D02BC744F64E909804CCC7585DB756CF541F3F4CA453CC0EE821CCE53B108C78374F6C4A66E0EABDDE894C639C0C5EED7FDBCE52BF78710512058537BD26FE9D5AEAF9B682AF91B3856A8B5EE4F2F6ABD40E85F5F061E842A35E9F587816435DA63491764E4855A54CFB1758310E676F18645A15093091827416276590B3932A93C452CD8E53EDBC2EF01D784D8F18529F1AF83C914CFE559A959D209F0A29AC8D6B72CBF9C8FC33756586B440B5E6EA2448C296C17C9855B442BFC63A0947039133177D20468EFDBFA0699AF6C2164B80D830B53A81EECC3F64A7B717D73B1715BD6609D7481CC0887297706872ABE5A28FBADC90CE0C135875A228D9A2282B133F0311F3099F9E55998F63337CE64A3BDBE44E166F016CAA4A3C08B1E097344541577F72413561F2B25B6D0B21CCA05F98899E8C1DB7907831643C15C47999C60B626F127E0C8077EB649CFC86E09522FA646CDA69F99E505B80060325C91F203A0AE4C47D336B8C579B1F0F1395902BE8AC7E811C849423366150DD105185276F530D03ED90B466365747461A00C2820226121322F1C173FC811AF8AB2EA8E75D401A64804B90865988FDEF2960EB1298D527300382149CBFFE5433B6E7B20AA809D50635AA5FBCAF61CFE7452717620D0A30B962F09B2AAF88A58A0AB13CAE80FB53BC61B9EAC7ABC89FB13D2951C13093EA9E7C8D932C2560C56D851B1E02DDF4B63E4A1A1E2896C76AA5026EB5CD49C514C1D2EAA695552C0023A3347D0C55B7AA2DEA20EBEB1093083D991F1BB4A8762174D4394A11192C99622652CEF8EB548BE4FA0CF1516382469D8FB6B7C3F70FF8524A9CF56F34A93DCC38084ACEC0F479A3DA9A10C4CE30D035D41232932F941E8A38A034C6C0B97415972C34D666809D94A2AAE1925693C65C7F2839608CFAD1F3FE05C19F860DA310A2B631EA1F146FF6CAA445040BF803E1F704590590A2A74A1FE5DBE7B9D54F92B1B87C85956F8DD05D1F174208572114EECFE028BF9B75DCDC77D4C76146F47F11D45E1693E5D8C0AC97EBC9A7B73CCF3B13FCCAC5D8C2E81E3BBA6D5D2DE85E8122F6D37E0C89DE9DBA521D3BF1B5DF1FC313B24C6AB7342557D4CDCC97312609737A4C4D7E7ABB9D186AA6DD64317B711AA1F7254F895A9A29FC25D47A575FE43A0B1243EB387C9E5A98224FB1F81D2FFC01369FD91513F6F90E63477131827B709EDA05FB0A819AD7A6F5F207DEC8917B370369DFFA3D98C7860B540B918BC1C80379FDA2CACED654A40CB8B0AD32A2BC1A6A43FF5F514E92CCFF7873E0764B1ACDAF43CF7CBF782CF6320F727EF1BFC6D39E49AA9BF4D5C5D934F42ECFA7A9970AAFE72223EBAF325FED6C1C104FBB7760A771E89E41F955FA9E169AF5A662AD4F06497FFE04E8C519376AFB3FC377566A778F6DABEA3643F105E7DA01DEB251DCBEAC4C4FD15707FDD6E114E6AA3252B5BA2908A1A05EC55CF0CB8837CB6DD63365AED987B19007D075EA5205C6D8F3915D2C9703BD843E905451FBB35D3E9808FDECAD1E7236E0E361200E00BE385E0ACF15CC614A7FE73AF0B3501C80490146D0E6BE6810D196B3270332BEB6564964AC0F560BF1B0DD30C82ACA727706817EDE97353ED52152EB9FECDD4BF1C70C66A274BF6BD899F925EEB25D368CE27866661A27548FB8480001DE019025C9E37563DCCF7600E30B06394C620CC3882757239A573570B0A517BA7BBE34A5C15CCB5B2C20A80191D18B87B84694F22446A5F9CA2D5E24094116B82E9D6D374613580AA688123BBDC2DA6F4D7444A48308C1488A31B2ACBCD215EDCB0D60E0D9FCFF99D428D4AE10951F69B320DAD5ACFEE11194ACC9D3B3F00BB368645937456AF53784398E003B5AE2CAC0B7FA838E5FA0ABDD3793B6B86C914EF1B72DA0635A99FB136D185B6EA52D8E848F289EC22B78B901A8A3A010EE577E082D3FCED93D4546C04A06ADF009F7CC2811F385C6F2ACBFBAFF77A844EAFF838441291E9FCEDEA165B236E73A9744CF7F73D978E87CA0478F164C1A0923A0AB9149FBA52887F7B5B047542791BE839F0C3299A3ABBA133958CFAE6A4F02264E2CC23699EBA2E675E520D24198A816437D61401DCC5E5A51ABB029041CC83288751D1757DD99A4EEA7D5EFC933E384BC805A7135A035843DBDE5D9769DFA2E4FF333FDEA0109B692A2C4EE48652C2980F343F3B3BF5D22979FDE4F2DBD0085E0B088AA9C7A99E0C8FEA3DC5C613944F1CC287A5987E8EB92D568865028514A73572299FAC5E0655147152C14C1E61AF82CC9466C3BD88A3AD190F09F63CE53C5CED5732844EE1B454BF994DC423657A2FA2A587D841A4B07F2D4C81883EAE81ECDFEE1FA2087874EEFACFA411E86C66DD40E4D43F448A12F7BF37F917286CCB33E2F8E751F6425C20BF852393CBE3C57D8FFE242A455903122A078D6C3DFD8C822A18242B096ECEC0E4685CCE95CE501F368D67ED98FB0EF978910D3469DB39EA7B1BF1E240AF8C5F9FFDEE1DDCD35E9F9E22F3F5C92840C9AFCC151579DDA04F62264857ABFDBB2778B42AFFAD4AC5497618C33AE3B054FF162D16A140321BC4CF44B716A73AFCD79F93E92C6C5BEF25B2D64F78D075C99037377E376E3B8730ACC9A340AE837FD795D809A874EE34B3FCD5012D5CCC5C60DE9570211B1480DFBF4ACC8A679F27BC21201A83E448DC69FD4474F5A9A77EE2121523C90104C3E12385D1CDC8C32A4E3210633671DA475F5B53EA9A14C6436CCFBF8E83236026F87DE712505DFBE5938934C7B36F18300FCB1AD0378345162BB9957A603B7F004565FFD85199B696093D2AB4E80982EDC40E6B258164E753A7FBD4C3DE2C1D75C9C02FC9E9AE4519621606D1EA622FFACD080A9AC5B1C1FC559F24059D3047571E7472F8C6BDA2833CA44A569F05DC11651D05325AA26CDB6530BA80A1BBBAC21399042672A17F7131B1318E95BD14CFB566FD29619420F7A08A19AD7F6EB376E79AE661A40156ADE098E935E2E90FDC87283088BF05CD5098789AFA3751F198967C2699DB0A9B22BF514C787CEE1A39EC6E658F26C028CA8268ACDD499466AAC18ECEF96A846569714C0F7720254CC186CD2FB9AE5EFFF1568BE45473BB373454110C2E77BC097B45DB9CC331E0ADD1A21907FCAACE46686553BFB416AFFFDE30B7021A6796D0B5E064240853136266AD1C4FCCF21527D011DA7627A5F6A863D54D24BEDDB163D3A96D8DE3B6AC4E00B489346E58D1C66BF725D6B38056A9E61D7197ED82C39359C8B50B6734BCB0BCA1A88828EBAD07315FAF5CC2BAF5438B9FC0651D7B91EB87DB01E555AEEC6CD8FFCC6A8D898044B2A171E2558A02CF3F1A2509F637DC7A292C25EE5838A245EAB0DB72064F3B1A1EEA21A6EE60F5D98A9480287011FF205C419748947B144C498326B357184F98C8E91F19949BC5B46E6D7DFE5B06F540DB20FF1AA8935FB53D1328B012A69B5C21C7DB0E600822F7A0A91899A1F48F1C75763332593318BDD3CE954CFA0052477C15C58B8DFA3352FA5E34D2A952DBDD32621E48B9F98D91720D8FFD79387B61FBFE288DE63ED0A9E14730986C958A8B5DB7EA37041B3B2A051A42101700025CE682A6CE6DA44D2E2C4CD37E2785F268CFB71941BEF74B8FD67F579DAFF39276BE7E774B11436FE0A4E481DC3B45BFE259E7F8283D1916120140E4FF2576409CDAEC5D610844CC822CE90FB94DEB1AA98972CAA45BA891B357DB363AC09586D106A75C585BD7E1C92D67FE76FE137246BC4DEBC0B1D5B47547E38C32F00D013C78E59E4E5D9A67FD929FBAB2E714DBC971DABCC6B8AC0B47CD41174183E4D662D428FEFC93BA0BC3B61A15A9E11A0EB72547B98569D7EDC47C904451B702435930B1F792704FC4B29F0E4F99E704D49643FD2FBDD5404F2D6922EBE77C0AB895727ABB70EACAD28A1B1A2AF41E3B2E517A4D92916FEB0D64489449DFC0C3788BD8573D46BD1033925F498966743B729B244AC97931A0B813693D07785675A32BD118ACD9D0BDA0A7D972635E3038B276B21972CC879B54AEAAE8BA7FBE61F24167034C91CA77B460C7CB8CC0B7DE0FB348C10D8A2D5F7DBEF1FBA89E67CDF3C41306D263EE2376BD8CEE254DDD9C7A379DD847F681273B8725813804392AFF802A27B75F4030C1094DE4FA8107703760C143A4EF5A64BFE81CAA039C57CD6632CA09DBF20AA643E7DE029BB09B036C89A0539A3A60353CCAB81256F468A569109AAC3C67CA2CB0552F7AD8DF9D5749AF38C69832EBF5B62AAA92E444B7AB7E1ECBD35FFEDE9A4F38D5C1A68510B32FE9E2E2030442C24E7FD5946D6CEDA51489D9121390D70DA09BEE83B1B1F0BDE376D992040E2AF2AD22C8303DF8A426EA6DB0E62CE83E144266D471780F445CB1863186959B7B6EF76BD8F81847127417CE7B8FDB5E305CCED6BE7D1A98F96AFA48CD7C0B642009123F39DC34F5B26352268A2BFA5F82D3296791505EDA194D6D862ECBCD61BDF552360D693F45ADDD5B564E252A3E3987A8CC05D2F472B98EFEAE7CFF1BADD60F0AFB05A3D3D885199832C0C32523A24D41B8FADB289B14F1F157BDB9967FE9B98A6796D8F188A300C494EBDC08B457A9B6FF922CF53588A95D1BC7491B84234A3DCCAC22ECB025558B125147D466B016A8DB681AF1630699D0EC15BAD389174D8C7FC3BFA721437909DF94D0386D168FAF6E0CB0E59707E9645362002FCB2137084427E11C7FC019F8D91762F085757FD6E470F5B0B54E59DA1D080D4BBFB811D70925145F8271BF89BEDC93AA9741B6963D2ADDC94855FA36F24C7175D44291272D78D28C52C1181ADFBB7AACD21BFFAA38CC657AC987CD62D2D904427F1FDB9472A284D00AC6BCD7B517B013BBED24CFED222048BD3D62F09EA24C8BF145788FD8F82765384FB65A08234BE4DCA6FBF6A89E3F50A1DFB4F68F1298C8FAFE7DC21A9AF0B6E652499BD5F75E851C40C8A8CBA8D4EF14DEB568055DCFC8B7AA0604A537EE606223D08BF8FB058C4DD165563EDA021F10F2007245473E0FDF98576E74BCB7356A68B7C03BF5A1DA240593AA4F1804BF874D9757362A39D65EFC88AD3F21E949EC39A4687C6E2277FF6C7E233160430864D78A27112D7E339E6993E2FDAA494F95D56D418689A5287C6C7481F2DB4FA2621450DC953909310FA7AC9ECE636C47D3D62FC31A1ECEFCC042988C7BA03EE0F966BBB3A6D7308BAB81CA6AD8C1B534B8EA48E828C095E164E3B775A4C13D7C080E7FBF5003400968E2BEA76B7B9F3EB2295E91AA7FF935F078B9220965179DD95BF93C749F4630B93403609FB3BF52589E479BC337CF79456543C68828051AC8601F75B383CC8C2380217B25420815A1F3C95CB4888A243A200E3FBB3001ED4E2AF9F4C40B51C41ADDB7B504FE42D461BC088C721EAC6560494323CE20405AF6B65CFF2F74E4 +sk = 3E74AE2B1D49EE6F149076F0BAE2D26A5CADFD5DE7BEF66DFCAE6B588A1F4067F4296FE557AF9D81 +smlen = 1987 +sm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count = 31 +seed = 9E6E12F025B2A57B0F5A3A9FA70396FC332E1802608E5CA07CC4FBA922F1FE5DEA6721B96F1BA2BFB97825A19F08FF2F +mlen = 1056 +msg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pk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sk = 39550BD2782D66FA95380F5F101D827377B11410F8BF3BCCFBE0E504FC09AE38ECF1A3A07D64582A +smlen = 2020 +sm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count = 32 +seed = 569B8B9BDB707B19CD6F9BEB29F304D603C1509B9CF25987C280C342E870B1E13EFC7DD7E41DC85BF4F42D0493B84B0F +mlen = 1089 +msg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pk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sk = B18F0FDF9DC4F514107F88CC43FB29190608EBC5A2CD00B49FE20631761038DF973757803618EEEA +smlen = 2053 +sm = 1F7C13A2DF43377C676063A8168EC7543D8BE7AEB3E3CD62D82BAD363E3C90545B0D342B716363EFE4BB215FE8559F0C26E0CD61EE2503BA3977181E324FC81062E2B7336E7F2F75D828C2469B6802FDEB510B27510063297D23D74A5AD15D96FCE4CC48E7DFADC919EB490E09D7207755C905CA87BB7161A299DBFC8BBD478D41135F0D939ABC5ED5FD9B081B4E4D96D2E2158E34E0907DA7EDC400D2FB84B0981DD483F32F87F2315CBF8625FB1BE3EE49F0E69F4CBF7B13537714E4AF9AECD7566A667951A04C9C6F9FA2F50C32A3F409A4C0FDE51A9283391DD8B69355B23241E909AD8C76DE9A02E88253A35A9F99288EF2C7BC606B114FFCCB8E34C762676F39C863901008ABF538B090745686DDB83E51CBBE9BD7243504D650563B7BA58177CD5CB77D8E5CDBA07E79DAAD8F478270251BD8E3F09523CF94CE2C2EF7C5722A8CAA01B1DE8CED334A3730B5E8D1095FA324F6D1E9A777AA1962CDCFDA246FA0502E8814C6CB8590EAE43A37D3B7555F617F9ADD54791F3CB9B0D0C77D1DA95F406CF31CE909CD9CF02DFDAC39EE8D946B85746BD4AC021323105BA7410F54E9B0E38C3F412DFF7F20B6BB2C9EA9E0D9CAE034671442C959133C21729C34995C33938B277A780B6435774BEA92B6A72C17443F932FE1D4CBB8378D41C4330D9C3E27FD35C2087BFCAEF12D973D0BD2B63DF2AC4D0FA80E6F39F82984C65B2DCA9C55BCB550372E4967D108BBC5038C8150740FFA2C31415C269F7E6C6463718735661D41F9D91EC91081A18A857C8EB9FB6DBF91DF4469299434696B86F0DD4738DD9B8B49626C62D3E531D2C380F51C8706FAFA30B6705BCAD9412BA860BF6F06CB182EC26AE8B3A59D6CDD170012D1E49C7F1217AAD74479DBA22D43D6C6D7E19E1093DB18D3B578CC79CA667A2E3C40F0AFF4167F17EB97411ADBC58970AD1BFC849FED07AE117C88222F7F99609EBFD10FC90EBEED35C669FCF665F5C096282A6617F2B90A16D95BC56992662F0EFF49C0250F99DBDB5615F935DC822C1A9B60F121DCED8FF9128A2C0D824E60A57A7978B2E4A5F77CFABF7AE71357D20F8F33BF47DEA229941F8CE33472356D04E9E44850138C537A2AEC83B2D854D773C2F54D4F7D9FDAF32377EBE61E37DFCE14CF467CD508350DC6D3CCFABB2606D563B3C726363C3199441CE66D38E0C63D0AB6C48ED05DE76914A62BF02D6AC797A13A09CF9E523E7A7F6A7E4CEC01629B13D42174679537683D573851684772F613F2CD13CD61C19FA9F301342B459561748F9D755521EB89633D4490069FBBF2D2691CA58F8092D98E46B071E4DA24FE5C10FD978DD41774311960AF173BC566697FF38725F35312D75E58845FBC33E112DD95D5C1CF78119CB413AC839377C7051BF5F17ADD1484F5EE12F42B0587AB41DF487BA5E4D8836777B614A9931A5FEFDC4AC451662B342D675C940061C4FF01F747B69CFF585FC5317636E2A830140C0007F73C76FCAB96195C86DB98E5E65C733825DB0325407E5BB059490F2E9133F9B4AA328976256EAAED2FBC59D00288D4830D99731A3AEF36E5BF5239F2899C500F942B80B00C3B33307450FF0C105BEDB7DF84231C5D24C3C3475AE2F46336582DE93AADBFD385C824F21362C19B1C6A75F56B69297FB3084B6164204E2348CB1D7CD3AB494BFA7EC8FE346251C874085F803BD7F4DDE1995F0D3D17033C461D06B49ECCEEE0D5312C3A435AF5BEC9808ACC524599668AACD95ECEA7EF07C4CA3FAB1CF964FDBA987C345046E6507AC3D372BF07D72CAB816BA627C2BD452AB8DC3044A7F0A01D8C0EA47904A5DD66C6B7EF9130D628A4F2CEA5A0D05AEAB7DAF2729C1041FBDB3C2D17BD66AE293C03E77A0837419471C29691EDFB20CF69BC6260975089AA437628F140A44FA2E2967357AC1BF1345E4208C33CFFEDE6CD634B371E7745143FF848F77E5130D1E0F51868585509F9CD3B906EE0A5072CA2E908D6765C74D9B5C35B6BA784A3EA59D808ACBB1C24D6C088CA6C9E17BCEB18337A4DA0C1DAEB5D51EFB35712A475D6C5A2EA51E93FD79F7DEB127F3418F354DF06489E10B42BC1F20651660CAEA17F67F306F48E15DB7E67A1B56578BA7BE6C229FED9567E128D48551E6EEFA17AF5B95A716555571F44FBC41AB29208DB7C1846E130866D5C9BE6F73E601C55610DFD0F67D98933D252059DAA1DEC20AE0E5BED6568A6322322D8A40E6835FA66E317733E1B465434532EEA8FA76886B600E06EFC1DA41F8DCEC0A5E8BA8419F0B7879CC0A93BD14D99608B5BEA931D8971DA8D2D89053E1DE40209E257E741BEF48C17FA15467F1312A368D4A061BFC76C2B7BBD900B4A34DA51B7CB5BD6E2FB08806A53C0D60273167D822FB6982785F2C3B0EC7D893B615724D0193928D0EA8EA2A1DEC5ABDCAA904C754CB7747449E87221B3D86BD5DF26E11DA753E768A8B481C306E485EC91074377DFC68BE74A444906E420C2D8BCCD84BE13AA5CCD11115B669C89E9C0CE374BC4059C696E5F8344FEE467AC8C8ADE37DAF614992914C763D971327B60946943847FB6B82672CC376B780953B6F4433DF69AC61E110FBF1A35F6272561193D8652EBCE3291333FDD4D84B9CFBC60A57E1F8B817E84EA15D440D4A4B4F7E19C08DDFC5949FE8CBDDCD0296A62F12F53D48B1288B80E24C756FC38E2FAE9C7A3315D1C6DA42AE838AFBBF5569F633A68289EB7073BABCB210F4E08856FA65057BFABC70AD3B58C2C870DFB5E1B0D11B6FA6D5BBB68285D8F9C21BD89669781C9F4DC32EB1EF58B80B1D371334D36FA66A2B3DD4B3E4DEDBA7AA9FB7E0245F5FDBB66CDA653C5232A131EC1F0C21DB1C47B990A64A24DC8C4DA951F419F57C03FF506E0147C22E99461 + +count = 33 +seed = F32C3715B0BA8C1D0BD59F0645E9697DFCF9AEAF761A71ECDF9672215B9F138C0502D7214F6B1BB4D6612432F9FBED5E +mlen = 1122 +msg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pk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sk = D4FA14DA39548392300A41BE413EBD53BD7BCBD045B4D3C8CA44ABC9599E269D8C98F72EDBE22FF0 +smlen = 2086 +sm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count = 34 +seed = B0C7530A52AC9F561C2C14548D3A5F5053396B738EA1C7A5190F5AB01C9C38719C4DBE856E42D37A114FA24FD5DF5081 +mlen = 1155 +msg = A4117808D9D05B702483924E99623E778E7A3B7623739AB7AC488ED93E711EBDDEC383BFB7E06086FD0C374F4668AB744AD99B8AF1C75309B60F55DC03FF7BE6F23187FFD5CB224068568CE2D06ABE441557B04A5A0C2858C416F6F7AA89A96ADFC2AFC54E0F31416CEED005B7B140B342652DAC7BF401FED4D94D475784936FCEB4B4F334BB14BA55B1EA9A36E2B0591287EAF4ACED997162691A96E7F59853E609ECA9A225F615A49A12763D80B5DFE6F8638923C39BD652936B19B944D5116F790E866A61947EB60CD1F3A1F319710D0F40E487EFBEF51FB4D00F5DBB94810128215F72B1AEDD74A1B1D237088DE3098417714EEB67D6A3E6BB647B6B0AC6D0BA3089D4CF6252B69C414E2BD6614429B6FCEABEBA50A4B53C7394652ACF7DD9403AE14436ED5FD4D1C9E238A8399A763806FEF5C3742C55B7159EBF5A13B271428F91229C191D617808A26AF9190F9D445BFD3B273702BC3E7F610854C8E86066BE7757960A880CB6727CEF19DC7B464C464A7DAC9AE85B799747B8488A4123B6BC7F0F7C2A8E53FD4F8687075B4E25660F5107ACF22CA688057DAE0496FF15A3EB9379A9F6E22FA43C932F137E389478C05DB86060686AFEAFBCB9ED79AE194C4146A48CE5E07EAF585279313851CB864A50075AE46C1AAB3B3CB920DEE2652F5AFA0138051C7C980946E8D5E18C16789CD184DC5598F65875EF43418DD56E11DEFB5A4A6AFBCE041BB292E0E2EC563296BA4EA6CBFDCCA32A18C8AA395515A83D0FB7819413E5AE056FF0EC2F63F1D52A8BE0B334A628D00995BEC7E46A34BCD2DCA0E9C5A88E0FC8C43843D6AE074C699276293FD8DB2BE48885155688428C2F5A6C6C91BD4A03CDE2126205F9EBAFE319D1B4F80277FE99211A09628AD840046EB9AA568EC71252CE9F69827B677D9C0D99546DF5A48A8D253AC0036DDAF4D045A70F94EC54BF5F06296B2C2617F2B0EC0B8374DD28DE269FAF739B1E55AE1846F548FB6C0403C5ECEE3CF9D1927E317F0D07E11AEBA01C240FE17C6660F7CB32305AF1EB6DE4312FDEA6990DA4E9135DBC0B88AD0AE0847E1576F3C2711B785B846C7A4B823688E4218596CAED583A90DC46BB9B27E00E4C1110B65F77E602F043A8441563667691C07162E52A53CD76E2D74DCAAA2983BF2E8F02CC30B05BD4F9AC731931C59F9EBC038FAFB09FBC886F4C4191352206BB49ADAEF9D74BD08A5B780FF0FA301343F5EA81D36912ECCB0FF24BBF0BE6A8283EBDECA79CFB22639DA38C9C639C4BD66FE5A75F0414FCC1455702856E6FC58344BF02998E17E967183AE920B7E04F58AA09145D6DA79B65EFCD18EC55BB9CFD53914F80D73C2B08BB754AC63E4C82D44B72376A544D97394B7C99678758B15CB94E71F9FCCF674B29ED5AFDCE452959BE5AF510D57F9E5395A576EAA1FA7BA9AA4122A779727071FA485C005B447760410DEE20B7C2299B4A0D5D9E5E4E038A19C87806C3FB875EA5BD7F47D034D7D5FEC4BF132B04E47574172D392EA7B371516190AB81C67B45FEF6332848A51B6C7DBA90C410A44E9A88AC082FE296A7435E7D2DDFC645D5AEBBC29620525757DAD1B0222159D658C7225D02374EE6AF479FCF1AA28CD91B +pk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sk = C796FD12D1FEB1DF46B162C38292684C09059E4463CB95DBDBF498A4DD4F7F002AEDECFA7A0388DD +smlen = 2119 +sm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count = 35 +seed = B2FD7BFAAFB667C9DABE5915C3BC271EF41F18588666A6F4990C09D098E62DB590110DF6A56F08C5E0DE65B00F91D60F +mlen = 1188 +msg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pk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sk = A18A366A5ECACAE4732DC9E954333EAD153203013BAC4E3C50BEE15269F983FB2F803BAD1F10BC0F +smlen = 2152 +sm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count = 36 +seed = C08E846A8E039C8655651919A8433D475F494899FB617DC3B4715DEF0C992C195CE38158B7FF40E0684B30FD7E623265 +mlen = 1221 +msg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pk = C55CB4EDE59C74A69EEB1200A8F733EE15933571E61A2D1EDCCBB27E9343DEBC87CED231D5308655EE1FE9CE49165AD7B7219C7E4920CC872E279033FB96631A33618C803C345768EDE00D5D2C6A03E0E6691812522B8D879553123B5344E7E5396047BD0EBE47C9D15ED38FEE59DDD0462C81BCA9BB7931D33CD42CFCA22A57F196D8FCA6DA0375F820263B20521FAF4FD096B78291489A7F2A6CFE78FC879504F758DF7542E2BCB5B00DEF7D73C9170B8E5A12BD3273AB3024193E0E929F12597783A2ECAEB87A4A4AE333CBFADA9909BB16D43713D372ACC6483D8AB39DD2395B0EB680351BF70542DDD052A877226C7E0741C700B6BE3920AB37A4DDA2D17B21B64F156E59CF492400204566E08A5AE4E52162EE18032429D65373E5C94D81BAA5DE7FFCCD2377B6146AB9A8DF2705D68464C1324D1CA93B103291050E2F71919514EA0FBCC22E64480D9DBB2C7E148CFEED12492B28D97B390416D6CAF2E26C08F4D63BF1940D145A3CD8871707738F70C9BEF3EECD0BC09FAD356E16667175B9126915694C4D117BD82A2FEAD87F316ABB09C971C4CD625BE13BED4713EB411826CD42772A9DEE91E7522306BB302D66756C30278360025640BB6BF5F0BE5938F66BEF5B6C90C887D0F36C0E1BFD3A4DFADF02675F687471BCDFB38D886F42F7DE14240B005456EBA2EE0F568A5A0AAEA0B1A4D60457F65A3D88CCAACC17F70F7FE6252A9787FF4A06D3577E766AA560BD20C97588F53D33E0A07C51F2C1636605779B255D54181781A20129061A427B89605AFCB4F96E0892B9C62C2A2CEB998CFE42386A8419648AB4D64DD19DB2D46D3D9FC8B8BED2DED0E25299C616AE2B16330C621E1D43CE8CE47AE91A6AB70223974034589DF091BE840D3462D5B3C146B96BC8C811E3364A600F35A8305A3312730183939600EEBB195ED0C8672479709ADDF90B95A87E2C1705066740B728FFB4FE584B80F1D92F13EA2B7AFE18056AB00FD5C19E2796F51A71B5FA786308DF396C45F53FBCCA415650E22D30289590ECCE39D588E5A136C017C1DFBADFD2294681639522A659503C346BF1B652C2DB7A404D6DA302357B3E8C970F2C7FB1A46F923F6BA5C4826B349233511FD23C77DDC5D75F215E5BAD118DBF37F022A1C8DC378C13A96DF7169900831D3D717DF4B12B59714962B2E609E4B6D3E3FDF5AE9DE415F931200E96844C37A2EEE5F1805384FE403F108D381FC2304CE20AF0BCFDF2246F81205C998F9A14DBB34F94BB2238BA36D6DB93C5992860B32273DAFA3605B5A662FDEED7F011E34F2D9C68EEDCE54514CC238798BD255B03F32D82253D0CF960959AF366ED247F7CE60130BD9A8F688FD2400477A865E525E927124B347BC1AC5D737611ACA12141A47D305F11360C86D0C3230983CB9A29B070DFDADA2D453404D45D7111DF27A59E83148C64608A702FC5002955745BE6779D1ACCA9C4B37A35491A115854C2E5DF23265366D08C20EF95B67BDCD65E07A9E33CDF7F45BB2EDF4AE976BADBCB246F7E8A89205B4F154C812A35BD25A10D0A917B6F9B8572E5A7B6E066EC8CE42991805B031523814977530AAF508A3624F4C26569B7CCB880C251522006AE7D4BE65ED2B985B279B356D96318684AC15E13D7E35CB3728EA58CB83639263BF18BF3E045855A6CEE876DBF3915F0DEEA86198FD00F04EC0904F9F467609B7F2C6579A3DEF61C02EA963E3A87186352CA99381424209AEC5DBD701C8505CB42E4A2F11294A8D622F8E94DD523737D646A86A4A18014C42963CCC02548D2FE933CEF8954474E5A5501CE6CC3E1AA59558BFE4A9C4BA7AA0E5F5F4F7B27C2DBD82270882C0DEFB8823CCF1BB7CE147BA6F78D4FDC927BCA26EFA7D58285831D8D97BB2B6E32274D92C2597DAEE0104E209AFA6163DE36CB038233E8B24BCA2D1F152AF1FD3F39E713DCB1C737DB626FBE7ED2717338B4169CFE8299F43F3F6E39E3486A07660A1049681CFF9F8853668A586ED961E42D66277CD9B7A67AE3A2080D690FFED2C04445C964C71B48C3CF229AF91850D0375B1CB4DBEF9ADB249D87AB176B15BE6C9D8EEC83BAA6937E48ACA9363C23E28B8F12DB43189B6367504C2D0922CD24057795B781617315FF45382033B07BDD32BDC6A5B151CBC631029826E399F3D420B949F892AC5CEE11AA3B8D608767721A90F715F4B4F29846EA3554C5DD9D5AB44919A0E2F1588A6CBC64C0D9F9CD93C4BBB3F95D0B79AA025DF7345B73D9D74E20A7AB049532128BE75A86611E4EBF5B52FADA0BDCCD1D7C29A93CD76A76744794E43579FA1A7F8F089B7C0E0773D6247B24A6D1CFC6AB4918F9A2C9F7D2799A15B128B1E1D909D86357011F6D88C571C1DB46389A0B61C033285E47FE945E29808AEA96AE1276D98A517BBA50674D1FC2E9711941B6E0EFC021AFF2AF0AC66F5363333528D2D03669065811066CDE33546EA0435F500F747904FE603193E33E7C17207AA0656BB1BC52F856FB4479CE2F71361F5B89E7DF084AAF53DBD890FEDFBCD640C488E6BEDFF649F4DF5B4FBB1F0CF925B965E25466B91B8B993625E51F9D7971CF35EB9942D32E1C37A19F375E90892478677DC948A65860B812E68B262552AF986577DAA4B4C020D007BDA84CC22AF4593DAFD8ECE0380E24124197F44C08E5A3067CC57706057BA8B6712697950310975742A77B5B39EF7C9542DE466D4B7951FEC61B99485E7725EF651C944BA3E9164F92E7EA4766B64BB874204E9E231596765121CDC5B297F25DC51C087A77CCD4A5540DDAAD77FC9AEE13A063F37E5B7F3C24C75508C0408AD6C996561B51AA9A0D7E8CCF9CA4D273FF11DCDECB2A39A9101C47255010B35C0E715C97AB920AE007E73833C6D163E2F79539E38874FB6BE3019BDF72FA9F80D6AD006559B7114E1C2E8317901F1A0F1390714BE9DC456EED56A482C3C9CFFEF3714D561C0E9BA9EA79F2F2E76327000F0A06E3155DDFA80FDCE05C733D2450C1020B2E2610393E77C375D5BBB654299166A2D03C1FC169AE0C1F06614F0DFD620FB89D5ED34BA857BD946F77380E6B1917C150DE0C4DF0F6514DD31C2CCDBBB7B1A6BDDE6715E93DC832C2B767FD386A9D454E145220A5B77A4A9B604E8089869D30465F319220D6E3F33FB86F487B97888A6DC28C134E96140A1EF157E44F71721C49155DA6E9229EE174FEB8DD3F43F42B7602B77796371A3D11C68E7C12E30E6580F2BF053547A9F96C39C7DA124B597C6B7D334BE4F38DEC6CEA401D078EEE01FF921B4B07C1E9656DD9871DDD05F8A5C5D16A6CC076F1BAC5FBF6D971303421CDCF83E0C12B622CE073A1714A3CEA829D24AB94A80B612134982675D588BDE2668A1CDDC867679278A3DF67BE6E8D2FD1C463FF4AE41033C68642A07A26C631AEFF9FC70A23288CBEF43CC35EF9FEC452BDEDAB3C7E2BFFACC55E2A7B642EF1156113C67009C5F6950F9B8CD1AED9043ED2FD870F5FC9ED4E254E5FE9C23446CBB12D7428B463FCFFCB37B8CA2B969DB168287FB21A67F1E48B2E47DDC4167E5A82E51325EA7581BC5687A608854D03ED5E87973B3364BC984E491BD94402E37A9B6707E48C2B3E489E7E7DA48DFB82390961F833902F5BDFDBBC8D2888339465F6440639744F9DED9EF96BB81C0F451A2E89F5E25E9DD13E17E1510963BD6747BB1C397E09067E8CD1F19738B7A675435768C4A41251FA8755CABB5D380743104DE97399FA61863704A108EF937392548ED5E985DDEDBB43AF80C1573095DEB692A026470605AABB2CF360C005A763F252AE5F9066A1C7212AE74EF660409D210E4738D431DB97E3877FD3E318C52129A01F43B77A354718C12C751640AB561E8C406BA84268476985863E77068189E569D4C9A077A04DE14009B4BF4BF716CAC3BF581F6091B1BF0325A0F350EFB4D086A3A331B7D9864A0ABC2E119E972C2BB86B6A9A4C40659AFCFA9DB89808AB9DB4FF08367DC3B032668322E9C86FDA4AE31A9C1B573BCB50186A73F232FF135E3CFF6D03EB53123057A95E9CA109E66DD537E04AB78F03C2BEFAD018C5F265AA8F76A38AC5096F6B057463E84BCDA9B3B4554C47B5A96AA22139BC4AA5C96069666F741F5C04D7AE03BEEA1F76F25FDDB7CA42F2C30938F9F85A698189C04F2CAAB9EEF1103FBB5486371A256410A7E3F28D8B9E0C6DB2977D328BD3FA70BC05AD931E3302B6CFB81726A587ECD9DD9FC8BF2FBB6475C313BD6DA279222B54F2EA1EF23A8D3F2778DFB0E5A3153B741163F0B97FD0F5795434B110D25ADB8D7A0D2E74D9EFBD9BD3AD2CCF2D04458405BD0973CF0015128FBD4D689496EB5163805FFB6971FA7FFD77FC23DA7E9DBCE9C61C271679B00977813DA29275629E7C9CE782C48B7F23B5764611A4B3A66287F0EC1691B0C90089FFB771A805B899019C6E4C14D8D994C5160F456678D3E481EB888AC46367FE45E3EDAAE2EA199A5C5DA00C4FB418E3BE1E95927029A704B4D36DC6F3A6F26AA67E7E479D2F46050BD124C25721819618B74BFE999AB26013EB5C03C0FCB71CF88691F67F38C90B59F4AB64275C8925FD3111EDF59258EA8D8505E8D13DE0088C2B2B3BA50DA9A8FA65C3019FC3C957C9C55F1F1EA24420C9B2951DBDB1C9A8DB2FB2F96DCD61ED86B98B491F504DB20FF2820BD4A5EAC4E13454EA80A492B657691BBCDA7CF3CBDB0FDABFF0676777025E0B5B5CA99589D16360413D8592EA3045ACA1B164615ACF3B2CC042E8E789747B29F7A0A01A7DC203F6D33E5E80C3E32C21B5F54E58B1119E44DF11971BC93F0D44C563305CCC95F76290F23387F5DCA4C73EE9F331329B0999C28DDE7C6161B50A012FFA531B27CEBDAE4E5CBD4E1BA03405BA389034D87D12F4DC543B78592CC80C6FD1568B04F2AF8013D64017606E6B975106705E71CDB95DA5831247655066A4DF72D05ABF90F9366A7000EC107F4CF9A598B5B75EE44C28D3F27D4EFBADD6D86DA47BD3AEE5B1B783EC4E779210BB05B380247406B14DE9146FDD3913A82EAD2CEFD0F69D3FE68A03F2F0EAE310633CFB7B37653A19626E0D207EF373E9DF3A4016EFF8A848320D2539FD7A88032D384EDD5EBF5E023F47A9D35C8BADA2CEEB57840EB87026C8617C7BD5000A7AEB7CA0F76CF3933897399460347EB859FBE07D1988AEB27CF29C13E2E9E7EE901F0B999A1E024DCAEFF6637B643B6C9668462B0EDBE568E9F58A2A982654B5C22306808ADE23A77996DDF2E296BC73C48A1B4F625F994484095DC01BC86E52367DDD8C906A69B33236B230BBABDC973624EF05A52A5E1ADF540DEFF3D31BD083D91B45E61F1EF7AF6CC81A839583D79BA95DCEE30279F881664520D7981F26A03125BC522F6F080649F29DAE0BDB148B1766A1B6EE81D96FE38A24D302C3ECC0A00C3D6C8DC41C87F734DD4B533E6456863D47AFD3201C123FB368728BF001B587253F0F26E78BDEE7B61A101D28D7F334E68CEF8878F93C8EA03FD2B45E1C3036F0F7439617790BB829623F94B4461CF5578714EABBF25CD92BB5C511FCCD856A6BAC780EA1CC39C2BDDBA706F1A4BE476C2BAD7435F45DCFE5F9E9BD5184016F694349DD04A2FA1B64C87232E19000D0ED9378868044CD714DD217CF3BFADF2F542ADF371D95AF51B8945C59444EC3685CFD312CBA49FF0B4B2F1D78C1BE72C733CA82608EFE6D0EADE6E117F871E42105C467DC7453E105D9B970EE2573E1B3CDFA5C68050840FB8C6C29D59544D6DF448B32FFFDD21023A1BA01759D460F750455ADF01E7C62F33EA4F5EECF43CC5593167D3132E10152385DD141919E6CFB0DE1B3A025018196D0D2ED2ACC0B4BC1C057366D49301883322BE4C70B4FF19865A1B66BD5F054C99B0556194AF618824DBD0BDAA4A2ADE231250046CF98F5BC9F1ACEB7D64B42B3C3F2E30EC5AD2BBC315D873F4DBA35F6A21FE5C6D76B58745583E844076573909F6507BBAC6A2D7975FC9967DD1F94D8014422D04CB745EF0A1BB59FB0A92D868F2B0561EF6B98FE267C59C39EF80F4237234AA0864450E4D40DF691787A120A9791FF0384F127BE8238E66C2D86CA42AA9ED39EAFF7278A93DD0F95A6749F2F301CA0EFD470100F790C138E2DC4BA5D7111A4C8F3CDE2234D15F2EBCE40E6830B528240FCA1D4014EADE80DD048C6BB90F87C4A524FA74718AAA44142DBCC1B505A2E6A85920A36DB791BBF4EC11935D3DD315922332B0FF17C01BC96D7A7B844789732715FA72E8E7BD2CD2E2A73514C879B1F1D79D0110AA016A6919AB36FEAF7962D1ED382557D0E5342098592F9194ACD65A4A91FDEDB0A10D3488BA8D1B6DC7BEDC03D0E018F8F7D726AA73CE88D8C5E0E9BFD44502AD2061D06653A4ADCF326D3D89C40E6E9284084CCD19B9E3CC9CE60FA23E1613D84C651B7EB3953F58E05CFB47B1349FC040711905651CF8FB56165CC0E8F7D1D1AF2D0CAA1635E5085C001A9B28CACCF2D4F52159BD646DA480A4E84419DCDE213A6B4E122364CC070149DA414047A9A31661B0C8FE788A239F41AF98FBC4C78C4D87D2F93564CCF1889B5002802688078F6D779FD323A057D699A62E4C9EE4BB529B38543575BA6EAEC9D28699FA4D4397AF083ADA84B00B09808B11352B43147372F651E7915A4BFA593A76762A374CDAF9E5946CFDD7574DF931E902E2EA326898A1D766329281D916DD5643F788A60D5F0361EA455C53949B90142C3EC29EBC74304745DD32C7428AF09C972240581EAB1D6E4E64C03CE99CA3BC35B9C512E6421723347B060A3AB82931008DBD92BD52EE73CDA3809A00AC78088FAA63E314EA12B8BA29DE3FB0BF24632AAAAE999C5C56D78E5BAF7ADF2B634C47C6ACFE296968A787A5B9A394DCFA48BBE93FBA3EEB0D4539B4460ADE4995C783223465AC094E887BAD1E8F84590905955C688075699BFD75848179F860E79FD0CA2872DCE75036BACACFD9C11BCAE43E0B6A307998A634CAC2E07E31EDA17A8C4B76881456AF53C4197E84DD5B4B093C60D88EDDE1A05DF406A38ADF5574C2344FC5C9CDB735371ACAFF3418D35A066BD871F3404D3D8E76EF16A64CBA867FC9A87E61324B857ED83B8DF53D970A64B077CBA09CAB3F18572D35464AE1F5960D5E1440DAF6CCCD1BFB22F9703DE2364A29489D68B98F523D585561BCEE4419EDB9925F41AE083B8CE40CB46583599EA00CD7127E328AC535B83ACC1BC5F7B94462AC299890F392D20F1A26BEF848FFB3B90C44737D2A4E4A7F3CAD68BBC909ED8BBE02AB78933332EE59EF6C0831061837931AEB0F84A1C0769BF8667A9048ACF028E3CF15C9A2A4906816E75E17940FF689272B3CCD792E636DA74AD0097C3AA152F9BA9D10E4508F9B22FC961648CF0AF2A19514DF0AC2FDB0075C98627B8E6D22F3C6E3A9AA32E197BA59DE149848F3C6C374F966740DAFCB2D912FCFEBB203F4AE25AA53CD10645DA5D27CE04555D196DD2E01263CCF7C53FDE3C94963DD03C04CEFA1E3E3C314BC1636D63DEC2C08F49F07BD00ACA59BBE47B048A0E6D23A34CC243EC00A5122F9DF69FBE6C7E63E8605DA78E258BEB9FE7918A8888E1C16264D2A23F22EADA2267728431B9D26871CEE12F68ACBDDF7BDC5C734E764EEBFBB26C44EAC6C078F101AAA4E4773418C2184C4819CB26A9178817AA70FEC09B405E63F68FC9DE6BD32690A1075BC2128A7BEC69358C2CF6F999238A93CCA7D0C1AB820C12FC4E061E4E2F4D02C7864D4F86E3C94D29946D11E45C844F69B16DE5445B5B2C4BF85CF6ACEA0BCC37F5A2E11FA1854453516FE94CD723557D9754EB9E054532DE23305630F54327D8A1D3959CA2A9 +sk = 585E714D565AA66078BC2B12699F1E86C6FF30A1ABC8CBD19563BCDDD2F1F6D24313CA0783539AAF +smlen = 2185 +sm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count = 37 +seed = 1D9C060EA0408A068BD982D9694D39D02BA5A473378F6F9F09349F686566F331E767263FAFF5DC0E823BB6F648843876 +mlen = 1254 +msg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pk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sk = 662CF70D3D5E95A9C6A33BD7C6ABF0E8CD23AB2D2D9420878C4835DE14A6C606B33467D954680625 +smlen = 2218 +sm = 6B27E59178499E9ADE0B6275BB7C3F68E16A481E2AA5AE725822730077A4638BBF0B8B9205F666CF8992B85327EBCE4D9F9A3D9C9EF48B0CC5D0C3AE18C76E31F4BE83A04DC240F061BD47BBDB05F707083E589BA2ADCFA34B46204855684033EA5A0F4415985DFE4AA3508EEF747ED7BD005D11F73B9CFA1099C3D73DE61ABA6F717163A05792F1842F1DB0F7B44BF9E432427B1A594518E0B08ADAFA1AEAF4A0B49132B4CF22AF77F876D8B9831F0650F72FE48B49BC1265D681623CFA9F699385D4F55BD3404E04066EC203B81A98F2594B5AD90CFD356D20AD9F1B02347C39EE8C5F814B2B9049AC70A29FD499ACDEF387C64722CFFA724DAFEE3E04FD7BA36C8A78189AD2525C9765A198DDAC58D81786C8D0597278B3619B7773C4D8C65940566FD4F3FBEE3EE9016FFEC6A1064FA865D1B7BC4063C7EC9A13C1FCA950A2EBFCE4A9D9738119439DA743EEF474A73E4213A44C4D00F1CF6115CF6A695C853D4B931E19BB481FB3DE183D878E3D75C46A77E136A5399BBE0C3EC546E584E9F52256B9EA68A9E70E1615A8ECD27EE451E2423FB4492B9D28D0F4540144B4A8E0F56D4A7E18F0045C6F451D1EF9387A72CBA46BA8809B8C1D0C20102DC4D120238B90A2E075EE6B4F4DC58C2E6F99060F4CCC9474A67BE204EA40661E318E9047ADB4FBB9F5BF4CADCF7F2F34CEF39E932226C8F876F6D3EF9C6E97666B73442CD90D127AE579AEE695F69E279F4EBB00CCE346446D88B9018EFE7E753EF8EFF06ECE933A4F4A3323C7CFFD07C6FD8DBD79B08A701A192CA3D2C0E617DD084E08D894B1107CBC54D5D427D2A469A08EF3B90CF7311BBB1E98A5C0B913A3F11AF4E33A6D5744E97B71C6F043C5F07B147D804F183EEA22388789FAE578193FA53872E5B110A25568FD0E5141575F4544A2DD8D1E29CEB0ABFFEF9403A199AD1638F9BB22E44C99E85B56959B647B2E022A51BD2F500BF7AE5ADC2BFA913973FE2AD5712222F82D68BD5456118BF8C3D043C1F3F6FB33C31B00CC11BD3AEAD932EDCE254C0FD708391A3CD5708D56C4C90ED9EB5CF9EF247EF71E8E778524118B929BEB721540FE5884F835BB0703D3744E313E6B22E86312C67E86C762564F13CECCE139FFE799DC2C93EF2279C0D0A4EA11A7ED09B07091C08853BB18B47E7AFC54B9A392827E5E7776E0B9B006F69286EF25B0132D3779F58F5925C732EB10E8FEAFFE8DD7AA52A5CB1E99B2A0B01C700F336076808317218034745FAF2ACE25AC8111260732CE86251C699BFFE8D60D9E09B6A5918D54A3F91B11E08B0BB06C3E2AFC8619687F0CA6E5BBCDB4A10200EEA7CBAF1CC232304632E73EFD82E25B55083382E87BA70EA986A044B0CBA2EAFC3316C1AC95A5F16F6368C210DBEADFAE6CF2382DDF5078AD594CDE3BD1A837C517B1A20A2099D938DF6AA02B6C0E62FE6147C904BCF3EDE51DDDA60DE7887DFEB2866DB402D23E5934A74C9CE4852D4B2F53CC9BCDDA312964A548F6F7C8320AF1D1BDBA7FD32EC6C86BC3FCB4205ED3DB092FDCAD9AC4D2B8575883E13F69D8C16CB18D1B9284B31823ECE917C905C5C8B9D180C1BD87975871014F773FB57D402B8FE16EE312692665824CF0BCE4509326A31957319364CD421E9B21BBC1DFF663ED850858A2450C2FFE64B65E009A3999CE4504BA5313BA0EE4A8843349C30FA6E59FD3ACECA130A37C04F9B64722608768973996112684B64D0C87BF95E5DD60661935831A6A1A9575EBCB2F64A15296BE788C775D80523D6BB4267D91B0C71BA5F90DDF1933DE898E79FC7E39D0A3D146F185214468DA50AEB47402AB542E52CEB768A70CB1F749E4164CF20E549B674CE965FFBB98D874D34B5B7851E575E6C1E4DE9C170A10DAB84940AF055A951260B0119F5ACBA320B55CDCE4F16346905A2073CD9FEFBA95734E4F4DFDB7A33F292D45698831F1D3E9FBF56D9692C14A8F9887265CBB4441AB331D977E3A68A1BC9F406AE0FB1C6E91205670641B9868E2A987BACEEE2364FDB089A63B53976D600BD7A8AE88A02872E46927269D281CEFA385C98CCDFA6609394943FAC32237368C6203AAFABDE072054AB5A14A91391D5A943F4ED4A4407F275CCFD15FD28F1AE0EB6EDCC6612E3436572919E4DFB57C049BD77B344D8E04152863EFD4FAE8FE3A7230AEAAAF82870820085F4B3EB5215111B6B8952CF2FF468B3D10F3AF849F16E190E9560F40B05E6E2204591B58A850E2710F7043AEE2A44A6D4A108CEEDEB2D216E51102DD08751925DE6A7F67BCA1980F0789B34E2F86729621F2285C5D3A036CD87C76102E9D607C37CCDAC8062CEB961053F3195B5ABD88BC64FC65F8BE34166841683F1EED291938F75DFDB3AF4FD2AA98CE95382ACFB5D5DFE6EF243C8A0B19B80584FC0CD533E38BD485D1C52E0EB5BFF90C0A947D9B9095AC1C0CE9754EABFC860990206B981235C7B612DB61C9FDEFC0F14DBF68A8A0EA4986CDC4AABAD6C218559E11CCEECD804EB98446FB33EAE47C0388BD8972DDAC02CE807B707D6D188CB31A1D76D44323E93DAC4F8ECF77E7896C052EF16009CE4D1147DF84FD5785D95D77310783F9AEFF1DDA693F4BED26457ED82A1CEA19D9C4919257E3050B25A7D1CE7561740DDAC3FD93A607C79875E050E40498BFBCCA95BDB3D0FE639DC7CEA80E3DAB3AD73A4265F012451C1BCC2FDA1E1AEBB7FB18407F31E7496E2A18D2C686B47120688240A2FB134A3C314D4CB422811E850524684EC485E061F7365494A6403AF170DA461A3BC32FFAF9143D5E9B17B2285C56977AECAF880CDD34F26120DAC4C950198233A50654EFACA6EA97333D2BBC024A5E668821D20333DF0B712510100AECAB6B484CCB7814178F851A3E6BA0B76F16C4685D5AC8BA48558D382ABECBDCF0B919C1ACAE46EBEB5011DD0B3C22B539810720CFBE4CBADB111E100C09C811E724A67C66A1B89EED1E7218861F55A4DC55E236C6E3521DCB374437A14E8000DBEBF0F7F9BF409AF952888675C11326D9E3E8A8828BF50CAECFF96075CF29446CADA373529D310660CBD60C042C143E1736FE7AFAF6FBE42791A8DB01EC0475145257FE2DF766D4EA972B14AE5110B8F8F42D659383E9BD76 + +count = 38 +seed = A4563D09AD21D3916BF4636301F2E64183A8F003DA186753D7F2DC3BE0089BA09C62B8A52B72C2C8451213606801FB29 +mlen = 1287 +msg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pk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sk = 1924A71628292AA3D2D34EA72E2BFC2520864205F54EC6F19F7714733AA34CC9BD7B1F1DDF057A23 +smlen = 2251 +sm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count = 39 +seed = 811A8A2ED2917CC616FAF246C5F9BB902E5FBF5430AB078AD6CE871CF8C160512A748216EFAB3A4CE1271AAFEA12C11B +mlen = 1320 +msg = 061934748C6758ECDEDDF3A2DF78574A470621496CE3F12E5E4555FEBCCC1A46A772FCBADEBA8B2EB5231B5B15DEDA5A38076C737E5D091A8CA8482F84EC4A20A51DDDA391088F2C3926F8E1D8B77DD0ABD606E9AC25A17A86A5C75ADC215C5030355C4A1B307C1CC80A3BC4A7D4B4044FD35D173A2C7C081318F707828A3438DABE0836C2D6C14E1643F05EF8405531D5594411AE4DAC6F3992279CAE379D7C1762B122037301D3FFE8EFD1BEB4E027E055527D485D0871F2013E7B25CC26531C2CA6DDB98B31F0AC2C3BDF400A0BAE942C9D4C4003F9952B67AF67E85F572EDC3345A84B6DC3CEBBAADB7E3C876AB2DA16ED0EACF4858033BF5A4F739F9E083A345C2BB5D8611DAE90D25AC45D8B3D39B4DE584CBEACCC6F5B6E61524349B50E818BB6B03C7E5B86795D49324CE6B1603791F20B3500A1B8ADE82359263470D777B35DBA38276096445842BA5D5E960FB2AB58730F970A15AA42D9737C33BE700127A7CE7CADE024D3ABCA59CA49F9A7EDF44DB62CCC07A595016868AA97A140178DC92530EFF864C24954464BA886DB7D74BE7B540BAAF807F1AEBD014680FF4A51E16E1391E32069EE823F3D23DB72244D657233578CB7D29A33E6EC31DF1FDD43B51742CC30EFC54BE83149177E7BCDE4450DCD142EB2CB745F8865DFD99DC84AB92750F1CFB0F3944E4E4EAA41261A1E8C58D9B230ADD792DCE20D2612823C0FF9F82E04B61E48DBB83F1A6DD5CC7F92BCD0A37AB3053803D1188029AA1FED9BA04F4C961588C9AD2BA7EF1CFBC50FA69B799898EB0DFE9668260CA5680F91A10D2BEF8F108AB28FCAB693ECDB942070D2B9B8BBB22609C8395C23D7482C31B69B0F555B7C079D3DEFAA5FB302ED92619C058ADF334E845EB1C6EDD903C0DE2AEDD3D9830943F8BCC5954B65DF37C901A17EF13FA75B0F2C8C1D2E38681874AEBFE90B463F2CC7831958FDC0DE0446991EB3C3612CC00188DFC1078FE458D2E5B80EFA7BFCE800C6B4CA0E570FA5858859633551DA28F36F1FF418A9B7AD18AA89B4612F9D676D5FD98BCE6F144CD7458CA9F2BC732A36A4D186EA290A009A870DA3C1F60617D56EA7554062367121F3E5E569503AA573B172C6278DDE5AA4CCDA79D9D8FAF41C6C9040C1D1D3CB78B41FFA8A0180395439F0D1B72E42471A9100973AB3BC7AEC559D94D2D6402374BA5A584DE168395A156324E1E4149ABD35C72AE0F79863CB59EE6BA22145E36E0D85D3CAF8A427D38C96CE489CD0AEA20D7960608C074CE3CD0494B6D6D5EC8895F0F03CE78982AD8FD6784BCF16825286C51325662F34726BA66D3A91EEB598124D6755DA090EF863FA31CCD5B08909A3279A35CFDCE24D2BA16F42AD280B029A0E27137A671C862B0E6F73FF4A1DE320C4DAFFB5CD4AC3522EF1C10E8A918005535F355CE6366B43A757938594366831DBF7EE72F311BE4953EDD1EA1C598960745D3DBB7F1E2D882CC063BC0791D18C6376A8497F2F91389A13AA96DAB78FECA081D761479848A5B4CC2E3D015F343B9000583E95E785A45A06842D7C6C0FE9AC4D70F085503D7AC954516953C497635AC8B7698BB784F73FE6E7F9D0AB9473E828168DF4EC142CC1FE18FA067525915ADF0764E44292A0316EF3C0A443683C92C4661409589EABD7B4DBD43F54317AE0E3D1C69C35A7868991FA0BC2F83430D89821B91A08DDC2D314A717F5BC6F3D89DAF163AF73E10C61630139E3FEDA723FEB2EDFFE6C7F364FBA22E6AAB75E267065B5E7575946C56265743816B2CF12A106AE21921E3E92BFB7FF80E105468F8409D6698E8660B5B05F3F4BB19A0BD4BE3569D24F51795752BE74C429AECA5BE737DE8C01 +pk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sk = EF7BA21809AE7E0BC3230B6061C5FEE206D805572CF1345198E1EF22A8FE7322B9E4DE31C0355EE7 +smlen = 2284 +sm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count = 40 +seed = 41CC9DB2E90239AB5158A2628E7478D0B3512FDF84CD27A4CA5FE3119A455C22045F198C3C5C39F491FB975BD1CFF7F8 +mlen = 1353 +msg = AE2638D944822298959F47B2173DE7D1E58AAA622296AD4A4CB67EC7EAD8220AC2F171605BA2D08AF3D6FF5849566EAF96209E9E00CC28EB9A517CF5061545AAD24CCE143A2EE1AB7CFA259AD9C01860B33B0036F2CB3A5086861212F408C5F055D226CCC77CC884452B2670D89548EC1C6E98FB311DF03979CABF725E78956AF185447287BCA2517F554E9F25E19D93790318EFC5D2602FABF262E5C7FC307E5A991E0122E332A803AC4A91B318B30D79394248521190D2BE326037A89FE918D139F763DC8DAA2C3BBCE53F04809F0D97303F2F1B88B572B3086ACAF38EEF36B4C0791B4918204B0E1E923BCE9E3BB1E7BAA07135B176E266AF174D5DF26C44842CEAC4AE4C1CFF05557DA3DB8651261BE78D766699B1891CB825FA9A418C45BB9F7F2D347F3F92F9529CA6DB94E2FFCC69337FB3690F556C5A44CBBD9D79F60AFF063DE68B14BD2F4B7E8CDF94F6C2F40219D27F71E8AB3D4D6872A5D4B82EAF8E3943A6D425ED04FBC5C7596AE929AD680B245E3D6A7C5CCD7FDFA1D14EF0F72B9BAAEF05B7B84ADC02913DDBC76D5FE80DE30527FFAD1825CCBA34F8587C5B0291471D6957AD99C5FBCF3669B4AE5930C8AF68305C2D3E84E714CB9049A9560A3C94AEB95A252F69B68F755DC0E0AAB52DD054B670A275BD2BAD7FF8EC0CDE6224E9A0EB537E95DAB992C382D6B03FA045DA402CE7C5B55138FB400D9E86AFE30923AFEE82C4528D1B38CE16D33BEB47A96C18428D919BA98C9782806D6F4A40B52F7F0989337C724BE24E9A5430CFEA470D02EA36CA479FAEAD94A74049898D1F1BE53D5AB8CC0CDD5438A7C55827131DE264AECD18E5F5F2F9FD60E8D2D6F55BEB27EB77AEEAC2A15432A5F1467483BE6073243D0165A6C242FE1BD7B7AA701A0827F286ECB51E4C2626DCBE95466BC94A7E2A09AB334FEE3959CA31974B6286E2A2051653341623CF3ACA65637DF657280B6025DB0C0377EC09E6E32010F0F59711A30496695D23728319DFD0AB5F3AA69025276E68808130659D912A53693584188E310B1CACC41AF4B19FAD8DA95D4B35E2569053F553A9DFCBB8FDEE1455DFA0E4F5E94324C86A24288AE27F3576AE15FBC8BED49BFD8521D77A61FB523BADF0E3CEE53799016C6EE4E1E5DEFC19C7717A5C41ED8FA6BF0E5811BAEA76676DE03767A607735C2A48BEDE511012EAF1F79E4D2C3566042FF2C63BB82FBB399CE20E1F268D3844BB473AD7366EF86D064C5BA080FC0C01BDD2AD343C5367D80D2A058CF40725268CD34123C219D9109780335611B008EE3F8848EA9D174D7B96BD2FD9A04FA2B550DCF0B301D64C0764299D317DCD0CA05718A1AC008D86FEA330095E81567E83BDE31A0D635098D7B86176CE6CC4025E8628C73B394D9A45B09B64BFD3A424162B16E1ADAA1AB60006847C6D5CA5733237A330147CFE6B9170D7B88834BB79F1FDDEFCC0EBB1D4FEF326E28C41C919607BF12AD112807BF8582933DDB096F1F3E2BCD6BCBD844DA317CEA2A7688A5FBBA14D84C537814EC2B171ADE28ACF83EA481631B968C26F8D2BF2C5AF7D61A93378E1E23FC756E2F0EE79199475AB4BA1FBC55D9ADC2B05888B2910049BCA98DEFEFE96CDCB67CA9D4AA5BBFC6CA0ECBB78BF29035D158DE2A1708D98BEB85C70AD1C64B39B387516073E2FE85BD9EFA25CB048C224E0EF76547DCA67FD66485A97EB5E56C06C78FFA08EC1C9C6F2380912A2585CBCBA2CD702CD2B51022F63EC920412989BD743A8A8BEB07241E3E8EB38CA14CD400C83DBFA6FC8E04F58529007A1477E9613291AF877692E4CA9AE118A1902AE7B4AE7DC2E992A6495CD19DF32CE64131A8D8C41969A8BAE1D870DD5F1360BA9278D5B76E746FAF99D526199E87A4B1D3A5C48A33989F103CFB2 +pk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sk = CB0B305FB54E1CB23B63EC1F6F4689137E5048D095FB3EADC854C852CA86BE939FADDB925EDAAE89 +smlen = 2317 +sm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count = 41 +seed = 1C13369824A3FDD41B1065E17297574715D9BD9CE5BB733D36D22C31B62BB1033989A604D78BFB1A0746BD4A2271FC0C +mlen = 1386 +msg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pk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sk = F92FFA3A36F43F9177763AD320FD651D9357C6D99F09549FE6AF12943B58BE902D085CE4FAA10A0A +smlen = 2350 +sm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count = 42 +seed = 7AD6C7DF00C9E52A75290D28DA946305D83CCF6DE2515C19A8E26850C34C8C2E545E2E32108F13B9C97F87AB68D10131 +mlen = 1419 +msg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pk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sk = 5D3CCE926A795ABC5F6632CABFF8BF66275DCC7E4A4AB3B8399D23E62A28BD16556FDE1BAEA29C07 +smlen = 2383 +sm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count = 43 +seed = 38FFDE9B60DEDB5BBFAD6C52AA02EF6D49369BF276C99E588D796A4F260E0FF0A65C96C35863BAACFFD9B212EC305E7F +mlen = 1452 +msg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pk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sk = BA2386BA92AA89049C64ECFE60FDDBE136815D3874527414B63ED32215F2E06F813C6452A3398E42 +smlen = 2416 +sm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count = 44 +seed = ACC98B16DCC9A50EF57F332D66255CA56C2BB679CAE705B4297F1418DA845861448DA6CC5CC458DE6C6E96128EEB2898 +mlen = 1485 +msg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pk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sk = B4E1AF25E8DC6934BA391A89984A358702BDD36838BABEBD982638703F20EEF82C955812F8086CEA +smlen = 2449 +sm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count = 45 +seed = 8BEA4E384E73C7E0B47381B3063334291A0F06D28DB61B5BF65B01D0A747722E0AA62B81AD46C00C8A5C31494E513836 +mlen = 1518 +msg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pk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sk = A62875A3A6D305E120DC7975962552126CD844554857C2943872A4E524A6EEB58E416D4ABFE4DCB7 +smlen = 2482 +sm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count = 46 +seed = CFA713E4A63A6FFBA43BFB898956DC400507F68AD164C3D24A67B5F8D7548C9DB44DAA43E5E4A0990325A4233089318A +mlen = 1551 +msg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pk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sk = 76AE71DED1F9E73AF77A2FEAE4EEF80F87414DFB7580FB4AE0325BFF20D74A5DBCAE38ED52B61955 +smlen = 2515 +sm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count = 47 +seed = 1F3193EBC58EF65E9E396D69220ADB8ADC729BB388A72CEC9028A094F1CBDED21CFB0C41356AF31E0CF66A3B0D843666 +mlen = 1584 +msg = 139BA17ED7B476DBB1CDFE3C42B3A57AF5BBCB3BE19ED04D6C3072FDFE917ECB9272D59EE89EF83522531D83AFF8B9934A8423315C350D1481A4B02980DC29E1CB83B76623869649AC40EF297B153B679C327BB251C6E6BC169C48ABA2A439F9EA24EF94656A415C3E86D7BCB43CB3717D54D773F1937DC8B0E02D4E6ABBB1C83FE73F1B221C9A359E454C19DE5E71EA4CB8C560EABF1DA133FF20D81785D2ECD935B99F24840761446C324DF81484C5C05045C0949DF8D0F10F942E1B5B79074B358C25B6EC2B0B42DF65D998B666CF1BC568E7D737F22FF541807BE95ED85A9980E940E24D2C506BB0F9BEE32EFFD85A2017DE694F61BCC2B292595C97FF4C2145E48AF8F0F3D71763B4DB433ED7BDB8DBF8643475FB2B9155F0CC6A0048C5546900792BC01EBA4B06C83A0C447EA0CF05410DE55ACB8E5521829C89BFBC084CD86E7CA3D701283B70F78E1CE9C3888AD2689E0EF5593D656285066F319E155F86C0A71256484F42A0C40E7CF13AF0CF77C6D1CC7231A48538E9060A7863B774C9CC65E321E45AACC002C0170EDDD18CC1424159D46BF99D08A28D2DEA8917D28D91A1D6C409D945A5EEA19413A1ADCA40DE9458FA6BDF1E5308EF9E67E1E90E9D92BF19B5351FC49DFF0A31E035038AAEC651C0F20F276E4EF0EE35C14BB625EB34205516D95ABEAA06A7A3BB3AF2F12236406689BFAB11E65FC63EBC5B944818DD1D53C0E7B88CE7AEBAE581D995AE7D8423778DFE20D6CEA7AC0B1B4EFE2B9D571DE77BD8F71E89D9F6A2DC89103B73625887AB376BD12CE89A65E6280515A44A80D6C32799669260167DA0A214AD0FB803930AB1952D93360B54433CE8220B29339DCF2702581E88952A5A1549DBA11F4CCDB6FEFD6D24522F3207796C8D5BA9D1582F888F2500964F2B975AED5D5AF83409FF9720EDCF5CE3FE9B6B586B08DE21956E7970D8DC28F6208A80F5378ECBC506333A1D98C58EB0E2EB0CDECE0F5D16A069FFD742D1E589F546C4F2EA3DA0A56F984CFD93F5F2912FB1D068F2BD7C1B5E979ABCC62E3A0164445398F5C0208E82B99AED1200D36289B1FDBBF03E43995341AED3AD712CC7C7530C751B40B765073EE4E4CDD411AE543AD5E2793F294320E9791AB35AE1697F23EBFA0280B8041859909B0089C101D7CC429408FABD2E073FCA7F2C2886031E9F6A32F2B596A799967BA8A47E87DCC8854D45DDB6DE39160600EB4235F4E3424D75DDC8CCF041AA05B25B5A3811540EA5B77CD8D7D611A63BEF5C26D57475B28E961645AEE0B9C8D47954FAF634017787A21A671493E7C5F1A4C553E0A68DDD726DB1DED4321DC735332FEFDF2A84C22097AB3552F878E304598EC40EB349E1C1AE416F94112A2CF8E8702A4C3BDE2F58245166550FC238E153D10F90652518B1D84CCD3ED836F150F1FF103976E743137DA5A97A61276DFB0C11D071B240069582265A9CAE4987B6C6B017DCD1594024D7B1336FF141E59936EC4CE5410E1B73BA6FB42D35F8999225CB1A135260967F4F6EF2172D53FA6AB6D1A2E3174B46C24BC103BAF69C2128F093AECEEBE8753EB352E2804EE64AE5140DF1ACDACD8F225B3C9A61264245B8E5CF759CDDD75E25E2D790FFAE8421515E0CD6F279D0080A3F80BB2E0729C0D2626B6ACE31CE20BCDA490C7660D04D1D82E6403000578926C52D8F9A4BE7103D64E0F03E8F148BB2236781EC30F6D8BC827C107FCC40F26DDAD485E6135BDC3BB331BE139A07891717B692E23312D0E5B1C41F30C3B4B4700EFFB481A835AB54340269FFF365FF87F58245621ACFD83B7FCC6FF108132D8966F9836544354F7E216FBBB851F390DCE8A72362F0454730B90D35AB3859763AEE35668310FD501C7501F4599563006AAEE9B636B676F3DBB6787317885B0F4A64171BF19CBF2EA7A625E1563032C196E1292D82C7484817DBF78D8E9E478FDC4C92CBEF48D4CB4F0E6DCDCA6682DC0A56C3E45EA0350D9FF88073748305FD7DF3A3BE8C055CB1C55167560D5C99345BA80C21CE791C4A511E384A02833B78E8AA02B1B877A9B8D806978519D716C611DF54AE8EA2691540E87C6E79EB006569E02745021BDC7852E1FA4177E2C3EC89257618B38719CB07B0BA68F600236167F019694959C2AB6FB39D5890CB176F6ACC3B9656E495C07027E3D4DE781F48C1F1A8AA1B41449689E191E495FF3F263DDAAA8DE0DF6F1A4AA3EF1F5EDFE437BB74BA +pk = D62072F78D834E2FDAC87CEF559E4C5BFB5458ADCDA2D1F45B8AD60C6F9DFBEA2336D082B6E5DFA4C71953F92BFB0DDE585AE58FF9F1C205BA54D90008D132CF49C2BC86FE93E154A54F81BFB912B2BD75DE94AF8C726401A955963614E857D483CCE7DFE9AE3C771A1191B8DBB5A128C66A7AECE8741F851D23E47A965EF95AB7AA9D2BE3C48027FC4E7E3D7C27E4C95FF416E611D8F7FD69B918F3486906ABE8A930F19C094EF884FF60CF3E7FC20AE8CDB24B02DE424E208CA8AAC81092F1C9A042E053CFB838B1C00D054FBD148714864497205BEF3149E263E9AC9125AF95C68C54BBED204DDBBDDA1D55052363A7397D23F13CCDE4BEF814C04B598EEED3199570003CB78C9DB198814C2E6212B2D8D064411F6CF13834653BB34C1C1E9D496E93AD387A493654DBDA7A4EB381EA7AD4BC963AABC4E4D8E306CA73EC968D6DDE739C62CC26BE5417FF59F316372FDC411BB42A84F174B7191CCE62C1CC76A346910049A81936710C0760F93527AE4AA4A17D5B1ADCB61EB8A91BBA8296E7EF2136FD172C395967193879E11F707AE026F2161F3322AA4ED5E6DD5B42FF71F2767FDCB4F833F673DB2AE51FC8A99AF01C631C9F93F35AFD1F24DB10FE244AB55343B3958AAD51A65E9F432AF5D6A9C89F864B45522B9EC29F29CCC01D400836E53289439783CDCAF74F78F4A3DF8F5D7EDE25346B1822F46858D1503A0F8A15A5FEEC6C1A74FEFB0845AB6DC7601F2FA0D39870724C0115CD3F71A1FFB185B28FAC90257CD61B8E58A199EA15EEEC3A5B65946190C708F94A7D0992F0755DE1175E672DBAB11B4F056A5CBC80465DB1C40B1E7B8B5661CAF54BA2555AFECB224B860D5C3593708E05DDF0C6443C8952D5B34305B5E3DBFFB0984F4ADCDED30AE07A654FA67F4BC0536C48C70A59C8A887A152F3885F88D2569243A7F2DC8A62BADB7DF04B8307FC28AA7BFF4F5532C5CD129ADF2C3017126A6E490248030D117D5C52FEF824AE20E6CCAD5158139321F0EB3E01B25ACC8C554897588E3820114921DBF97B9A22709BA536BC5F58452E3A3ABA8D52A515762AA51135912A5D09D88F4C040100563A764EAFB8A3F193686005C139CD0F53AD58207E59EED99E04F29930731DA422D926DFFA5747B2C7AB26AADA8BC89CA1CF6EC6DBF1486C8D60E436CDDC038E55498DD9D80D35F0EBB4C5ED3F47FEDEB5C5C49D60EE3D1C09245C759A4E9C26110F50954135CD18890881E25CF0C1AEC8182CB73ABAC8F15D21711970366A36258D97076DA28F9ADB02C3B1AB9ECBB229476B3F3E590661596F3499AE8913AA228A5763EF78B4DF477309DC021D0F73B42ECC78CDB3B4B8406A2B11167AADCDBB2227C9A57BDF967E0A0668BA6D9F0D8DF3B3ADA0259E2D11741D2DA696967289299EA474DA1094114C98B09CA952709382666808BCE24E2309B2E44D1C50BB64B33656E3C96AA94D6D163B86AB7780545B42B819EA98CBB345BF8F8F4B1A634EEE18695FA5E71149FBBD71D36930F2B3D5E4039EE3305A25114E36741A1B2A0C7C22B3DD69A457EA05498BBDE0EE91B879F4E453C879D1C9A64F64F6C96E0C9901C807237328F09AA16792B120F96957037A04D753859588229F14F117B7D59237379165D6A2B528395CEEF584529B01F5195F8C9E8D03680F52B72F0891C910C658A0270A00B11008C6CF756E2741693CC2D06FFD00FCB652C98DB798A22CAF0ACC9717D9609DF58CAD6FF2F8EDA6F5CE580AB9B4E871046656266B8C1C63C5917327E114C99D51D6F0652C759713707C4E0B987762A9646428833C5B26BC5BF9EA66CA50563BC3CE242EC80C6C917B5D1113246D07192CC7347795B1C80B109B542B84A227323B3801D20843A5B5B79B934EA261FE0F11D19862ADBD3592FA1E1B75D7310D0F4AB82E8F27CF95945CB00B62BE6855FD3FF01D2B32E69EAF433CFF6F152B8202F94595048D43238CE1BCDF3569B7B7992BE06878FA2571FA32B00879E2C72095CF8942BC61AD64BC1F9ECC655604FE4421C55A4DF15DC4B7DDC75FCC359ADC7AF792548393A20BD51C6A2864E5EEE846A08036F94286865819CD6F3FE4546970136300F5F2E2F6C5A020C7FB97E05CCC19308B3A2B0203F53FC53823492863879B0061321717F94A988774780A0D39164E63E1732515CBC2E15DA6F017CB761017C3E00078A20FEA5960A15B9A77FC8B33981DFBF5E7B97D7DD4DC02783AC0E1D7A1BB90D442F42FAF9FF6330BE10D5987F36F96709C8178D7AB6EF2059739CF6EFDE894909D1A90634561C7024006E72C20080267CC2567B0DE6DAAA0B64908C31A5369FF4DB79E7D25BABA8BE71C00993ED5FB4026394A3BDB1CF542F0C2DAC3AE3C332B8FA48FDB8CEA175C365C2880987F07506417F6EF2C3CDC4FB670E1294FEADE72E3BE2D5619FA61FCD31FD09D888B6CE3D17ECD518A0D68C7C216A99F936A56B4098439EEA0330C92AA0F31FB5207CE8C65310D6249C28F75158212CFCF2D59DBAF7345F5A8A18470A3133B6E890A79432251854DD27CE9F7F7B3C17BD3AD00F8E3CB992367387DC518C7D74526E396DF71131267126A08B5B895B3A393315B1C02F7469F5C4FA4E74BA42431F2D9286D19DEAA1E064BBD6374E89F8D5B8B21802214660380C58EE3C36F13F25E0454B41A1E204F6ACA91AF0609D7DDC9F1524FEB74B49B5CF9AF94AC0AC5247F2759F0521C7A12369FD93F01A0BCC3F53EAEE0F80A9018351D8A510221958FF627BEE0B202B6508BB92F0C14031921F11FA16B5D05A242975D1AA0F178FF58071FC30EAD866AA5913B5F8D60AA37203E16F77F8E1B7C1568CF7A978C798927020D5C6C2DF706709D2D0795C1FDCE6C6AB51DA76A9A39D5CB256D487DE7992D74E059311C2E6FA71690C4839F11D6D34BC20D7DF6998FCEE2265AEFA4B9A4FC8BE71879E92816276C84B15D466701B4F67822DE5DD97466797B8D8664816B9110AEA6422E75A6DD49897517D2CC2D6AC05D490323422A7B7E02624816C41E17514677ED7FC47A4FF2A2A12AA122374421D144BDA0E2EC8D2906B90EDAF84DB593787275E9F5CAA3AE3C97C56F6EF5900B98D1FAD221FF3FD280EE41CAE3A3128A59D8D456F4161F018EB4D6B9D1429C90E9070A04F3840B8B49E928926BD4B6632961C9AA36ADCAAF9CBAD662C6387C2358295DB4AE1122EDC15E2D0D23C3DD9EEF3F32E28A1E0F109953B2CFFF4E4019137BDA55D71C8241344AB944D40017AFB6A091D2A5D6DB81588B7192AF13B4B9D75E78C7E3F6BA008852573599129E63FE480148F0785E772B0B6C30719107EE3F4EC0DFF6C1A66A7EC281D70104ED52F4DA53AE250AC11F11945D7F5468DCB6CB245F2D08806D01382F7258A839DE11D8BE122A2D2F6FB15F773CBC60653B05684A6C404D967AB7261B69F497AA16DC67B501C19CA8B0DD133F581A4179D5D6D80B763816C70170CBBF28B230CAA7EBB99682298E739803BFCFB8698BFC57A0CB423A5A27067B1CF568D9274A824C0EFB1F67B7F6A91F4A7C79AC546A76F8810E81AB53A794BCB2FA4D84A7EBDACA18AFDC276305342C5C8D63056324CEAF8AE370AFBF08AB40DD4F407E39796ACACBFFBCF595A9765885E3F143C9111B083B27ADDE94C54CB22A955296294DDD923528E9D3211F223F3422BA64D892AAD2F3FD2CDC1D826C6D790438BAE969A0B94C6D4B7CF9EEAF40B0613FD78E60F490B23F5683F1DFE0F0A04C82E236E54F476BD88DED8919A1F9374BD0E7333A6414C87B15BFB6ADC2345E62688A9F79802B667171E9B0A1C7AE24FFB55983A6F257C0665512790C32B3EDCFD55138212255496E5C63EE4DAA5D8C7C291EB97CAFFAA2ED6460921FA86522F93F2F7E45D4FDFCE0320E150E98EE913D42DC1A80C58BA639391935D6C4DB198E0FD78653A9E5E101162E918E3884646526DE96BB67FC6DCDCB2EE80AEB3620D01D41FF3680563DDBD3BC288DC5F33B99F39761CB55A2873C155000C24514250778208802666B511966A88847CDF41D34249AAC5C0B98B49D91EF40051BA07355561E43F0EE306019F72E11B91CE70DE47F59C2F3F98BFCE6D16B0D4475C140386C81FC2D6A08D2C7E570152AAA964E23888421EC285B1389928BDF59ED5C7162B0F9C826AF6886D1C23FE45C433E3E17D3922FE7307FD1843BF8D3796DF250A69F0F2E0988E047818343E583FDAEDA8675D98A8627E97EA29CCCC4DF628F6CF9DF731A0AF2EB0E726051C9838034CFD042C790E385C80F8FECF336687F7F9256AF965425F0B565F30D628D5BC8FC10BFF8A8A63C803A70D3D0B50EA1F6C5EC0E8395240F95B9E2DDF28F3581A3690EF4D1727C7906DD9178A723AE4B9C796A4F1AE31432F7E08AEE8E60CF7347B507F4DF7C51C42AC456FD9A3DAC8B0395452066555F6D8965B732249755584A703730311DA69B9C61901C14313F0748469AF899773E2F0180CA63829DB9501D0D7494DA776792D65E579D5FDAFD6D861E7E03FEF3764909AA2CE61128B48094485766F7B291043163B99018303594CEFB5C5822518810E0D51DEAEED8344BA8C17B584639B3B2AA6429B2C759BBEDFC1821B34454E51AB3992EFAF23AEF619F9378FD843313CB30AA5C297A878110DC293B71F27EDE50A6DB69045A513C47C2948204324F11C2B5300896D1FE7C365BBAD54A554467460F1F6ED851520F5ADC54AF14A984AC332056EC07CDF6AF36C288E408E8D309DECBBDCC6EF4B0DAAE73CFBAB9147CFCA18C07752A471D19C999BA87CDC06CEBF2ED51085B7102E99AB519EA65DBC508739E12BD2FBCE3518F4483CA8923E207D1A60A48977425087694D07CF6DFDD5B9DEE0D9A7657C9D05E3F742BEAE03D936219B5958F07AAA7E06752BDAFBE7585BCFEE20478D6152418AC22F21228F2737BCA34CE7B22EF70CC0A4F45AAF29D2F98286B97E74B3884A5338CB4B8496EF505DD9FCF82067E33CB713E4B204199EFA8E24E19EB98B5B8E252A4AFDCAB0680FF023975AB72EB64DF5777362EAAFB9744CAAD46F7A6378CF877DFBA0CD522B7B7A5EC91AFE294DEEFD223975A479997C23CD44E5F9181909C789F1299F8B784208ECEE253CCA9A3A7F65CC4F0391BD60F295E5EF330D9CDC2900E62C08C027E1A09A430DA94811A35D3D05D5DDBC34871396E7AB94899C4D9D4601C1950C5E5FFB008582AFDCC8A378CA5FAAD0D7064D0A8877C15621920243D6F8FF3F0744FA0751022EBC8ABFBDF93738F82D415A69FF58F3197A64E88C9412DEFD6FB20ED468710577132DE40CA7187B4CA197DFCEE1C56048CCF51546E8AFF0F961AEF38347C6CA5F87FFB5A27E1E8FE4C0D5663DB45A71DBF0A72771AD81FA041F6F94EFB8DEA13AA76A426C2A7E856B76F3A0E593C14D025C033AF6EFC05BAE36970653812D29C513C14E245B4FAD8FF904496EA33478BC5A6A8173647D23EA8849D623488D5A2694FD495D3FBF360C9350DAA02FEAE88AA72F3BAAC3677031275185EF807DB0155A71C38FF10CE8597E518222A23B8BA94A5BF69D5D54EF722753170ECE31CB944B67C09987597B61078A6E7D2FABD0FB114A353416E0EF3DE530141B6D562440F1BFFEC3127BABBED56CF597DC83F915D4A936C62810B48F34521C38006B216D470019623FBD864E1FE482E7F88EFA21251295B2C2315D3E8F4989FFF63F133947B8F60EC6FD0761614D7823E22ABD8434810799D9D0D529683360F9D1E439315817C2B42000F369EFBBB6A9BD65A64AE335C3725863779AA4503B26AF4BBA3084CE4E5D7AE684F6BE71633AB42BFA4DF862669E193F1ACC3E048D69EA8B3FE4C68E626CF9BE2543160FCEF239C4C0FDFC945572D61A0E8497A04236D6D69942B2D35E0C3015AD492D4BAA430712416D1A6AA2EE5E75F595E61782B9A5D9D00B1721CFE09872396FB7A5384B6080016CE9B182E7F1F8445963A3D4788E105A483EE86F61EC72B760AC88E9459DA20F464E1CDB3C7320F575DFCC8776EBF6A5356C1030B946754AE1CEAC72CEE5D77984F7B2C497A396320186E13910881A4B89C194F211F0EDBE54DF8678CEDF996905977C8D0D6FC4F67C2930E131F785D4851B2EFA40DCAE97060FB1A4EB02773574F758F0D3ECA4EC6393A755AA4809139D1BE384F0C9B496F99E9C13CE142A240A0DE76DAFCEE22E7AE754CCA0EB6B23C05FECFBD6EEED1D2C7C2C7760B49CBBB00DA03E8EAF4C3C3C8CC3E42758BD6496DF1FE8D13385E6DEB32101F0E49E7BBB97613DFBF7662753703DFE45CB2590D3AE326364D2216CB607786631B9A78FF6332DC45864892D91D1EAA0BDA431474A0129F4D02F961AC93F96EA17010C26C0A362BD5A1EF07C2D3B0EC2D5D6439D0E0AECA3ABF0D2DD418C13CBCD9F05265AEBC8C6D84E22FFC1B70F8C958D38B7C0C963B15C5912D46E88C428D627A93E435B8416529009C10D5612E1D7A62EA05568C1E357D512519F99C32036CE9E38EC270C629CD683DD76EA9D25EB807CD344A3931E52D2670A140135E92F39D5E2C641AABE901FA37D4BFC93B1F36567C4951AA8EE9283F810C5F42C193CBD15A9F9CAC666B581EA9BB03B2B3A31A4D6C5B211698692AEAF5CA8A21C67E7B514F4A8E908EA5724DFF69DF87896BF35EDCD76280FB41F99992368D617E5281C4D12AAE10E450BCAC37BB5EB1CC0678653F0BC536A3BF8B0FA143C519A7AFCBEAA27FEB00B90ED8AC67547CCE58265A1D8A78F2712110A66A27B8A2D4AE9FE264BE3A8A79D3AF7A613872B313B21F0B45428E54E39150A5C40FBC062CA4FD4A8063E5EF21C2567F1D668E29946BF7FDDDD0F1A6F945D1CF673B4AAA79395551E13C158EA400E6AC466A7744CC8ADBA68DB0568813BA390B3ED97F4F618F25324B891C0ED8A62D8D438070E2BFD535D64642353A90FEC688F6207A105E9D8BC46DF3A7171ED44C6CCFA23849884E006D6846F0357AC0B82A75F00B5ED0AC2664FB31842523A6AE71E571B5E6ADBA7D507A9309A2CEDA19915AE43EE06985548F3CFD55F2CC62731A377C79E0F45F041491FB9A418D067B64FBD6504E92B7F86BE4288D732D7EF372914182F1619C83DC700E42124D544D80223FB031F9467FAF555D92A9E4E00B06566A101B8EBA329102D1CDD228CAB9A3642F0C13DE3BC85C7FF3844451EE492B3A4A9340202DAA58707AE31FEF74ABE3CD56631CCC8D0B6EBB6EB36B769D980F8687CB6030E6AE6C4977D890B31068EE6F6345D3E91F049338DDF9BEBE100DF65C2A5099392F8E970202FBA0C0A4BEE349BBBCC4270CB1675B8FC686A1F4623F4DEC4CE723DFF36160BFB547D7D7D753A60510BAB109B329C3AF8DC9C44C382F4B33766601583A9A9F74A7AEC7B05558E8D02FF578E4D0895FB00A1246615F0DE168590E1857AA72743FDA97CC3EE163F177509B5583513DD99144F2A56841D1465350AE83BCDC3D489FAFBB262CF87B4E8A182B3547A7C6AE899C5E28E6964A512BDB72074979A42E8F1C4DEDED8A1819220BA88AE02DAF9FCFCDEA586600C524FF7E5C68ACA640F50E6A80F3E9620D294EA84A0BD695DD9331C9D35B265B94A8388642B04D9F3020F87339645CC96A468A7F5E01099A3CF1D499572F7910712E76EE30BFD374C5A5091CEA69AC7BC883FC5D8F2A81AAF0538EE98C2C5A3AE614742D34DD5E6D4C769218B802602F8A0210D4CF7763BFC0A7FB10D04144A3BEAB1770DB25E9780866C8AE6099A936C2AD0C149050D00D9CE9592AAB46F1A6042BA5759B92E231D09A68B451A285FFF94C5B7B15BF3D42D2AA1DAF8DBDCACE262F80626DA4A8EB06739D5697191C7F3F18477AF2C64E8B536C66BA +sk = A8F65BE046001A6814F537915BE3F03F3670E1169E4AAA6D7E726174ACAEC77C7B0F3198F7DE9C2C +smlen = 2548 +sm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count = 48 +seed = CF5A04DDB5EBC45328F703D486D24443A7692D65AA55F054E3078DB76A7939590A3F35CF1A21E82A845445DD1B64A85A +mlen = 1617 +msg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pk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sk = 802E08C14F6E3446BBF7F4666C8DDF7755DC718C3E02B7865FF33E9D8290ABECFF3DCFD19D4A206F +smlen = 2581 +sm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count = 49 +seed = 8C3D2FBBE0D39E293AF2D2CC5A9BEDEAAE3752DFD19CDC1E186D41E717A0412AA429CBDF005445AFDE684656B5D17690 +mlen = 1650 +msg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pk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sk = 23D7A85A824DF3D904A511281A973C979F67F5BFAF3AB0546E85D0597F91120FFE2892389846902F +smlen = 2614 +sm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count = 50 +seed = C10427EF0B26328163F85D45E22EC5215415326F013FF31EDD58BD3E97B1A72FF07D275D4C1B517F4661B0638F75640C +mlen = 1683 +msg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pk = F07932F773AA8F7D4629AFF59ABA0BA819AC16B5E82D4D06E3A37A9A601C76A98EAD4F76CBF018F148508537F3BCE36314F754E667494D86BF933C00C423EC760778EB10C91C0CB9513C0280148E0DF54E03849EACC737CDD4C809E25FB09EC57895B7A98B0EC871CF950E1E6B4A4F77A50349B677E7BF84F7EAD14C826AB8013794A2A2744CAF7AC35033871F1BBDB8919E4E010AC2097C6FB0BE6EE1DF01B98DF80F349F8665DB87BF46C85505788C5557602D7649C713DBDB11AAEA2188ABAD4C85D3C038FDC90154555020481A3A3F91A7135650A556977D6BA983AF9D6DDC3CD5576927A7AEF5CF71252B8CB6C0DD427953C7487D5247028FDAE241FA5B7859A86058167BCCA39A484A78B27577F4B973454A6B59E757DA3C9665D78BE5632B47770F1B2D2A18A07B5CAD0BD774B5F4ED557C2252B0B3C0943AC2479BD215F113400DE8E1CD37B3004CB5DD6879E15CB9E0DBF8AAD0F2C7243C7A97E67AA0814062C54C37F04263C159147D4340630B2DA493C7D1E105BFCC4EA9EF066F7E91C84EE4FAEBD3BEEBD26B8E1F28306DF18920FBFC5276F8CF7D0F8901A4DED98BE44E85B3BA5C6287C3FD756198842B6C7BB9FC2C14E23554D91EEEF316AD9B0809219CD08264178494BC060D5F3BE90616D0DE975379685EB920BE1C1E35DD4C00390962FA3285C81F14B61933940923E3C38D70A2F4515C01184D98691A6332035D26FEB3B3BBBDF5CC8F35B09A9E583C2B94EE4EE669068678F141AD675314776201CC46B70F25270DD5883DBC7466A4C79D99E4F4DE78750A95CEF5009E4F5C0BC059A2B040F1168FDB437CD17B3798455633195E31BB8865A1FDA2F7569B326B18728C90E76CE4F9B2A93A3BB8C5DE33DE5119609C94BF37FA4F29416C4D7EF81BDBF9BA03A8CA49DD1FC14E31A64A8EF0ACECCF36B810DA46FC2EE3466EB247E7FF164583B0F3EDD1FBDEBC467DF70A6ADA53EC0C4DAF354512736AA1FCD7B38C8AF32C65289C752C96F10FF64C64CBA2442E57F0E05D8C1F7ACB574A1525547BF954CC782C663C6BEA987E0949AEEEF7796A5FE387AB4A2A2D23A24C7107EA7F0F9513DF570C2D189A0078B9F6E650059F60D7105FB2E6F6DF68EF4AA7B928A2CF87D46137BB411CFA221194E70E310AE6CFEA9B8B558C4783E8419844B2135040BD0DEE19CF331177D7530DAABE7CCD86D9278BA1F478DADC6F0D6EE0E9DC2AF14060F0208C2B28E6BF38C5C65DACDBAB4925D88EBCF2CE1B81DBB6033BE2BCFFEEC3589F11D3EFCB3064838C1BAFA3AE50244CEC6D5AD796893E7A8F669D2CF19C5A2D1A4C3AAC3292BDFE5B0035C62347EE810BA5338287A801AC63EBE9FE38E897D967EBB03B528B173F06F195B0AF8EA3768041E164575192DA8C0BF48F3673D956CB6E2C514CAFC7AB3920A362FD0E9271095C6B6E1733E6D8D5823C9FCA9F7464AD3ED7C453F4EF3661296FD501C6EBCFD0BCC02F025F20D3C213855CC41F421D4E33C2724F89CB8EA072956759CD26203523D4D7A4DBECDF39E3F8202EBAA4DD3B4EAC80D99235B95D396E98222932706052FFA1BD2B956C18D7B128D9EB97D1A3F79A81D6D177363DB647FA91FC21E55DB4B94C7B059CEB0DDA49E3F016E32CCF2E147CD6212427B4D7BD52C5FE602D42011734DEBEE8699A5A4463102DB99A566C33B211E4FC4CCF60026107884134EB4FCB6F4560AE45FAAB03B45465069C6153BBBEF4DAC270BA677B967E44632DBCE1761A8489B5F5860D7F4ECAD9615212DB28C984CAAA4F5516EC6BA834E25AB3B0E9CF07748C38DE5EEC44D2D1F1AF2BC9802E6625417940AF748E42229D67913E9F030DE84A0B94695A96B19C49770AEF52C2AF87C4C1F311865B85FC5D71B9E43F191BB2551BBBEF90B8B0F7E608FF9346F6E3957F90F6F38F2FB59B548C0C028E9D5AADD867BB60302EA16D140CBF8559760547F763B875E8C7A0DAE84F5A4C746A319B62AAE0269C396E865DA9A7B5DFFB5A6D6103D9E2729B42E86B0E502C610EFF8341776828DFECD079C68DD2E6BDD218588665752E0849B258C72AFA14AC47F2B69F132349D3AB025E839D3FEDD778E78CF87BC80A97CC9214BAD6F88FCFE182010FC06FE8821007F6FE5753D941DBDCA20A81C57535B408C0F6F1778461E77362420B604213404B1D11CD24A4CAE85BDCE42FE001640E989B4E285E34806BF766E3FCD866CCBA8F6CF44C8C60BD5215923F0A09BF96195297D99FB459B0302D8A98DD447ACC6A595381D649B0E53587B2E09F4E5A757EF2B1BC87176041733A8EBD2C07293C09DEA7D6C8DEAF003B7260C8EE60ACDA9389945EC337BF4FAB250912A64F19BC1C2C893C7CE1C6BD1C03EC0AA4791BAEF8AEADC1D51A839FBA483E7DABCAA25CD02A91BC6291E5C92009D7CE317AFBC1BD1FB6821A51EA2EB10BEFA1CB6746BB8D6299D783B7D84FECCA93D2B8F4742116ECB4DCA191CE6E6B73787F9F9F8AC8B30C5D705544EC121FE67D24D951546FA197D8A18B39AE4D6CE0A1AE5ADB4EDD7700A72818CF283B236287DEA154F401937E4BE88F0CE58BA924C27FDFFB4800FF1011A5E77F3FF8456A8D921BD7D17228C0AA17FF8BE5D639B342C320E71BEDEA58A37D6211782724AB5D837D5B465C0BDCEECF98CBB07D49083E7844D3468FD2D944A1093550746D68340ECCD960AD601835665D294073E1387A762000BCEFAEE9346A20F93D5359B2000456411A2A53BF8052B5C7FF7991F8ACCBDBFBF1FD9394A0ECCF9A6491195FCDAB5C16CBB60B6CE3B42D1B3989BFFEC9E6CCDCD18C9EF0B6C729DE3A72B4BF648B72B10A3A998E598ACE1512ADD113FF5335F40D9DCC679DB1600341F4565BF85E8A5CAAA3C0B3A308A750D0E838E488C040178CF6FBAB0FB06C84F7F151D6EEFF4E5FA2B1502C1A4A85E3B053B89B4B2D52E7C8EEE082124C4FF30DD7D30F7303242DA206D9074DE1AA59DF4D33595B5EA645E1A7E87507229696C42D7FB187CE33DA15611BAE773608E667A0F034DE9D8E936528FD87E8D28358DF7088B465DB764FAF158CF44A2F4B56824EEFC57869383C3B1ADD6E9D18052D8059D720886C2107BF90524B06B5A08E059C9163374A0301A0AEAA490E2B3E5443C31341A46F484DACED99CACCF8DB8C6181BC32EC2BFD6F5A7676EAE2CA6A4A6D35ACE6B5E3486AEFE2A969221D6567159BE55087E429BFE3BFBB1A7507AEEB1C6F4741F7777FEAD92178FA76FA611C37E1D223D61D9B782CC902B0BD651EB7F24EF67F40D9C10902B1B7B2611B20CE5611749D8E68A563019F39BBAB41AA573C9E64BBB7973478E95D66A34252C898D26C1CF1D30A91AA5EBBDE8D349AC28EA092DEDF003CF834C9A25A20E433AA85AC24823077D83ED8FFC60B334C73A489CE9AA508C8A751CE89DB1F87AA7E5D88B1EDD9BB9900880A6A78944F93546006DFFB485C197410C5D6024EDE191EB2F5AB05E24AEC0E96558DF339293A53702ABE578C6EA94D588864873FFDEF0EA58A94F1075E8D5DF50FE9964E9B864E8B4C422351F7574EAB8355377065946286BAB9D2013F174225D8AB7FA733BAE708A1EE327175FB808BF7A0E9CB994FFC421E26EA33703FF65B0AD6D59105FDEAD89CB3D3E511894CFA7F3A06CD24C395980ADD372C49A37441967366887687C91056A9DDECC4CC2BF01AD00049167215048CD3C665E5DB6E870CEE161FD5DB8AC4497C21E7DC14FA63265AD085FC07C4F01F2953F2E408C185945AE6502482D27458716CC7B8A85DD3AB1B459FD8208DD71F510686A8F3DAFD38153C954DFCD95EAA12A98C32B31E05248A65524174E09A74A0FF33A5C8E01403CB30039A851CB6438BB8282A568A83829A99188DCF459ABDB532135D4B153E2E7A97CA99A8F460467CAE945F58935AB3F67CBC4A4CBCBBF5CA37EB1A3A420E172912F2E159012249FC8B665C7F2859228BE8252649C46BCCD125B5FBA6D297355137C4CBF062309EEA1AD02BDADB40FF76C57F980DC7B8E775B9A8EB85F81795C4D5FF344491294FE16D032215F2B4C409BFFFD8032F152717B5EF76F042AF7F4A76EF07F8E084CD9AD773CEFBED61090F32726CC9093551A0ED7EF8C03F32C67FD25396919D5E0AD016F2DE3054AF93569B28DE54ED85114C6B168E16326CB86953617BD839EFEFD393085E4C6A1F947F774B542DDDBE24221E84DAD4015817D61231F202B641AFC9617EC7CAE58C75AC579CAB4ED60768C1F8A08B6FF9823C432C3524001BE1509D072B3A604D78950776DF64F3295ED142E5D02644F043F5F2A074D7C6B310A8EA342803949044D83D5A82E710ADD12448FFE49C78B4189582B7C720F10F22B4B71A0FFBFD2E6CBD3BB5DBFC18CC34A99571D45852367D91BF51760E3607E0E6BEB885F092DE43B3D73102A034F957D478BA19C423E4878E6F7381BA4CB6A396EB11FED687F8A0B680B25E131C6C9F355EEA44915744EC8CC4EE71A82E94799836F6A5D952368DC4A5BDE2927A599BC2ED23DFC5FB7607DF1573C9F077B90CFF0B8398539E85E32C5D677FEB1A8DD3A06B9FDC06AE94177B540B5CF5579B8A9A5F74A6F1855B27922E6B218D2868EF8571BDA332DE7AF12D100E51B19F5D137053BA853D20D38889D56DAD8C6A08AE626605A6077617393F00776F4B17E8B780A0CD9EB27608DC81DE85277C8056436F8A672708212E6003736D42FA473E5D335EDA2535B6CAE8CF5D151EAE76002E93BD238B9EE1ED2A71CE95164C32C0633866A4CD2968FEC7585ED4A3985B5D9B123237FE7004EEE856881A931312BD25A2F85D529051C729BD56D6C761B65E9FE1AE186D07627B0C99C00708388548EBD477A7F6D68D6B1D656526EC1B9E4CBDF297FFD52E73A11A4B82DDE3DFC2D40564B4D78C56751097A69D9791B79F5B2704F0B271023F200AB708EC4B2852ECC0AA0AAE3B9309B3726C090D47007461DE2483ABD30C6149027681430BDD1C150FA9A3602830A0FCB3880612B32583D2A7C0CF269ED32834CF02A009A7FD602F67F451995F517B6DFCF2702758A97BE91C948BF08F7E473EC4138A0B779F7C67AFBBDB25F18479E96E5A5D075F0D0ABF8D2DF39B751756FC106CB3B13AD709BEDC50A01514F63C765781CD149593E3ECDC7A59D7E974597E93D3603E8D66A8C02A0B6A2E95E8474F946B71B909D2BB7D3C16B95A3DDE599F14742C458EC7CDAF37E89DEE544B0FF9B03258531267A6E108DB5A042D329D306AEB8DB8B41E2B872815533C577A4FB1919DE85DDF0DE2467D430697F17523E218A78CD5CB45EC1FBB1DD6302F35702EC1132060C952B7783CD22D042A1D36E06EA6CBC87AD4269530264A4A1233BB3FF67F72434ABF7EDD0F56929EA0F9448E009BAC38BCC2D625A0A01159A253D05F968F7C2B5EA5559C395896F79F83BCF23BA21DC7318FFC742D431F513F628E201CC18A5E7B693B87B1ED7D754404F4BB7675C5E89CB1888821A45C467C2D6E829C92386EE275BD5A83C17D8D21F23FD76C4194951CB70A95711969225590792F693689273BD6CD9DA90BBD66FAA5B3954CE23189D3AE3C01BF7C2D8D052FBD73DE9743CBB03C4941BDDE44630E1C4439C445A21F27BA01DB5D45DF165CE7E30A089B0DB271CFCDB05C5CA7D3C008B80D92F8DEB0D7CA9D90760B12FC88870798432FC35D10E37CD7DC88A2ACB7E83462B69312F96C7A69D29C023613C337EC7C26C4A2411B8C101F2FC4BA49E3EFF7920DADEB6E769DEBA21C344BE8D29FC3E1D48F051DD6D2CDB67F022271AA3D92CC9D97995F7ECCEE497C5B6C891C43E16905048B80218F87041FA3BED1983C64A9C4CC3194B9A2F120852CBBB03DA45EEB2EFB560BF609291194168CC83711CD52E67371C9E8F6A1FF573E51EB9C3AB71DDA7FB54FC7C40516F9CA644B0053B4F36C82483A0C88BCDE6C0D78953E6AD98E6584EA508ABC27AD0AE57902CB7A62BB47E2F3DB3FA122DDD0DA025E25C190F02C8FE5C9ED98AB5C69447A0F2EC78A67E33DCE3ED00C1EEF406E4468A8F6C1837B524C3DC307065BCB9DC3EE408D58365EFEE8FC51A57E455A3414520816CFC6452238FCFD49DD0826BCDA16D4352A95F6B5D169D4685BCE4E7547353E583925832CE85362CA1082542B3E5DC585B87DC17ECA2908A977331F735EA696B142D5F37B1ADF5C2955E72013C5235A9E8AB0289947C24464F9595DE7A16BD0584F01EB4DE5C2157FC38B3F7F5CF8BC6C15764992F3AF6B8D308F6A4A9F255BA34D56E7D8F35F4C4743FD13060D47C3ABEB428DAB0BE449BA544A7E78975E9F3407E4B7232E44C5B7729BFFA972DD5BF01466C1C1CC6E4870E0C589F5ABB7E98A3DAD9D95F66C8320F9D3C675351054E947E474B164C92DB1F9A2E6DCC4AA23B8A56B6175224FEF649867854E7E9E51724FFD6DD2EF6CC1CB5BD369DF9E395A1A09655D2F234A1F9733A33B77F2E5BDAAAAFEBAAEDE6787E0E4328D5FF637755B6A52EAAE0CCE7758CD6CBEA2A17BF9F82C707EAEEEA11FEB7163D71D1E495217E227BB7236F0D7527D6E798F7809C2DD78552EBD56A25A0C850E4D79AB8B9AA3C9EFCD223EC4FF6BA92F5E83A145CD30FD543E81793BD85BFF403EB6BB89DAA7F15AA2FEA2A131794CD7396FFF874DAD78F71505996446676150F7EF4B51DB1437BC8A72B6C2660F28942BD16078BBE54A135A6C14FCBF968A8A3B39118EBA25B733E1C0747586AEBD217C582ACFA93AE6286B3B08D1BF5F9BDC5801F57C46652E86CD8C1347A950B4C71904EFD91C0476D166F775A092F6ABECD4840981F37D7C774E3269C1BF58F90AEA1554500BC41B2AD5C24A94B9414A96768B1C8F4DDAB30E31332512219F4EBA675D0A26DEF5AA68EB8FA3E2C894D836E2E2396900CDF1D22726ED2867985F97ED96369037059A993CD7497DAAFF52A2EBA41CDF226A9F444B8B9FDC3100A21E8F4F789816C3D99BFB19CA2EDA987F0B109B83016C14ECD354D5D6C5C28F879B0138D2537720983550FDF728754CAC932C43DBAE572C193A414845CA2C2570A0903862DB0D265CD6DC2F808565DE262B892578453DE8ABCAEF57CB99E25AEC620F8E3890E1A5AB4593FB6B80B878435FADA69C4033FAE833413BE3CD06F22EB0B5D483F710E1ECC839FB0EF3EF2A6019B04C10F445B8417D32110A6E72F9F931810EF0084ECF3DCAE2FE5D8DA8FF3CE22127F9B5A6BF23CB012D657A09DC79ED7340933E7BF7912C13C26B48D39B7779FA41B0B89BBF11460814DC638FAB58E6DB05D801A415806C25628BEFD45A4A19BEC56E1DE3A46B9E61148EA4E70590BC7CF8E721B305CC065AAD76848FA814FF852D05D83E2D2C5437334582316D69959E1EF0B2E20D48CC275F34EAF7F8989C99FDDA5D2DEAB38314BA9E427FA83C21F2EC999A4C4A385281F0D10C4DF1A253322DED7BBA8F733428F44B549E35A2D23E2913F1ACEFF3DD17F6EABF76AFEB07F86DD9DA2653927C240CEAEF43904046D621F6DE4C2506A5035F3600E863B6CB5C70D080DE2E8100EEDC071F663B24ACA3243DE911CC7ED148DCFC38995E443E1C0869ECA1A5D43D63BF1916E4D6BF6EF0509D847F0A30C8EEDC30C346F5FD4B21C3424BE6B1EAB90DDD53E90D5840D7A205685585211822B511EF8B0F49953FB9AE5681FD1AA2760C21719827DE296E274BFC11633D85798324462791ED932165401D9FA5338554EE97A50A0EDAC64402DEEBECDC4C02ACA85E902FB50127B2258D02D9D1814AB4D3C5717F096197DBCBD78732E7634121D7E2AEE39F88A5449288369A12F653659165B9ADFFBAAB54F7373C73D30DF89000AD189EAF4DC8D2025A5F4DFBA399F56F86 +sk = 771CBB7C9FBD9FC5DB93E3E4DE6C034E58BE9BADE93748C422971421246962347B5F037CD6CF229C +smlen = 2647 +sm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count = 51 +seed = 4B6B73E042CE76DBE39535E45D3BB2F3B9F8B2BDA170E76CC88666844703E32B2367460A0F6A0A2E3F4E7A6CD32BE998 +mlen = 1716 +msg = 0BF9A7C0F63CDCF3F850ED7C5DB6191EEEFE29E498A19F9D89BE4698821ABD72EDC34317B4F8EC2736DC83C24AC195BD55AFF00E797A83DFFADC7970FE53304F16F5DD92E6EC362B9E283E41EBF121FB2FA2A3F60124EF3EBF836AE51FDD55CA9F59B085DDD660724C072B86041B50A3A446CDB20A45BA65380ADF007E005DF2D9AA16A9D22B11DCF6F0B1964F04F45441A923691A15D80DC85003B9AE281F2B5983DD1A04D80A4D9C4372D9820BBFAE3AF7735E7C71E9F085C0A6E4BC107D9E4BA222B38FB236B2CC3A19DD6067BEAC460383FF2BCC771A7F1AAF092FC72C292FC1D5C6FC6B9715F1E1272EB22F8E0B33A2830E31BD6C531677902F6A95CABC3E9C1AE36F77037A785FEA355137A581FC14E6BD5F1F7AD1A5DD19DEDD448B47B558C22DD0FCBF296A812A726E7D1B57F4688D3F577104CFB15FC63C27F7B6051C7AED7D645186FCA63AD9C2D68BFF442466EFF76BCF0E398D2BF54C2CA4CC614839E9BCA48AB2CC53865803710A98D313AFF1DDD06A65680EB83C640052DB807EB2F38ED0CC211128044D331FEC3E6B0B2F3B675C631FDADE62C16D1719278413EA3F8E54BA34EDE7E73F3D94802D2F9CB9794D257C46679A3F00015945903190B97071F8FB55F8696253AA3F39B3FAD344FB88224F5313B43889B768171895F7AABEFF25E21E525EA01A996C764A3ACF12BFFED08F3F751F5CC094B50B325F8B62C7A5B3256964D48543690538E634E5730354358534B65EDDD44A526BB4B15E2042B6210F503EEE06D00D615CCAD10D73CDCBF5264B526674D85C0ED31BA5EE584F21FE6D13F883ACE4B094768865E43099E54671240E8E2AF8A7D7D22335B3974CE860E7238A7C1CA8A009EB51C8636F0659189AC8EF01C871E9008957CECE0A367B63BD2852BDE8690BD74C6D956435D0AB82F94A90CD00FC840DFC7036B84D51F1FF5076CA0974DB6CF25AF42EF7DC8C30C2B04CEB2510E86FFC510BF4C931639478FD1520AD571FA17958CCF8E37F5F6360030300EDE3A33871E9582808BDA2233996C5005FD0C23D99261F570AD9027767F6FC96D18BA98E8DDFC2B79AC12CDA5F2367B4BB6B99A3E07B59882E49A92AECE85339BBB18AB9644D20A3B2A795240492CE4EAF09D9EF728FB82B1DE7B64B5D391251FFB0699335CED8C7CE642FF1A79F04C3EA0DC37EA101188361AFAD236EB218CFBD1D0EBD784CE27DCBA0266DDEB87B59B66A4F75BB44665643FA358DD3D0B69B49F45A752B5C410E2299A62BE4B57B32B0924A069A8E8C15D754CC34DEBB0D967E70693A6FFA58CF7099C2C2458B437C7B205CC7E815F6CB494080F9EAF3017E5FF918558DDE415FF72E954EBC2ED4C20C8ECE38CC916060D22E582D54F74C6C181C2601400110A683F4A365E45FF1387BCE4E152A740136BB762B03A99FB68F6AB42620B2E3C00FA8D150944230A6330409B27E4AAD1693E2C3DD12216C4E2DDBC5E9CBA68B8B5417A7B2EDAE7EB67D25F4EDECBB087F93DC9C927C33076B1C71A2B83B33870D602562ED378805A690DD2A427D86C2C46BA4741F3DEFEB91A05EACE975C836E52868CFFE52CA92F97DE94768161A3E953BAB6A28016782909EC53C02F35184AA9CCBD5B793B525204B72DEB63E104376893B9452C3F2C492F423CBEF1EC87C85788CF3073FFBBCD67FF79BD038672943AE4BC68DA131DBA8D7B41C83B4E9CFB6931987B270C74919BBD40612F823114E4BB148671F1AA62BD2BDFCC8B0B24010EC112E883AEC9746D0F5DE467ADDAF51F8C070A359108B1F91643071438F098233AD9A94D0FAA665A39291A98D14A861905ECDE4755D00E690429C57580DCB6D51BB6186CE72EBB1FA8413892CAFB8713E89775013E546FDA30AEB8AF9F7155C08B25810C80CCAA5E700C124CFF59FA32E0293ADADBCC7B1A99F67E66B28DA614C5A4CCD706AFD05388C65EBCE07A543D3DC1E5A5D1F307F675728D4C629A04E9E455B4DA35236C677F26EDC622C1FBF29568D509EA0690AF4CB5DBB4E418B6162888E43B458774A31324BFD5EE8D2152E4AD43A3007D7D4AF5FDA172C2779837AD3A09E135DE953CE966727A7183BF77ADFC76430666B526692991D3C9DB5BB377552A7801C548AA63F6931D3EE91B875CDBCBB7441A4FF81F86762332D7192FBC2F7B69A58DB6CCD3558047F1940A1CACD6FA28A000B9795A2860394BF05F0120E6D85F96B1FE9DE14E3ED66A31D747924B6FF2620778E0714AEB34B79A5D935A0306E55C36506A292C5DC568403551907E49A43A6263D2915108916F1E27CF3529D1B7BD1544AF83A7CBE58547F192A93CE5C5BC6D652405FFCB95345F522B2D34E8EE0960BB85537A46121BD9A408D283A125EAA745BBAB04E2231C19AE95E13901C69E5C9C4D70B104478F4A70D64F81269A8 +pk = 57428BB922D4C7A82572E8A06D014856FC2323E2C434221D671202325F676DB68D8BAE1DEBBB1E6E5348992F7D739EC7F449E5AAEA8C37A05025BA01938A56878E9F0CD0F5BE3C86AA4DC43A8926621C7630DB8761A2450AAF8CF524443D07BC09954CA69249D01510BB9973E0CBFE6682C0A8647C4CCEEA30935C95B6FEE28D103228C6CAE332B7E6BC62AAB7B3FF75157FE522CE3AB17507CAF17D0239615621A4AA1653DE45ED3F283A46641E811D7858CBE4292E6C67EFCD1E5DF4F34816DD30B545F2071406BC123AA37F71FFD43EC634602B454280EAFBC974D474BE7296E0E0355C0FB3BFF1970F5D2CBC3F3D0BA3C1851BA26D2B1F128C3286AB7174906FDC4735508ACB8BC24F798E98D494FC9EC21A328BD196CB6DB348FA03DE1F0DDC0DFE378FD6AB3FE470E99CD605718E57E11DAE0C668930B0ECF294CCE2C0E17B5B320AF97926D9E8FA3F4B7358FDF7EA6E80CE8487CD015287AE5D0244089165E78E09381EC5BBDFCE65F97AD4F5DF3F30BCB1E671A449B5C8FB38AB56F2E0BDF4A465A53EE00E4976DE4848837B1EB6C2F84E12EF698994B1CC8B977FBFFEE511DEA4A6700FB666764B8E689A0729DA488812D569FBEC288B6F7576ABA0F80B5087BA25832B6585A76032327911D3303B46A7BF2F56BAAF2CF0D776B62511B0F9B0B5D0418C4B08765F455695E84D2E8A423FFFF3D3C9D12C67F4E324DA24D38848537261F578A0665E4161C8EC9C8A98DF24A0721C551948E5B716726BD88FC046A694419E51ABADF594575FBA43F33398E42281D2C1F425006C6F2D0C7385CC0911AAC43C38297640B9E3FCFA081CC065B0597B92752E1580B76C060F10FC50E4B91A7F7C291F31383B5550F41A488A4885AE7263576E1CDC28614943AA200E26E56C2A4E6F4D8362547822745DA5467F6644CACEEF97FBE2EA9AA07CAA8ABB3D027CEF2603CA3B2C8F99C00D3AA7F82B105C736256EB0D77F4929619F51982E5DA23A3E7834D58EB70FA8A9AE26996B63B641C7B042EF96D34FB54AF54380B06ACF39083CEEA9F307F3AE2DC8BB6666783E0AB117B48D0E2B90CA7D0F40E64DF87D37C05CCEE79BCF959DC1FA74CD1B3EC919CBBF1E1B83D2489249C2343C5E8403F3C98153F7E0BDED656B8ED8F7B6894D78EEB381C308D2E63FC33F919A37CCF87D8EED8FBBFF97328C2357AB872A98E2C4C9181B089775194842DE0AE4735D23247A769E4A25D3581F1C27F3821D2228F089B07A2B9BCA707DD80CFE401D2C40C81E4C0C6C57239013A26A21950507B190EF4609C84D2EE9916DCB5FCA8520CD1B619937A0EBE94DFEADA9DE69561206D5DD1459318593FD0C9B7077595DE0FC6A96B9F1CE6D3F0ADE9A2E75AF62B837D1D0332720D0DC92D5DCE6E209ECFF123A25E4E9FBB4B03DC2D258FE7FE77F4D9FC5E202A73B739FABB945F0B443F01A5F210F46CC39816A8A22E425BBE8F3F898284F01E1AB3B9DA614146A48D7F9AEACC9ED163F11BE5CF4118A2E24F28EB27290AF8C09E42B1ADED86EB8D8D39359B3619690532B189F537706E0F2E76D509FB0F0B528BEBE24C1424EACA85BC6A33AF6EF9E6199885234B435014827B6E64F9638EE152DBEFE3C8728A69A21FFDEF2016475FCF4564EB15796E05089DE8F9A46FAEA8FCF765733EC02E602AF2820F0E37B5FA90C7EE468DB04030CCB26F5097CC0504A14F50DE6F3EE0B19BBB5863932FED28167FC463C8C2AF00C0417F37FBFE8B39832D34D5F6BC15FFC337567748A4E029B3FC51D702B0A1DF8A0228D10E32EA17D30A58C86F3BA78CCEA763CD347590EFFEA87A2AE5C5566EE3555568574BC97DB451C494118062EDAE19574881A6672816A9E42277F99D03B17AB4A75C3F00F4D91F29B950DA18F6FC07D375DD469DE432FB5F4EC11B24F4008706EB34BA370E541691780AB769EC39E9D6A8E7831C6AE98E365799FA636462C158A9958C518F888D10CC28DB41E67169C892B2F4AE442086B08CD0808E30BA7721E755137FD963F31EC69D5E0D9F14D208C1548BBB69676B6ECD9DDFF7A14C8700AEB65C15202F3B699B22AF6DB97920336EC59FE2B444105246FB6D137E0792806FC67663753BA2C8791977081081A0DB2E7047E1A11F33E94C49C69FAE07920039D89F811DE54076B19D392320F545812807FB3D77C34DDD78B225E620FAA517C7C9FC7C003BE2465829B6CB06DF4DE0B318C90213D906E8DCBC6A423E592D695774B391F37E4C6C4686A4D90EC2E9C6A882486B17541E6125C89B68A3569D11105CED6657F2A8A1BD1F987C9731EEB64AD5272F9A401E5287852CBB32F8C921EFDCC83F689E34F8A6208C0D8443284E82DFEB64A630F54780667E7E39B9745D2B81F240EB6DFD6C6F2D1C3A7337A32CC6D2BA1B1CCD261DA32081D5F339588643B5F8CA55F71BA00531D9DB9587DA8F122FDFDEFCB39DC0AF54B421138A0050E73E71F6CC0DDBD1D66687621F536637DC306A50BDA186C1781727B3F541BD144BEF3C097E1CBBE9068A1753B8C78467FAD0FF97AC9B64DA6C3244A7F5D65C4B7DFC01673304B84312BEDF9A2BE3326A8D3D877CE83C6B89F669C5A02ECEE9E0D6361B55D3F3CA02C9F75C5E973A53600A9A495643ACB2A7130CE2F5D2DE10235D362FC21D24A5CA33A1C5FB191705216010C99EA8CDD0975751807EF108A8F3F407EFC718BD17C5956603EF6DC90AD2CCE1DFB8EFC73A81847C308871C2C9754B881870D4C79AF40107EF3F818DD07D77EEA12198B8711C1FD1E5F683B833AA6D588607831126FE04B2CBDC9F6FC3606127D6E599542D656354744239ECFAA9CA4445B90F2DDF7C642EFAB0F96F19436FFCAC803BA36271229460DDEE96CB1167D15CD439443CDB3FF99DC66FA8510236B2D165ACEA078049BDD5B39865691FF6CF9057E75ABE08A289BDA68E3B35495D9978D755E9E9AFA1E9D96C4BBBF983352225A46CB00F8BD0C7D3ABD091DF062706F9B65E568DBECC8C83FE24B5DBB03AD93FDD30D861848E79CACADF9304961A57C0FCD9557458849467B5733BBF3931BAE7A23E0FFB41E89AB354EF288BAC5B24B116E2B3656FF600B0B13C57CF115C1AF85E106E7E07A6B0B4F1546FD245B080ACD5B0321E745E881D7A45F1E1E0F8770D083820C064037603717F6E30A9805E529FBCC0274A3FE61A5804A7AA027B1FB58DA07753F467B4C5ACF2913C81219D8AF5C751C7F7E059B8D3EF2B24304ED14766EE8A37F862FE4B540846D0E455A292839A88886516133962E1D01A7A7A4B94CCF015A3E99DE01AEDCB3611EA5C55DF3FA9791CA13B0A72D1FEC05F71EC313B3AAF8B7219A9DCE5D01A01F5650A659DDF4D9B37B90C6BC0D7215B7DE3551E82091B9F3ACC4C360A15CACF1F5C504D012FC982E1479BF0FA70878CF04A9D45BAAC155300611A82A00CE5B47AA1D21A344C321228F636F7B400B3779B2D3149FABFAD8EBA076FA4D98BEC4CABB634F6904C3F92D9875BB8F14CCAA7993800C689EE955E1DAEBCF9CFA190DFFE8823A091F5F123F0E30FB734436A484130EB224896B841D7E483FEF808DB8F19BAFA5731740F33EA48919F61ABCE6D655D78B0D92DC2F26B43DF3F592BFA7ABA940A212AF5ACC2CDE35DC54163322CFE186860C4DC562871305F6E189744C3E56EBD4006E7CB0A8EBC501DF317A31E4708E22EC5EAAADDE744A35BB80FD73A060C9BEDE2F59F6724915C7D81D718C85485CFF3F34BD32D67C085C1CA9575C5530B7996C583A9E2266C4B79C8F4DF5CCC2296752A0C7E9FB93C3167A1BA2C6F1484C75D0288D39AD497D9F02E90235A90D99AD7B40AA9503157089F19F880DD4D7DD97F0C930ADFD604221301CDEAE82C4D32C7127EF6B900B0947FF24F0FDA6A40176F7F948FDDAFBB96FA0634237F61F932B4EF952075E7AFB184AABBC5C88DDCCC12E7C5D2B4E8EEDFD8D911B58D33E699EB4BF19BDA9B6319CF72F2FA1C353041E1C53E86C92D9476E3C138CCDBC6CE15C7F13A9337384D2960B054343B88FCC4B8206B3F60308CFD956B654A3FEA0D0A621C7AB822341638157668167D2BCB7FCCCA6C4A7D8E9C1E45EA4C96D837678891C5AB79A709B4A734B50B27F8064D440B19768EC237E8D283CC703951514DF7946E8F2FB882845818FF512ED101EBB39C6B9B390B9FDAAD3D3BE24EEB9E0FBFCC21A907B111224B35D88E6A050E8B0ACDED2C9DBC9F9E3C4B86126BDD010537677423A3F5321C741F96CED47F7830E6251CA8DC98144238F09F6D71C13F6C187C61BF32BAC97E7FC292515B91E66714374D5005DC0E6116EF1E1A0DBFF8E0989D37E3A58B7B668467ECC00FF61BA3A017EFCA1576F9EC1F0CC48E6B4BF8F47EF53EDF4D2F6F9398F4E38C6A94AF04740EFB07A3F4A73EAD0E2F9D75985852EB58EB4353DC08DE5833740CA1829BE615C8E6DC5F26E0F23BBD566786AEF3405386DF9657FB6F227BDD29274619160D7ABF6E19ED4612A5992F7C9B5948D328360FC371732DD3D831EFC071BA1B658D2BD42A485D1C49D237B7B3DB7F11BADA7EFBAF350AF6BC914BA0D459E86C569C60AA0117F709687435AA91979594C3EFEE18CD2D6D6C37B541C8D494B7618908D95238C0427E14E1201FC4AD8C1AC3E8EBA1A9151BB14255572C07F23E861748780103B57F38210746DFA50035230CB402B31A58034EBB021039305BD30416180B5F44F5975A8AFB85E3D0568015D55068CF6D0D71FFD59FE8EEF4F75721126CDD84A73E1A66B008070A328D8605F38474B58B8652F5AA177E810DD9FB67283C53FBCAB2A5F5A0E172A7379CC2BA913E6F3FF83184D50F55D8863B7BC9B0894B8A52F852992C8E2508DEA3C0AD32CE97EE9F3B7DADDBADD7243432F1102419D40EB84EFD6AF2DC8C735E011023ABB9A54450545BF0B511A5E70D2B52BE9FFC23B1DEF4E9D0391B94CEF50B1EB52C4A004FBCB2DA6F338F2B56216FC781BE8780CB0C21FBDD6EE14063A19BDE366ADF6E5DA29DB2B6FF593D99903DDA7153943DB7C277522330040D9E532606F2BA17A4996D27C543B1A4D1B1970FB969B61B6C4A24FA85AF3DD273F18DAD10FB827D63BA32AFF3E86DC4B8C9B0D94EFB3E5218DC3C315B61F1B146EBF791118DFEC9DF63182DCDEDA4FE33C764F3CE5629D087FBB50DC5EF7575AE0EB5E6175ACBAA05C5F5FBE12BDE707DCC1E9456D19613B2846F9E6505E3BBFD07948CABB8920BEA2776767542546DB74F9334B7B0817F5C0D6B266622F0801B51C991F9F00A69814D4D51E05147C77D3D985D49DBD8D0686D7065FACE6E7C4F4B09C7C058CB04CB8CA34225C90C928A5D7CF46D7ACF41E36B4CD04F15E125ACE5DD0A29BCEA1509DC805F84F5DED130DD6AFA394A8AC3214242B40DCD84952B127BE9C493663C4AFA5843B1E87FA8242F93A5634D986917B99DD1BF3F93AFC9E256B8AEC3570B748B69839562D0E7271C56A44A0F0353E5226C55EF7CE52DDCE8112221FD744DBA54538A74464B340C026B7B7EE19C6D3EAB7B900E42895B2ECD9F2881F39F3AF7B025B1116FCF15B4AFD76BB007792424DB75256A85F47CA4CE93D933F437574E0C51346EAF2B11E4288C97ADA9C0CB9A3209ACBEE87789D1A14D794C9E4C2D0034E4EF2B517A7184889E7638254B6961E21241A428AFDE8F42C6A44122261D888578CD95FF2D3A343514521FEE7DE6E8E028616FE0FC887018775B4CAD0B353B6590C93D856BBE839138E505053F6C0725AEB32EEC7C8CBFC727C8183FCADC7B4FA3A87CAF5B3F210587CFC5D8EF288D2AB334F105595EC26DF996FB03E0C674DA2D894027E7B88E2547414DC57EDE5C9DD335596EE900A28391BCB937468EF5371A29C7EA7501CB574F3CC21CD471D622CF1134062175D7E173308C3DDB46649CFD3C23B262D8C6EE3AA4B42AFCAB5FCE78D62487DD991D0A5549D3C825C1E051B6D57997AF2260F94C71FDBE7062864B0C365D9BA01F17A742E7D372E08733AD8FFC5F1350DAABA9AD5F57185DBB4FAD192C81E2ADA02903F1CA18F3FEBE30061FB58DCCD6227714E729E7CAF53117229382B34A5CBF5BA33932501A2E5337CC71B1CBEF9A1443DB38E6EAE601A0F4FD81A701E5147D2ACA6733EC057A47D67D817DD22D84689820E52CD07FE0A16E936955486F85251A327785BD8FE5895188BBEEB3BDC4B665A25E08DA03854DFB675DCF119A9F6043AF274EEBA68CB69E80A3736282B03D61D8F42ADC400217E905C29D052073750F864488145DEA170B51936144C53D21E83E2C6D6CE0E66C199B949691DA72472B6C9A95BA09C4863362EE7D6F0A76F89F45963CB8CF33535501CDCECA3A0F1DBCEF7A8718CF946433CFD83022D3F5DFF24DB3FB007B430E6E6908786FA0E8D2D2BFCB3D08622EA0B9DDCDC44EC90FA1CD07415D2CE7EAD2576C69A78E1E9ED5907AE916F1AB3780BC4FDBC0923E6A4C65D37C962A74C4F1D6507EB5FDD50C2D3451F49BED2BE367203DD5AEFF3A35EEE666A53FE29F68B217ECAD2C8319360E28E388D9C763DB7EFF3C97A0447F4EBB47838BDD0988141DC70F8CA06992085091EBA04852C56B7E980338B652D861E51F663686E4DBFBB9D9A07D5CDDBCC1997160458A5AF37254323FC3752F35E54FB7A6E80211B5C98CE2C2C89E8ED093924D6FB9E835D4101135D6585966CA957180D42BBA368CCC4D5366017E68CDB52BB175FA6A079F5D7C4A31D146CABFC84AC8F46822131FB813286FF7885BA556048B053D3BC2D3F863761F4F3DEE86441FE07C1068C202E5D61003C60CFB27A31FAB45DAAF13714EB535B24EDFA4111C3A8D5085CF4B303BBDA90A64547E2C34C671CA080BEC22FD1E9EBF5E97BCE4D0ADC4F228B7A78413D9A40984768A9FE63ACDB2C40ED48A7EB530CFBF9F42C2343BB2B9D894E78A56328DFB062FBA5624088A609DD2AF79F59EAA3671B4D2778FDEA41F8147237151A766CEE26E3844E978BD19722D27F577D8A1BD07CA4A4E9B4754CC8589303A1550C740FF89D83B1C2D2BCCDEB07C9463DC434456161FCD76BD90E184936F3474ED011C0FC23F350A8A1F6E02FDB2E7CAF0CD92A7FA6255F4F52060A52A7CDD7C25C0F97F5B32DD52F838AFA5DD9EE18D27AB4CA5E50C001E75F655EFD498E5A26F54BD3B68F6AC6AB3FAF93B003C83D880F3651D74F2EE9B6A81324BA7D650595B219DD356BAE054C22281D902D79FFA55380BC83452B06B2AB4210EDF2C61642A5D20B1CBDD4548C15A2CCFAC7302781A2547B82B8CD6CAB01E504B2C107F15E1C11E8C4D2A17C202A29A80C45C394F1E64E7ABE48CC16CBD9D661130DA031CD7AD8005DDF51A4E9F7A00EC299AF55171F5DCC8B4A8C88A2E629A0D0324B28B9D1FF0508AD77F3A75D2F02FF22D19ED3D35416C2E6B675257A523CF3F60906F3BED781FE07411AA55A252FC9B1EA642DCB6F1B76C12C051DD90EDEE9BEA1E4C704AB3B263E7B49CE7CC794D31F5F8C986953627E8CD9D72463D1DFA16B2FDB915FD1921B71B53A152F2538A827EAAA5A0AE2B2719E3FD947FE5422F7F147CE7E6D3F4D7B2AB9C02AE7CF96FFF9FFA10E43A5BD24624CF3F9B3A2C6CCE15E15F0BDE72CAB4A29022988FFFA4E8B765689577A76C4EB2EECCD3706E36F87F0F04E992E5E1097AC1B57BE81447A43E6AC2844712FB830F5ACCB400D697BDE92B737D8F6D3687B77F1426321A0BD9AC0C9CADAE9E0B13FC2D93515AB5CAA4253863E633D7B8898A1B6A628D329435975807A67C8170C57191C42ACB9D1E3FB355D0364403C821C600A13889E58C73F269ED2607E5ECEFDAD30D4DA8D81ADAB4E1DDA7E613D53F1D91A8419E7ADF7AEFBD +sk = FA812D8CC3A9631A0239474EB93AD3A2A3480F2D973D3324228EF92A3B04316368B0856BCD09DE30 +smlen = 2680 +sm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count = 52 +seed = 3D4607399F6FCBE074FD2BEAB1A7571239D6BE6308617866B65B892EE65399E14DC7FA612CDBC5F7E23116FA86C3133D +mlen = 1749 +msg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pk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sk = C660B84D558A7E6B4EAC47C7B62135668E0EF0FBF74D514EAA3D0D428014282AFE314A1D3D9EA4C5 +smlen = 2713 +sm = D6066021F94D3E8C107B88A007107E78E34479394C4B4C2FD5C7E15D51121040FFDAF61D47F650826FB5CFD8F0CE68BB1553A9E7D8F0F16F75CED3C369835F8CD40C73531C7759C0E6AAB8A474C7C1B0236A6E31991AED8877BA74F51C33A7268C67761447D9B64BB99E8FD12760F4F40CC1FC85854A0059CC7518998165C9818765030768743EC69B9D9257CA6DA835D966C8A37240C2E363046CE60E6EA28DDB601D9E4CABDBA8394280E52BD7833D6DC5DD4F6D0D8BAB201D8F84D566DA1DDDD46DF49C239009C90382A35FF46D11C7E3FEF3355833CE448B58A39FF7DDFD504B2A0E3B5245CCEB413D9993C4BDA5D9DD044FDA3785FFFC054FCF370561A9F470D681A807671A7F906E11CE346BFECF43D0DD7EA7360D4EA882AFA621E5027660144429AA01FBF29A2CF52F5F301C05AD4DC4AC94650AFC623E0807D675F4C326394822B078D6EBEBFB0ABDE9A11B971B4CD6C995D1FEB94537C275A5239D6440FC26E166CFFB70058423B473C87EDAED42451EAEC38D2887F4C3D2263CDB933C5E44B4F1B0352DDE68591CADFEEEC305654E01CB3E0110A7A9AA4EF4DF93951142401B493EF8A1DCD6654657C44761EECB33F2455FF2A997369DB284414DB2691CE29F22BF865868E201FAA3812478C0EEED6190BB05D9763E0037F667E0ED07A3A2A5695F2757ADDCA6170E4B3C41BAD51B93E5A4D9DB965D64E453FB4432B9D45E4F10431376D27BB00335523F203E6B5C3F29F2D799AA7AD8CC7D6A7302D475ED79EAFEE7E4276D4B03631AF2733A59AE5BFF6E9BE1874EF66DE252FCBA6753977D8249697D4CADC2743A2EF001314588E4CC97C16CD9CB6F83C01A0D88E1A02384B6974F7EEBF12B355F1F37C991D4DDDBB4CC48E56C2BAFF7E356E515A94B63997B0AAAC4CD2C65D73F9E12482F98F7D500962CB39CA44365C8522F0D6D9501BEAC36F73AC0A5A2A0351D1B36ACDC4223F997702EA6BB0C82FEC729A23B171603AA33C52927463947B3C457FE84E96E0D5E9F89CE572E54101FF816EA0DA50C3E13A80DAF1579D84355D8631F4F6134BEEB818D9FC9E40C9EE6D5466DAC4F3FDA7DE6B534A43D937898E16AE18B265C0F9730F4D1B723AE65B2FFCEE4A6098A0F24D287317224E9799AAA07ACFB6AB20C09D5B7BF376E1EBF5526C5AE6EE88A9A024D4FA97A181B32C7882CDE4BB74B0AFC8EF7A5AF10E687D3746C66EC33FF44B2F987875055BFC6879FA82729E17F327E9A86889F6ACDF4C395D2C8C4CF55DDEE8DD7E724D829BA80666357A8AB15CFFB084539FE26E9E8D7CCB918A5851A2C7D05F467204D960D3B49A2BE48C744BF1A80EB2C90D01776C3D697E2C2D4A4DBFC582AE98D8FD326FAE96A1849EFE729A1173339D90C48C3A2B867135F1DFF5B497D05FD55130694B5F9C62D136647D767AE682A0F05C670CEECC03475FFD39E0BD4E45B720D9D7E8DD04E69C969627682AD83F48609F6E66D0BE99064988E4654E3913B7CAF1475622E211BC247B98E5BABA1B804E2BF651713197D8A610CC111BA5FD98A053408AD155DCB756D28A283BF3B20E6F3785DD5F105F8D7D9F2956064860B097C675630EDEE1F17E2EB0B26B6C20E260F9A5915D63F1BE2C74FB0B37013244481A2D0C581C4EE12516E0FD4701E9835C8526A490CB39E99FAE07C40236808F9605A63A5106C19517C3711CA4B9E8EDDC77B242575D904DBE64223CF14A8E39FEEDA9D6C5F9CD0D0719A7EB5EFA71453636F78CAB8262636FF1E136C787E38A43FAF02699C1F260EC45B068EDBEEBBB8A0E08CE282BF47D27A33216856F0C59E743DEB13397656FF17FC4B3C694B189C35E516BE719CDA6542260D1301DF93A5D93EE118F7CB0AC94D0364C9EA66718A4BC7F3D7ACFFA60AFB7100F7D97E98DFFE167D1D8E46C912D41EA057362C13B078CB1D9C443C1A57AC18C4566F5F5388F47A40CA49CDAAF34BD4C9A597FFBF7AB20D7CE88DD76A639E09ADA323C588B08140E9350268C1FF76079093A05CCF5E1613A70E6E37CD257875049A767332E5F7420F319F9AC78F97C0C4FA40B1EEF8C8B48045C78F73584590FE41F9F274DEA838DE75DADE66D04E9D9308CB0A9948320D28D9CA8F1F51E39FF3DE20FD5A2A267D127C317ACD51FB779E597A8DC7359D920548B8BCAD761C6B8012304E12628A2652D12A8161E538C20D582BF567E9C2B46B4CFE2D2DA31120C6DF50DF45C80513AA9EEE9F2613A221AA1D23F861C7F26AAC7813B7ED7278EB420A5C44F2A5879A2F1F9F11E14602762E3389B152C014EA9DDC9DDDE9ED1D6F74E7526F690EF37E71D448342C012E032C00E480A699ADE617434C12DA0E69139D0D9036743B9E2B9134B5086FCB96B193330ACE8E4F77148AD0F532E72E1792795080B54D7172FB9AF1972D00AE24D0B3D86528675B3BC8C7B80598D855B95A77667AD0F671F00039C08CC99F5644BB006BA9356B9C02BC935212C43490C741B0845CD7B4247592374AEAA1B589E670AC62777293870963B5132DCC27088F5DA5B831FA570766FA81C2A07B88BBD45B81992EDFD2A7FE934219B1F648DD8A414FA03EAFCD39E72BDF7D4F6B9C1F31A0A67DF03F6709F2BE0E7D1B1690C92CE7B8C6B1054270D796B16D6E445D24CB11229CB0F92DD81190A37838951AD28BE2AEEE6C5F63DA60A911AE0A24B1D05EF2F814FB30AAE8CA3BD9F01D4FABE5B279142AF948B0E6BBCCF7560107C161C816A0D8E61DD908445079BAAFB78C14F68B8B2BB241FB03C237A4CB250911142D0B460ACC75E6B0F58BF28546A4779EA7342238826F636A510CC9CFFEE8BB0292A58A07694C05672B560B26158A8566D01D0EEA0773E81F3F84376B29CE375FC56A0689A7CA5CE94B91814B62CBB61EA2EFCA0CE6712A941D612B0F700C56B46D464C2AAAB3F64A89CAA8561A1DAB2869D79DA1720274D031946C4C7715FB9C243DC95CCA7AECFF55EBA4044467EB922E93F57E3E39B93876A03936DFFDD2AF48D055C6C188F2F229812EC94F3FBDF7D7DB62E4274DC91718710EEC2CE034AEF266207C5CCBA21552D6FB8DDBEE8E931067010594A9E0CB37250F67281C0A369965367424D454CDD05D3C8F35A15F76B4C8C3FEE42F4C9CAD68849837DED3BE58730B94AE3A5F9146F90E03B4C0836381B3F9CCB5DE6BD2455D241BE9132EB6D4937FF27663F4CADAA9CDA193919F4CB0D0F727F6C7B26E831C3AC8DECC234D79D1B3BD28305E3012A3733AD718FDAB7DD1A6400BC47F47D20F627D2449DBFF10E37A62299E22E408A28A806D403CBEE19AFF6FA9B1814B35B9573ADC86F829A08893CFAE4A0212293447D3086E21BBA28049F3ED383519917B169E8A1B7DD64CEFE0DA643A97950A205CBFF6BD9334180556E84199F0B60738715CD69AAD7C882430578F6FBA4579D908F863CA54D0B9862EEA6ABED31301D183CF465B1A256CBD597A629307A8A890F11C23DBFF895B932E9CD2F5F06A4183D6F2D61117126FCD2CE2B86BB44A9A5B402E3EEDBE4ED1DF11716E91A2302CB72D8F0DAE132E16311C80DCA041694AF1EF63F659959FCAA133D9E5668F94D0489311AF3BAD379DE17793BB3EE8A284529A72CDEC474B3A82D92C6CB21C63017F262E0D7DD47AA5C58F5E23F8A37F00D5438717F05BB974F18A5D3E1CA054EA053C30B34FBFAEE88BC0195F061AC32F5B71B2A8A3ED4B8BC4EDAB40A6396C052DCE72E10768526C00610E96DF38AA70938CF844CF445D8E2BF73C4F32A742812D8C1DB53AFC6B6C0A4BC67C3CF7579702312D6C89BF14E9585D2C624D07FEB4B5B57F8E4C5CFDA69A5E922CC1E9 + +count = 53 +seed = 7031BA806F4D8BC28529163B239E0EE836871C51D2D62B601B71D6F2B69B203C81440F8FFC09C3AAD94DB1D880160671 +mlen = 1782 +msg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pk = 393327B7A8FAE6462BC30B93CC1760B42493A7924CCFD30F84156F1976EF7F934C033024283255AD088C37962C6F63224453247490A73809E76A7AA8FBC017ED99EBBB3B06C8DF282FF624A805182311F16744A37047B060C1A9358754805645CC36477A4429CA467164417501D894DC0A1828F5B0218DA69D06CD8755F397F62084E94FD09C3AC2EF8D1991940B789D504F51218CBC01D3249B26B5DAB19209B18B344F79EC5FC40C15FCA276420D41FE7CBEF20B6F24DF3297B7F6D2EF57E85AA2FD4E42BB52CF3F48FA6E9D6E16553AA29A229269137AABBA0ABA5B5A7631015D2BE46640B3F3BB908B70113FF2C9DF07820AEBC1284B024E012C7017FB1E437A53B76B43E7660D3D581BC86B6289B8B2DDD01C1620FAB3514A37DEBE7F411906987B5746765F83E94EDA3322208A5C453EA40990C52FEFB4DA4E88EDB809CF0AB5CA0102CC8DC6BC8A12D7A90BCE526B282B830DDB21349F3BC82747380B8CEAFE2487F172462AE8E3B70AA0AC330136CCC58BDD4888C2858346ACEDAB2BED3748D2431A07DFF1C9983595D2F2D88559DE2E42693E3CA37DBA7033E106AD90731691EB4973A4E23DA4B1A12BEB7DFB58E64A7CCE214F01713093D280FE2CAA8E13258955F6E7E22622F3BF48076FB80198D19BC415EEEA50CB35546BEC837FD7C47352708E66C2196E1548C2E7D3C52AAE79093D13F4A637CB733D9B136E32E15D035754B1A129F5041F26C8C23434190D103A2B0D6859C9BB12F2CB388C36A0667C7AA6DE55F8BBC9D932D391FB0181A5E3431592C9F17605B200ECBF6A6CBB85FC4161C13B0242C74096D7BC961BE95152C78A554F2F9CA2E361FC98117EBD4EE0230D95CE43A944327C8FEC30F15BDB9DD1BC6C293FF426C271693BF6E4587325028A8E6F1E9FDB6D4ABEB3A40A08EBDF96091B38F70BB73E267EA4F5D7A7761807EF37D8DB0E6C83203EB771FFD931758D8724C2D12BADB8847A1E7D2DB8A0FBCBA14EFE27EF2F72ED7DA973539BFCDB0C9989DD1A0F20F547FB07AAD1166BE4B97EFE7AE5BCF4677A65A2301FF4DAE4DCFDFD03201CAEA04699355B89EDB6C8A9A5313E4C8B701288A3BDD2BDBBBCA8FA70A626D2D483864726D8AC31613D208A4E42FCBE0507127CC820832D8F2057045F5EFEA4461695F3926F74754992FAB24D68833AD8E8E73E32DB4F2321FD0B339D3F0C66697269FAD077C91838BF92DFA89A00D3C118EEC4B3E54143C9CEB46FA97D48B55A168BC507FFF488CC518A6FCA305635627E77604C52FA05E4AE80C1A203C5DC16148A31637E9B5190E6FC40E6EC30813F7F189F0BD0ED731CFA69FFFEDBB98DEFB4AEBCC7083605FF196FEFFCEB1CEFA2FBB76E4071FC51A06709DFD03A37EBEAB99533339058C23F65552886D521FE39C66C44D830F4B3210C9E918FBA093EFD97AE049D040D9E679EE812634D57A77D010E76CA90C1B0CC7374DD72504727B1C18F9F80978510F8EF3917FF1FFBD9F768EEDE1646001C5474A09966E0C99AA3FD2981F297FC680BCB06DCB02C4F5BDED434F300C7BDEA8F8880F450EE1E05A714B2B14B83A6992007E9125515114607B3D6B09774BA514FFD49F724785CAB3CF87AE8AE4BB64F3E627F692AF50DF8ED59A5CCCAD4F84F85472DD16D870229AEA18D2FA8352E3F1AD2019E17BF1ECA74936D39F518029064580A48BC8C25A5326E009591D07B51D748283CEBDEAFAE4544D2EE0ADB87F16DFABD3D20CAFEA532F52FBF85AF31C3B2EA1340659B3F0B4295F9D1745871FEA3B7EB4556E94BC3FCBCC3E8C8C52A9043730AE709AC57CF86FEAEBE26CE5D1B6EEFAC5127B9725B55316868D67ED5793B70AE3BC479BA672C79B932C834D8112F951341A91026D6D8CAB3BA62287014B96BB5B512A84C2469E4A25306509613D903C611AB5D50AF7C910233B89AF4BDE3CA70DB0BAA552CBF33C27569E749DE2E556CD59E671BC79E0FFB266961D89308E6F899D2432B63B49140F759E7232DE661E6C49BBDD1E70B7C77A8BAE595AC1E2BC2F65040A750448F2EC9F6A3B0B11A7BBC6635F181EE9B75E708C81E561FC710044D7C45FFEE3820C5FC5A8F4939034F081F71CD537D360CB4E21FB00547227956E8648FA7A87FD796ECDDA70FCFB0DC71D4596A95493A7FC2D601B1D424B05872EC5BB59B05EE9630F87BB3C41BD4E39B2E1845373CEA2D2A8DC300EF6CC79E29DD0722C10362F307A04E178425C14231734A1A7C839FF6A152408226EADDA4DDE1ED7466C55310237B15F417F638AC3B6D209C06F7EA7C3AF3179BBC8B8BEA12B3DA8868D751FB40281C2F8B52AF5FC85B0228BDE4233F7759C9778BAECF6A675A701381CF32FEEBB30CEF98C635322CEE2A74AD81A22A3EC881DF41AF7BDD5F1E28824DAE0088516C93B0E462217091C6A302A9D49D352562501741E5CDC81DF96D7AAFEA0126CCA3F3E0D63BE639132351DDAE7375B74257425161975FF8F7FBB96D0FFF1E877C3BF75BD711E1C4EE301F8A67A01DC4446D60C8E12E1DE2AA66A956AE021CA94479175401BF836E684FE1908817CF604B1A215DEE2D83352AE1C625C2EA5FE842982D685466BC220210A9B63E8A8B5CE0B6509588C8E5D37E622526C57A7BC65C27BD98DF3CD4C7357DCF9AC054A79372779DCFDD431FAE4CA115AB1380BA6E83C9D5DE563B415DD2E504CF7045AFC2543C1552512E0C7C9C8760482D348880ECD15EF65E5CAC0362CD0690B8905E5709D887D560B268B72A8A47653F06FB4D0EE2AEAA0B415F1EE6BF6B6A9980AAF19281721B195971AC60DB2F39121D846BE1F06CC3299F0AAE527D9DC3AEC203618E3B42EF8F041D6A4F6C3EA47063F580FCC6C3881ED7D8EF70C75A9DB08EDCEF7164BAB8EAC089DD8AF82FDCE3C9BA08FC000E34867F4F41BBB4164C8CA10ECF195BF292D4E7C1991C76B41276C4913DCE87D77DFDEF60E0C2D963B863BF5392F472C29EB5A2E9F209B8C01DE2CBDAF20C081DC2E3144E8E1CCB27352E4790FD27B6583B13EA0F7C4BC1F63D46F336EE6DE968CF5AC03AD18D5312A685925173F16D6E21E7696DE547655AC868D819C0669B3F41069D4CC3B49DDEDF061DD476ACB101C6D76BB8A70633F5B7F6F1B5CD27ABA420D3E99341F270137F50FE0B21D85120A10D9D7EF1D2C1D4E1EB18E507BA6797227E74D5FB163C802016040591B57FF1CAC23D92994DF96AAA70AA6A6A448E04C3869E1C323100B02CED415FADCC6311A3FD7FECC8A2B3AD7CBF3D36B086AA0DB97AE8738BEB1024B6BA67A6E5C31EBE00D322F9DD6FA47CC4580F488911251BD48222142FA7AA70284D533FE87997E66F323032C6DA1DDAF082E3647F5F72D08D3F1C0B936F7D3A92CC6B94C2CB5631B948F0617CE8E04AD734EB6415D7B151EBEE7E65222FEFF8412FEB2D7E5DD6B0E65E42B6B9602F6970BCDE9DCA8037D054F4776DD885CCC0624D7800B8390C7F9F1FCA8A5C09EA3D8485972882F3B00CD69B5BBD3F4A8B1449E8DCCF1EFEB55B78E03AEFFF930768EF43B3D5E82725F71812604525714F33B90B133E0E17289EFAC96D2F5F9D71174414DE0A7D84BB6739350A1BD4FA7F00A6A25DDBC383CAE83D8B61FDBADBF0670420CF571DC49C32FE8950ABE547D99E5972498AE3DB9E041DC686ABB0A47EFF28A7879E59555FF04968B33FBBE91843A7C198E2E5694A374C981EFBE14717B83FCC3CD73921F7F39BFA5D0247178747C6BD0B36DE1C2B5FA0DB2F2824A6456AC07030C9E6B4A34ABBC4DE5EFD9A63735B577BED5E85A3670CB572284A2638DD0D99C69B58AF2ED3C7521C52EAF957510AE7BDF34B9EC8D945E9DA617108152B0869D0A86693434474ECA1437503CC308BB164D8608BB045A7AD0AFEDC1A5E81143EA3CFED0F770BB6C96752C38F5F1CC4123A4431B3CD1BDB3706200CA1D8716D567E6CA8CA1359DA2B9D856559D271E6C1D8496DBE7878DB5F0D50E18E67B1B2EA33E6BC520EA53614FA6A2C0525C51C9DF4F75494B87054DE70FA86F6B3BD2ECD1FBE1255A8026EA4D177553BD5DDCFB8403E9DD4709D46E2ABF87BB70B34B6775AAA9A817E7F0EAE85CE7CCE75B955BA0FA5B7088C59850529C5A2E5BCAA093DD255D9FC7E228EC50871FA013B5DCC83F9E541FCCC07F293BC4CD5D19345E1E1105806475CF1E1B4E1335054B52532D44CA789C5CCCAE9F138C0F076945CA175979CF4408F187AC6506273823E0C93E677307ACBF8A49E191A951221F996CE0C0945F43DE9F906F9DF9A0813227D0B82241DE0441C2E96A008F34995E3BBC202DB550425B9EF676459B2A6FD0F0E898F4E2B77C57C121EF39A0D232A2567037ADCE2E5047C258EC53E75EBFF2B73C92816F51F610D5643E57EE6E2B1204E3A17FE8630D3C6E991F6D05294D82B8D387DB2E9CD4F81CAA99732D1781FAFCCE3C8FAE3153D1B47669784D326A10D622B296A80B4B938FDC515963BF484C8730B43CC63353F07AA7E9781F7F2A5EB4F925EF9572C6B9A849D389D109537EB0EDD2B28859C5709E0B8BF1AE43D8E35534A0CAF6A8A0B7FA90CDC4B55F64900B96A35A6CAE4C8029C169B34004A4BD4EC6579E5C95A374C9376FCAA596FBE649FAF459DE3BEEBCFB6E3F805D3F2788AE09477FA877522290A25CD1E12FCE3DB27C6E82FE9B27A1252EEA290380784CFBCC88A112A1EB773DDAC7A7A12D0D6654F8AC961B2F35FCABF4D3DBEB9663D862184F3BAFEDF694572BCB1A60D4479062812565679BB212B520CDA30AF583BF0DE8D81989BB182F9EED59017FD78B6F984A55AEB6D74FB6992674094264B7B6FCD5C61E0D55C8DE37E2F09BA360C48D9657C3C95168287722FD1FE5443BC51D0BE3BC9A2F84B5123AE58C7413E040AAA626092BBF50F56C4A18C591C6350BAF5D52BFD2F6A5DC69D911373D6554293C71F1EA7DA4344D66AED6FBEA2B3681540D468E9CECEB394B8F116B80FA6D84DBEB2557616D2DC7A42192BE1CABF4191EBD3FF2A8FE23B372FB7D1971014E802980AE1C572A060ABF7F7F747FC37DB70079DDAA42A68399B133A91D98F138FBB68A8C6F4A4216A755E91B74DAB43C2C93ECEA52D3AB6FCE86DF5742C27CB4BCD08B97E6E75592C6707A8996DC25E24BBE76E95ECFDE06A625C86F3A0135B8F6A0928C783ED31DD55532D6DDD8E78BF194E4893D233A47C2101A39DD780F3F257F2A7C7CF0F117F99FA14498D9E3EEE3EB68FF6C38E5FD1A7DA7FC94830F30C3CDCC90A21E1FDEC42D2D0410CB5A122448759B6ECF27EAEBA89095EDE49E22B44149D700C59E9F2CCF9A0189734EB2E09C3CBB84B9DDBCEDF0A4D78DD34A6BB72743F722F8797C5BD7322DA1945A2D004899D1DFCF099EEDF427DD7D55A8FEE8A6084B1DA9074C3B2EDB32C4EF19BCA46E66496F4E59A682BEAECB7E76CB20D2CBAC00A98297F04746972C1F73FF213C93E64BD9B2239E33AAA42B6ADAAE843013CD73A65E002037CFC01F4F8BDC85A3646910D5128EBC595F02CA4F76CB208AB393CEC86364CB6E65403B74889800D5CAA16BE46855897445C3F1E6783F19F824B2973FCD490E33E02E8A97BE169D361E64B1DC1D528FF540561F0D1741010D89EFFA232CB0A77A772E2D4AD1D2372D1520CBF89F1505ECF58DC1FA314A62D685B21F042D91BEDBBE1C8F9F940B993B8322CBDE4722BA2816A6AF2CCEA8B593D75D943483AE9FC3FE6E357A89E87266A806A30D0B0CD4F3489B8C35F6E8ED9847D2BEE6A5F0720D7588C0E3C05228E12AD7E2B2BE8325A7B4F0FABC1D4731E40661851F93C2B834A9DA6E1D3E9F3C3EA728257B3BF229D756C4E78602BE759D3E69B9882DF631E0D8E4BFDF59D3ADA754076894AB1D1BAFDEE7922D7936A585869A53A36D4EB0A2AF193AB84011322285695622389165C256E700EEB59077087EB8833F0857EA681F0F4539732659ACF38462B62DD8B4FA7C105529AA1B32334AF12E7BB0B63CD81FD9B7AFE8E0B9A63830205195C6A05D82978F54242C05E32FA285A9D8C922AF5B9845137CC7DB12FF762277327C2034C447889A50EB303B6E0B229B601192122B82A859EB6E7CAAF6C4228830DB293A3FD1629DFB8092B039FD76E998A60757FBDEC7689B93CBC607AA644844EA33F35E57A466305C797277A0D0A7D86786A09FD21E85E37B8156EA0AB947875475D4F3FC50A89BA32E41B19BDB8068C4F4C0E35D836B3AB374AC141FFAF3AEA7641F0DB96A717A7CADCEEC73C06F10D94FE3261367A306BF4F6C1C6F083DFC373EDF520E2225BC0FACE0540F40BFC9438B2E776B0FAF24A60A9F6E6AD957A47F94400AC57CA7EAB8B37CAE9FF26C371BCEB28D0BFC1D22F7C9F16AEC0207C7C913AF6D016FB2B96580CEE48D09B3104FC90FA9F5C11D6E6470B4181108AFE45C647B5192907B9348FF08FBB8690F41FDF7BC609447A8D1CAA1AC69A1BA570C693D1F01B3ABA313CE4627CA0D74C5AA7E48492AB0A6D9B064CA1A2A6BEBD9D1DA4EBE1971A97B48AE157FB66CC7DD1BB434C905F2A6D347B518C10FFF0AD2696729B372B30579056F05CF8095E7B442899056AC5F247FE5793AFCC5C103E5BBD6D45DE6D639A62B240684B96E45D94C9529BAC23AD9788EE2F9586F78EDE1D5D0CA774A97ED774844D23A3D975B94AE00BE275A1120F3430D101729520DD6E9E534E64C24E4DD2F313AB9D0FEE28C7DC4CDBEA861807197B39577C34FB110B38EA68AE9FF8820A35E23997BC0EFEE8551E89432BC53C5F3C57C77177C8D5B113D39B84EA2C54B502EF1F43FB17D9C65EDB8C641C06E11B48344FA8F88F302AA366A55DE05DF09A648D1F9BB05B037E3D66E3362B2EC33CE0F4B7967A526E3D3DA9DD7C69D04D7B76EDC720DC88B4CC96513DD339C18437287E8F6EEF4975C4D9C2BCA12902190BBA50300BF9A0C5F4801801E4617396F88C697A46C8A2B334CABFD5DAC20F1957CB5027AA245DA1EBD41BBD8BCF33527A9DF2110ACD9403BEBF48CFC04E642BE867553C0D59EDD2D6C4B7E385E2814AF42B59A2E2E9C95154299787155A7A1A8890DBA43F35BC641412AFE061F399D56CB621D2AE40CBFE110790EBF6E6DC96A169D70ED707A0C20BC81A67A79B232BA0C848B54AA397FF8610F7059B6F7B0F94395C1129B9971D6AD3781115F0EFCBA1790F472F24443C13182CED5CBFF1D13ABF1FA02978184F8267430896B53154834CEE6337927489BF7431CA859B0C1FE19DEBC17D2D047930D9B5C3CAD4E5054CE08A7E788CD1D6F98D49915CBE4EB5559BBF849D03DE58C67BA7D820F6C6DD0488C4E3308A219AF450CDB6361991E26EFFBEEFFA1C6D791EE6C13C9163B8B8C23CF9B3C50E90CB72D294D20DCAD74B2C48DB20A43D64CD0476CF0877E377A710675D2A8A038961772260F7271A2B2A0C55D89738D8E2C4C86A1F368376F6F9C21089D41B885B15E9D1E33932799D4F9188D2FA973DF88BEAE80085BFD59153B1F4F13974EB66059705FF0CECC8C6B2FDE866420FA1DA13B2B1C2F6CFFF9D5B563363192BC6DFDD396BD7CD47CCD8911251076751DE1C6702BD3EEE741D67D67FE532E86E7C86A882D010E7EE82249C63E5F298C1891617A440DB1B718B8E6251C13CF372F9E10C0CC9545985837737FCDBC93559A26674C68A705F65B6E9BFED8AFC4C88D925915626A3942A405934CC8B6687D19D53509E52620B7054661AE4262B2F04A403B3B748A2D944998812299355B3F4483C5B3A6923C94A7E212AB9858ACF8FD2F2AF8A46BE8025800C3CAB3C03B23663F30D09B8F931D06F86F3D273B127EC4C9AF226E8FAD1DC61A189185B0EDB74D565FF3B2F65EE7CFB3AB73E2BDC +sk = 929F309AB3F90CDD9C21EB77A7CA762CA3AFCACBFE3E67B056290835694BA3D85073DCEDC7077122 +smlen = 2746 +sm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count = 54 +seed = C8671A5D752CC6DDF075C899797603A625C142485EAC3D57CAF14F2244D7F84D116B28F959912A758E519D588A6A07EB +mlen = 1815 +msg = 3EAC87B3D642CEAA3DC904AC3C4245CB2A260E4B74D0394D33D4B71024144180A727F80B092305F31B2526998EDF6F98E46933FDAF0E8709E98D54F13C2701C58BBE35292FD3334C5E03D345A9A2EA1E01B2C4573567FF1FF3BA7406A16F5A5805EDD760AC78A3AB8602E415F67C7CEA5B36421C79F83CBB14FA775448A832A4B28851CE215C11DCBAEE652CDD7342B6B1204727479E6208FB556CF08BF7EE230F32659E829CE4FBCE0955D01D36624BBAC18C1D25A3E187722F8F74C88B56E518CF0E78B3B0EAC56D8F13C4AFC4DA3613A41CCC2B0B0E2EBBFE5799E479F81335360D483596E9AE926751EC9B956555F271C2CCD85F0F6C1BBB2C326C29B5DDF6B5C4C11F8EED15C0143993FEB626543E92CE4D66C0BD28C79ED1ECB793A3091D6B9AB510B0D41AA42D70C2D8F26EA0B826C8C375E1DD89B3E2A48FE5D88A462DEAC33BAC35AA32EBC010AF7E47B77AD23653D747760914E0CA12864CD401787EFD96F30D82D8907DC68578067703DD19B2377DF319EB540E8AE78B2BE86BEE1C915FF3B2F4B25C0AC22CCF89BD85371961944D8A4E6D20E2D3E9DF3A07D3BF6986898786F0667545275FAC3EB0F069B457D8EBBE5F60125F94756DB04EA203451A0DE160CBCE2A34650D92F200448B097691A61361AC487FBC3C82B2BD7C1ACCA02031311971C3CF69BA459A0B640A702DB4467973713A6F2466560FFAC0592D64FF1D4A935220826EB559CFE0144EA4B8E54EAF67DDF91988DD4B3749C865008C0C1CF98BBF76D929B85C8C426C15FA56706984E0F2E90658FA3CC33EC9FC700976870C94035ECF9A0534B18D07F55923663835416E40235CC2550BD9822F0912CF101F86039830AD9102AA4A3B6777EDEC5EBE621082FCF81A1C6A528F0324EC9D39FA80B6E87D6366E7EDAA0E14337D6708F7C3D2FB1978F4F5CD594FD35B267F9CD09370D3366DCE286CCB9647A1944F8D8BE63E5EF8F6108CC5E9AFE9127DA84E1913439EC35A4E17F7782DF042DC2F7C5CAD8A659DB282E61763539B56C2AFA0F2B507D549EC8C9E76C7DB306380CD7B46C9699B6DB8BE06CCA15E8E83763137B06BFF02DE2738A46C61B70EDF4F394D54D0453DABF689FB6BA41616BC589CB9847224E74F919B6E03672EC6A52584FE81456D6E648DD6F0F9B068EB72241F067BF6B891A498A9A59356C735E10EFB37B3ECF47CC5620A35442DD81E25D2C6DB0E9E871301ADD193D628B30E3B4345751BC17E0B5B05AF758A653DE7BED3763303FFE1AF05E407F296C736CA6F4C348B25718C7A814BD0730AFFC057842AF3D9B9ADB12FCCD740ADD16218AA57E43835821A2BCD70F1027F3042D4A92F10D0A1FB8323E87869BFA8DA24DA75F8743FA3038C24FEDC0C987065421BF4B300BE3ED3F6D6D590968D3EE32A8F5E20EA6168756AA18BB78B6AA48C299C36D0E78B6F84CACAB5946C69179E461F4C2DD201D8032A29EC6C52942AC37D9C76AB4A401C9AFF96284E1E9E39BFF6D912CA33B6118067605EA65D7F611DD963F4F75F97346FFFD1DF84C79CCBA06804B3017775D8C0BF614FCF4D824709557937B22E1805A0A961ECF226F26E3706362BF6D8D1DD30BE7EEDA481A64961641DC57B9F0211F8EE43578E4C2B6507114DFFF3C3F884586BFD1278D117F7C6014FD5980CDF1E2FD1F34CCAD170842B9E819C22FAB9890AE265C3BB6946FCCFE218544D00A6BA5BEF5224EAE24002B6E83E0B35E98C2322BE2EB3D8234BE8B048C54E40782C9A24D7A8B461EC05F38A94AAEF3DA3B46D0D85B0D949CF1089408189FF97C56C7DEE50A004AEAD82C15C7C0D0965F3C65A9A715A65D29CD3614954EBD91EEB4E74F862FBC944C56F2EDEC4D344F92E8154708AD0F5575880503EF0F107A9A9DB99BAE82357C16578F3E6CBDF9B427DA88DC322D11C6AB2A6AE6F5179C94454E09DF5CAA6A519A4C1903C8F2925639E12AF793695F256BF0E55E0D45B73880358F09719ED89A4A1A07868BFBF16095A20035D5D4F99FDA19DDAE3E21CB98308F4508B5CEE706C27898F03A2BF14F29ACBF055E4AB0713A7B6FC1A7853EFD36E1290E69587FEC15D492A66B9A4FEA6E2BCDE61E02FE18E06F59A2F4E06F177B14CE4C1CF1A8D1F49C554A8A4C68B9937B4C230320C80753D4B071BAB2DEDA89C9181820336F1E766E447EA1C44E15CBB7C002C1813D2C1726DB0E4DE289466077DA9610E5F3AA313B1B01DD79A4056A8BBE9D843CE5B0439325FFDFE91FDADDEC6CB86D5CEBB68D8F9C0ED237A4648C412780ACFF48FD9CE817EA70D950DCB989EA6B11FD87EA4F30347A27488C5C15BE7FD6D1280FEA3A7C022F8D9881FAC93176DB2025B4C7914A51099893A791BF5BE851F325347484CA6ED51B2BA71548A6046EA7EC85B31A9967E7D119D2CA3A51C1E14D5A3EEF0D41BDD615DA01D45979007A1997DE281BC340C3203D5BC0075B1AA38873A9DBB9D18E6E26971E70B54E41E2C8C91D2E60FBF85435C1EBC4893C45A201B1D2391549F52A1CA3E0440ADFB746FBBF0D9933F9FA0220B3E04EBEBB29D2A9AC1 +pk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sk = DAE1EBA78AD1568590348088AAE88C1ABEB59626EF65991CD76AB81198E528371D32E0D6FC3136BD +smlen = 2779 +sm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count = 55 +seed = D780D7688AF364949A196657A066BD48FFA8DC45B4885279B6DEF362E5957F398CDCE1D20FC3F8F63A275C325FCCE654 +mlen = 1848 +msg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pk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sk = 15ED428927A7EB0C7C2DC7A98CFBB77BDD773FA8747B8232A6EC4B87CD7DBCE1B75810662AAAA98C +smlen = 2812 +sm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count = 56 +seed = 36AB8588F5233D15674677535A682382C29968FF824031AF646F58FCAF0E83C1C486B1E75479149FD6F4D9E8397CAF73 +mlen = 1881 +msg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pk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sk = BA7E359B1F669783521AD35EDABE97141A816C2FABF0AD0E001E21F73CCF77369C0FE006C70C5944 +smlen = 2845 +sm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count = 57 +seed = 4E94DD734A371A7C6AD4A567038CF93BAACE2B9D30F3862198DC55D2F21F8FDC9A7AE5DCA1541712179E3AB1FFA3F792 +mlen = 1914 +msg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pk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sk = 9DAEF95C8D5A61D3A3A267FEFB9F37D6E677D7BA26A3A5BFDBDA8C281BE89CCBF953A631DDE06531 +smlen = 2878 +sm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count = 58 +seed = D9281003AC5F7673E0E9A7BC29C4ED75E6B0F228DF49D11A2599BFF2DA9E887163BB26DBA4F071FBCE02891540EC6F1C +mlen = 1947 +msg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pk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sk = 0531B4105CB209585F9FBC29CAA57E64C2D40F0829931A42CAF7701717D9096EDD3940C8279400AB +smlen = 2911 +sm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count = 59 +seed = 750A74866BE8DF4E60BC14BF36E6D83ABF6DCBB86792D125CF0980007C5435F40F87BA96498A88252D9C5C6710807652 +mlen = 1980 +msg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pk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sk = 7F8515AA82DBC9EC8CF1DED5AB58EC0D08CF686E25A8C01FB1109A3C68D19E48F0BC8CF3FC81D0E2 +smlen = 2944 +sm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count = 60 +seed = A832D4AAE8076C4EFE8319A74CE315928AB765BB629075254CBC63EAAE691C220F4B5E1839E9A99D8747AACD7C2F1EE3 +mlen = 2013 +msg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pk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sk = 5AF3838060E0F83352A75A0EC4ACE2CE8BA119BF89F34CB4D6B8E27007CAE7FB67890942ACBEA233 +smlen = 2977 +sm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count = 61 +seed = 09B8441F47235EFC82D71933A0037FA4F69124C3BAD4EF6A3A7178B417A3FDA874081B7EEFD7EF1BF234C752458FBBAD +mlen = 2046 +msg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pk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sk = B323D48B567F7EFFFFD47A7C9ABF0ADD5F11141737A8AF62B56E042EE498AD6EBB46B59E0A80510C +smlen = 3010 +sm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count = 62 +seed = D2629CEEAE5C95D3C34C1FFCC2338B4A97782BDFCD39111E18540B69DB035B352D012857111F816F03550BFE5F56ABEE +mlen = 2079 +msg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pk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sk = C1CF3107EA9B283419E27DC563ECCE950BEA78C048A3F49FB42128819959E51C681731EACAED895C +smlen = 3043 +sm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count = 63 +seed = EAA4FB8EF0290A499A1D92EE398A8D7E71CD3CBF01A36750DA4B7EFF175DA26D17AC4ECE49A84C88D1D2C2493563C26D +mlen = 2112 +msg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pk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sk = A50FC40F0D9EFA5D254943DC599F7DCC2F6D197A4D2666D5D69CFACCDA560817AC138606688C27C7 +smlen = 3076 +sm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count = 64 +seed = 5909111F333F3E939105DFF8532548927EBF289F31A72F4C1B0C66816D8B68F64622F36A9BC85E63601BEE8EE7CB3DC5 +mlen = 2145 +msg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pk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sk = 4C0F0EF1CA8073A562D5414584EDF268913D53D5FB39FA639E02E900891EA82CD3E6BDAFA6F88A4F +smlen = 3109 +sm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count = 65 +seed = 238461A224ABEECCF709AB6CACF4EDD372D45E5F4274095273A49AFE614F2BF713134ABF68B4DD058E6D7B612C3658C3 +mlen = 2178 +msg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pk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sk = 5BA8AD9B66C93CDE7E7E616A97FED8AA91BC7235FB4DB086CB4021877780C6B43E324A0CA4E88681 +smlen = 3142 +sm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count = 66 +seed = 83C653708FAF3E5F6FBC9DFBE6FB5E83E572A7688645D75D2C4835B28695DEA4BD7093740D0FF43237354EAD1C978BC2 +mlen = 2211 +msg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pk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sk = 25D957B9BF68326D2EFEC93DA464F43E3DF16DD6571CEB1AB68BD58E87734A51441C9A21DDE0D2A0 +smlen = 3175 +sm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count = 67 +seed = BC81485EE93AAD8B464B5199FFEF9FEFC06EA97645BDFE0B4E915B812E606A77F93917ED925E882161CBB909747AC4C8 +mlen = 2244 +msg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pk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sk = 24F0CD3B05D964F82D3702BF0A613139808D49283286294BE57E13A983C3C961CE90F89103CDDA99 +smlen = 3208 +sm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count = 68 +seed = DE9E2742591A5AF6A6153DA85A510C39FD31A2ACD8A8511F190A9A5E5753E63D9801A8019508E67DEB1E9219CC18BA3A +mlen = 2277 +msg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pk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sk = 5EF2732B63A1CBD2CC239EA6FED62F7FEB3102715A5BAFD8C83AAC33702FACCF1739CE2DCB5C5F35 +smlen = 3241 +sm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count = 69 +seed = 272E459EAB6A0BDF720E4C5B79E641C95BAB66C3CEE261D0E3596BB04D232ACE0A1CE24BACCAAE9037665A962C711B08 +mlen = 2310 +msg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pk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sk = 6A27B1666AB6FC4483D14CF84EDE49FEDFE05BB24E008AE8A01C52D83B8D40FE99115913DA825740 +smlen = 3274 +sm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count = 70 +seed = DCC58DFC13B035323ED44BE50A7096F697C9C143518FED50A59181160960203831A9904847BA20B85E99FFA63E4AB0B2 +mlen = 2343 +msg = 954511394B9D10E1BA162861802A717E24EE42A346C9ED280C88E267A41EC09D6D73B6076E7E30257BF265B71A0B6E0CF408F02BA9078811BE94D0F38559E9985463FC9671D182286CC4F18CABCAEE1A3E5ABDBC384FB27911168B54A387171C0524489FDF512E4D8D2F65050CFE7405D8DF63A79C6E42A76F4538907EFF4DC5870095241523F56FE8E389EBF1A1CC47DDB9F0188513D5259BE257BDA5BE7381F22392CDC2406E0F2448A80F3824F2670F61920C667499DE899F0F6B397381A2DE66255E061AB92CD864DE75C9DB7CBAB9FE76AC38E0AB3389530B4004055268B289B40D79B32E5EBCC74353510BD1627E2D5DD0BE7D3DFD04138F6E3EE7526133DC70490612EAA5024BE6FBEFAB24E1E83D8941A113D8B871F3DBC3011869174888CB7A265D7DE9AB99B999C19AF9B442EBDC904FEDAB52CF40B787AAB35626417C5291F2EB892F43E698A8C65CBB6442A4832F33920FB2DBFC50B8E996FB227F2FF294C385A330957D2FADA9F86839235EA79ECDE6D9D94FBE7C79A38D40B9A8F241F53B921107FF1C72624C9600EC04DFA1160F1FA9E5D986A5A363E9CE8627276DA73F5DB47E4B90328884CFE93194CFFA6FA680F77886E4A7A0FDAF13A7DDFF6984B8855E1F58235BABFD5106338FE2B075D4F10A9FB3D3C5F829B7C61B02B34E9BDE6E62CBCC3AC9F467A6CA170EB43E632EBDBF6847F781E2469B4740FDB83DA34CE34A286E3B363A72CBB13EB66CE1DE35D8FD77DBEDBF45C44DCD16E6B58A1699694D9006947C8C20810E85E3EBF8FB2C68B967743642D86556AB6958E545AB83EC24B96F2B4BB99CC8890C3C1E0FECCE26CE09B6D99000694F870AF9F642374FF0BBF61EFC7CD5AAF5667FC3FE5745DFAF7F13FED70FE070EA4C09CB1A92D8B7F0DFD4B4A4B7DCF4CA6A97043BCEF6346F1570F37B0EB48DB8D15C8A82ED69B0C7833D6C830414C111C987471E84D2CEB5BD973DCA34ACD3A65D7B1A502368941935435B78B8F2B74C2BEF127D96651247BDBE68EB7E466B9EA2A64A13C375103D7C8F7D30A13CBE184BD1EBB19F3274E645F5C7B82EFDF09233D8AD146DC0715266963FD3CCE6F8CDEC20743BF1B7F57C101AC24C64D568923203E1A6AF03A700F5A401EC4572BBA528E284C151F1D108F7563858011FAB32B3776CF2B910D7B21180DBE75742032791018258F4D1407C9A213755C5C91205352DF919B6F14BE056243DF6AC2909E52C9A79F6917440667719185F1C5F1AAF40D873BA22956FA0BBAD9C35360853333A10A0841D9D2E758A0B1BC187F6BBD31C41B74F9EEEF1F7A28BDB7AC3D52FDC6FCB3EF0383A06A61188548963E552716D2BFBD6C2DCDE496D06615E86A5CDB76A03BCA2822ABA85EC6807EBB6918AD2948D193CCF74F4BDAF7090CD4294C1785DCEDB6B55886A848284A6A4A88A496800053E84A9F2DBF6B334AACE11A5A540626716302E259A64C6316ED543806B3BBFE37563897E83BBEFA570312DF908C1786DF0FCF55069EDC336501A5AE9D4BF212D56A9CEE811038656912238AE284575EF8DE1285B763AE54ADF44F91B6DD9E309B7A7A0AB71EC2E4611831B3CE1C9DC85CF907B52DF7406B06367E7A43DECE72DCCC57D268820EA021C27056E3C6B50E7BA7A59B53539A6B7B06B35051E3151C23F3BD3C889B25D0ECE1FD0DF1AEDF657FBB096CA1C861ACB0158501EA1AEFBF6DAD11BDC325AC1CED3739A40B7A83458EF4F3453C0F6EABC1A48037809A90480DF9DC4FF07DADDC58DF2733D49A4FA53C2A41E55A4A0167C6D33BA6E752AED3A125DFD6A0322CD235254505D7B3CED7A0DEE7EB662ACFD30F8B79D1A872998CBCF15CD86E26809E0D2DA0324DDC90FD12CAF9D8E4EDA437FE4E658D47D67C95927C4B5DEE965B940CE93E6743917296E10820A7101F8F633C93069E8B569F4625AFD4EC61BFE4549FDD06C2290A91AC0FB40CB1F55DC8BC1FE695C73AF603840AC0351F5256E00555C984E79A09E58C566D1A117B7E569BEB5850FB491FD9B982442B55BDF53832AA65180DCDDC2F768B1A1361994DE8C25F3608EC853D5982E0AFD1F9FA70170FC3589DDAF958DD840B4B502F8E2697D01AD7AC2233F6A16D540EF8D232887D2B4FA727AE2F038A69AF3DAE69EDA8EF6BF1E0B67D811160B75231543EC5A4D0778B7B42FC1DD6732385AA4400450B3CAEEFDFFCF147635CFA4AAA53DE4EE3035BC40CE8670016384BB877A86A15B59F3DF0C5D624D3D2B23EC46913618C745330A96C715C6F0BD096487E89B917384CC30B3D20A332F1B4056462227E98AF9874FF1D18DF2A6BF84AE822EE737F9E34EE8C69F23EEB9BF38ED056F499545F405759355C104284A6D08A9EFAD8FE28288B2084336A6479A6D42404F3E6FF3AD1DFC63C8AAE971AF11F2699F32F57AD29188492CE07BC1A271035B4D13A686EFDE5572353283A0F3138F6DC05CC35E5E5057C5C8B9E12B0164C0915ADEDF40A6E23848FA59ADC0E65BDD2120486942F232315FC94B4676751A35AAED2828889864C4CB7DD95A662A475733C2CA8F6997A9C822C6C8B9DC95A8B4C367E613E97D3EC6D6DDC2F81022EC21B3A93244E3BC8C2737A7724A3CBD480B26819EEB2676FD383601D79FA266ED3F9BAC2A98FF0109AD7E43E33E108D88C09BA82AFCCCFE98F50F789109D99DCD0A2C61947544F3666EDC621B5D5ECB7088B2430A611BEA52BE7F5EDFC6E2649F5E81F6DF72FA9A748BFF06AF766A60D2B751B23A8AA95CBF733359F7C0CD19B1482A6E6572D1570349C688D78CF8B8C7DD37576DC47A193A2C2797D0AF7504DEE303823A8B77204AE7B6E91D431979798A7EDF435056251D0E3F26B2CA16BFE3422CEA0398D30F0A0DC06DC8A93D27D13650E5BFB6BA04C93FAF0D7D06F99FE4F1F52A059FBE808179515FDA48ECA714F0947FE9A98F02D66FB0D80952411CDFCEAEF6ABA16D92B8F1B82DB151D7DCD7FB7781EC55F4A86C86011FBB9C5570EE76897E7803036E2FE3CDC2D5EA7A613897F3C69A6EA734E3811BFD15E90D7256A0C0C88CEB54EC6AAC151B435CD2A870E4A02087C2B847C75B00B44BB3CA6D4404C3052BD308B8D5F595277592D26F6D5A2193CD4D650BF931FEFB9DEEE61032B29EC0412F38E1CBE025B2891C59574C1450D9E3D8EF27940EF712143F06F38DDB86341A7FC781E0FA8971DAD13AA7E93F1858C70A71A40164211EA9F6A41AE90D19032C2EA52C23375CE3C4E59599ECD6855213AEA83F8DFC5CC70F58A62E4DCA17C09705C0C099B29056592986C03CF5D67074735F2BEA +pk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sk = 2A855572E7E2ADD2888022BDB585B61577A75A31AA8ACEDE59ACB27EEB2936AE99780D53D82E16E1 +smlen = 3307 +sm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count = 71 +seed = 270BEDAA7BCD43990FD8B4F44FFB63A3AE8E991BB2BF84DA7BC2CCD1A079C579AEBE2082ACBAB7FF286DE795F31973B4 +mlen = 2376 +msg = 326A4FE723BE9363ACFC000705A10B6CD8A7B25E99A34B4A354CBD6F50550BED30F6C4208490B4194AB79B24B093FBE132C299DF924F2FFCC2CDC6C2C9019EEDF4B72D7F0817825BD787135927102E1DA041E9A78B501B42DCE777A79ACE604E57DF11775D7B87E75E5B00ADAC90D1ADD78CC5AD348C7472EEC6E6E06F737E77115A9509A6AE6570F738DC2F21314A7CCB9D44ADD6E1434CDFE3614BC73A6B468F6691B60F4F2DB103289A90C4FB2BF5AAF87826D2BEB0880FA64E07E9BD30D4EDA00D6BDA01D1EB22BCF14EE797A859C9A0D9034E8C5316201AF91388C47E1DDF061C9F45E067A5F60B355C98F8734559B8F1B82F47BD9CEE0224A1D67D40706333523C34F3582B6C8CB47BF7D0E4FBC7D7CF3DBF21077E664FD59998338F4DD4A423C3A145EE1E994AACC1A48F81A7E9FE106008DB93A6626B8C8505043AB864D93AE3972675E69C3825304086AA3419216CCAE7F7D5117739E99D8F4A0B658148DE33FDAAEB9967EF56677D2028C3B584C5CC1C096F4DA16799408B2EE2FC3482AD2F49293CF4097A78492470099BDB90BCB4FE3B245AC8B3C53E05D7609E34770ADCC147033A8FADE81359FF63C3FB90C5A498C98B7A0E5EE9CF4D287759ACDA4BFA3965CA85E1D1C1019E7FE6D82E5E66A717F94890277E6DB1EAA6F3291FE1BCD7D437094749FF5574B8728E0DC21A143A14E382937EFB7EC1B0FB3F6F9C0F547F470E3B436DFC7986F923BEAA89583D8978C433E0CB0C4E98516AF1AC797C778662455A57FEF45BA2C7865C1DF5C502EDB01C8CC729468091BB96BE9DA9C298528187867EEE9A06141DAA15F60CF719DE2BD15010550B92A41F12D8F38B54692589AFF51A9D5E6047A0D9B707369992251DF31341A45B01B05FFED8ADEE5810824F903EA59F14FD500AEDAE797F8BAEB470C0B14C4EDA5C687E4848A85B30A8E8F59C45D4C9F0C65FCCB15F4D4209A55722C29B6CB09AECB4E53FA3AA602C56EE3BA6900CC12889E7B87D5EF283AF1586764519A30CF60833C82F0ED15E39A8BCAD5C6AEE9999E63D399C5CEA10AE1F53B04858EF7896AA29FA541451FDB685734C39470250545193CAF26C9891F7F965904AE10E8566BFF9B2F465BBE13D6EA4A79586E68844B9FA68B2F992565C8B0EF5FFDEB5878CC12A0571CA3AEA50ADD29DD06E13741A1AB215BF487BE7735D1634332F47E037253054A21E0AD8D8F011334CB5951F833D4D344D632BCAB7C373CB7DAFE8F3D79E7E13BDB1C6CFFA474A9FBB46F5736D55F3466534596EBD22B29107A8FA50C1D0E62F0533E343FEE038FC0C3040A6DF2D318BBC8420019B1B148D6D1DD2FE428C2FD617CA73F224EF9AF9BF6F83CF1006616235471B69DD4EAF9F32529EF3E1DFE6765E61E246B519C702351C9CD66C57065EC78993D793B082E3685EB06F2530B07862277D339A52813C99EBE16C06C4C8F547D9705850E770982E8FA0275A52F430FF2422A115ECE46A9202CAA0195789532B1444F1507AAB2E4303464E499989F21C7D881328F18DBC77D4B9B467CAE244A93053C0321DFBF815DA28B6EBF483EAFBE634E9947BB5383FEE3A31BC03A63FCDDA5E3E46D5D3184718C348A83975728714351DF43BAF91787CACA346DBB819602F18A4C4FE90C4CE307984BCDED89CD2E4AEB66318C10D95AFA5BE53393FEB981C21BB1411BB9C58818BCC141223D66ED5F35F90C05FD4848617220DD72F5E892292CE20AA9A0F9AD54022CBE94D2C86DAF3FC66949AC35D8E122B02E2D155E73F4CE24D7E85A5C301DCC173CA8EC090AF9DC7F443C983280DDA27ED4B9BC71F86E84F7AEE39E6A7E9BF5E43920AAC858F0F49A06216D9D3984CD2E3575C0FA6CE8A5E28B0F481CCBAAB450FABCE8A1084EF458DBE257CF09D8116136C2CF1EDFA6CCE31AED0F1F8278C1C8D9C79846886D48E3FD311C015BF2373F7CAA71AA26B011D0DF5A843AB53D7E7F0466CCF49C5D4DE872CA87B8895101EE0147A3DBD391BEED75FC16F65814D56CB29273A5F4E5400FCABF85040505C31D001DF0023726E9C1F7C29A37039FDDA73B9B99ACEC3A029F7C0DD61ADE7D5E835E1CD605AA8E583BF8DC99285E86CF91F4B4827A0E8956EFDE2B495A86F85E78B954341CF3AFEBE8DB71C26B9B1BA27B47284AA84E55B1C2AFEE733AC596A10186D9AB504F33E34A06CA931D7633462B04B9B2B0D4751B0343503BCB2A1893D944FBDB4BE63DE167348A1588E6551FD9CF2101B0B4CB61422655FBEB50D64CB9E87A23007A39821EC3ABA391485347624EFC3DFDA4A133C537D7CD8C3A549BB6BEF9A52D2EDF0A8892C6FC3EEC3EFC3C18741C85BF24CD3B36CA04EE77F654ED5595A0E4B9316CCFE4D2AA6B4A66B06F309337E363C9E39829C8838729F19811093DFBE962246473B7A19FAEDFDB0193F63EB85EF308CD3BE5831F35CED36D9448D0EA8306044F78946079210CF89FF78104BCB2964CE2AF9954D53885D7914E4FFA4AC7E9B3D103922FD1AD68C0A4592F885C5FEE51D52214E17035E8681086203B79B5EB176679EB3263B44EA7287262DD84BB98F6639B9657AC04E397D69C634A0C1181ECA485E467D62631AD2D9AFD5AC5B86ED4005FDBB7404B65BBB826F1A2334A481B9CD46E0CE9C414A162E84368089F24149D7D05EA6ADF40B25A708357AAA5A28801FF100F69252810188CFC6087507BB5BDE1CD43BF72B1B3207CE4F7E65A18E5276613D4BEDDAF21AF7B964FF69965C47CB03846F7CEDDD2C5133080FC632A4F0B3495B2D2751727CF7681F28675552DF2A0994E425A922BBFCF84189B8C9F43058D691DB3166C596F6BC480EFDE06BDAE7B9C2985A1F2F6441520620E193D7B94AB46DBA2A1ADE44E2B006734E6770F34B0E2122DD7F4EAF045164DEA8C2FECE7758630384C00A6B528A6ECF07045B2DC0281C936A540904733149BC65B0F57ACD9A5E41C2ADF83FD6A760B169BEEBF04644DB1314270ADF86D01CC2CD580C609E78BBCD9D2694A89F9CB6DD36B9AA2AA5581FF561B5417BE2B52F3EF2581E461CB0690782F33862C52590643BECE0A6141DC805D8F56C4F64C1BBC49A3ECF1E8827926796E5F9335DF47DA6D3E4C14795B547116FD1F3351FC55C28B543183FEAD8DF7DA4DFBCC38E224901FF7BD83B16631064CAC4A37FA632F53F004374AA19861FDCA515AF91E66186EF804366D5A1B3B4FAAA60A0C4B36B972A9579548B4CDACE7EB85F1F68A4E4255FD994C1786975E7F6F0BA87D0295DE72876BCE37146A09EDEBC0164B9C4911CE41EF4D48130A27651BD0DC315FD622CB6D03759D35756806332658B5B33E768860C1946569AA45130486AD49B +pk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sk = 7967E9DE70A7F95E69371F812C2FBF932CEC07AB4C235AE9E8A6799F3F537D36AEB7575AAA4955E4 +smlen = 3340 +sm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count = 72 +seed = F151196F55A9ED88F1663AF6BD24B2CB9DCAF3C9B313CD8F0A27639D3CDAE72EA90D60ED5C7C6AB697A06185E5A2E215 +mlen = 2409 +msg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pk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sk = 5ABA340A8E541568FBEF49E77F94CFB4B3A5E9CF14C6755CE6412CF86CF62898695E0B1EB0DCB18C +smlen = 3373 +sm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count = 73 +seed = C7ECD1EC1A3D83F5116C0AA4345FB3ADB4D9F81BD79896BC4932EE2F9D2D1F179BAF7A002D88F4F69071A7931E7F7FAE +mlen = 2442 +msg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pk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sk = DF4853F482CC1D0B3A2D71E9EACA064E57C5D100DF79BD004BA81B43EACEC4010E5210879DD20A29 +smlen = 3406 +sm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count = 74 +seed = 5DE03CAB3CBD81B8805A17E0FFC2105C3BCDC8D782EAAB161A15AAA543FED59353C1FBE03E7F36B955FC51C9B30F0C93 +mlen = 2475 +msg = 5F7522CE6BD0CE6321C27B9EAA6F572616201F283C5EC171D0BA47662C2320897805E1551ED438F3FCBDAF9DE6F3A19DC16FE9C167A65B6E52BCF512C919561B548496A4A80AF7CE25458A62EAE92EBF677872482D8647C30C12BB1F080C6B9A56560D64FAB73DB17487BBB007C66661EA9DDA14601AB27A100EF4CF4B7447E51418651C03211F8FB884BE91F3980FE13E00EA4ECFE6D54882059A436C90BCAD80E4101CC6C0754417545F2D167629F80A3C5FFE45C00AB2BAF0494D6C065872B03A987A5EE818B3EF11E47FE1747F49E2DB6A14410F0B1F9610A2D6114395EF6EBB231FDF71D595CC1171DB9C89D6CF202E42D4FB968AB8105FDDB2AACB15FAB8014B534CF468D77ECDE2072623B7002620B7AC3E78B62AD673FEEF9F8E97E91ACDAB171FD415B2D15605DDE00D074A770E36F2218F7130F13E91FA4C88DEEA7E854BCAA01B8458D40625A33E982F0955B83080A926EC240E31F0D9BF477EE3A016E146A3909683410D4D09ECDF32EAEF580402F0D416DFC082CF1362E8B79158BD57739AEE56DC41A549E534C7CCF3620C7D7D95B92994A747D5EFB8EC43CFA8189BAA9B75FD54694E512FCA388B71A5B9EA591AE9CFA34183DE59D284AB16B2EFFA4B26A24A0E615B38B83088A9827EEB5C29B419BC061B033E0E3FC809AFDD3DE948412677E0BB5136854532639F3CCB176D54EA1961B5C527EF66F4B3286A583E86208AEEB8ED07D9E6BF1BEB33995F76CA480039A6130775895F19E3CD4873ABE3BF2FA9DE81BF0CB04575DD6AE282720B152CF0EC6A4A04016DB0F3543D8272AE56B1152B02EAF22131420CB194021F97060D5CE52EB21B57CC93964DD21344786E3888617152D2ABD829799CE47D20158AA93F7DA85CA6146C5BB94B512DA053C35BFA8840CA43F6509A1477603FD50F5E4F9A7CF8D2369156989AD638D35D345BDC859C52688211BF7EF3F4AD4944657289406BF01DCBB49D560A11840EF35DBC0C7F9C96DBEA76300CF61997A87D70F5FF8C51AECA2CF0680B6FE8C4025E1E25B62103D248CDEE335F4FCD67597103362003206C507970EA6D78CFF4B68B44244019152DBF812675CF667E5E13C8596EB6FEA3903BFB25ED08F902722A37F8E460E37A03A2D6ADBDF79DA20052DE658390484B83BBAB28D039A303D7376BF555181680B7966C798A1C6CB215257E37739DE7B9706CD1CF3AB031F68C82D6ECFA507C104115040744D74A40C49245215639D0CF4A5A7A10098E9CE3564AC3C44F0683AE9D3094784D354DB1AF439BDDF63D5CCA668D8180264EFECEEAC0BE1B8E1C6418E45F9ED6C779ECF169143B034CD9F332989D445C83A8786398C507B9171B4D95728575539CBB29C5B804268D88F2B39AF1F9572B8DAA9FEEEF69C4A77DC64BF2DBB5E57F8B33AB151769B2D00010D67A2D6F188D6D5B35E5E1873FE2B327E42AFB8885A842D26C246F7C18E6BCDD6FA49B300C65A3822121E95004928104017CBCE2AB95ACADB9802BF4BB049B8E96468353D649654C6F69D774380A5A387D6414DC3000540BAB6ECCBAA088C1068CCEF20036E5C8342FD512F55E6794BF85FE15721D99A1BFEEDC218617A940C8C25D4DFAFEC677D2A719B2CDDCD302294B7FA41AEAB5606F859CC0D638AC94B99AC3EA48C687D278EEBEB396DC5BF2D2E89E880F76B533FA54EFD30D8EE38B34DC5F8AE62C637E9A7E85D99E011F62D261AB4D3DCEB98A8972D3482CF817EFF476B873AC56963BD60183B359713385BA82F6E24BE2D6CFEA6DBB4AD2E1B5B790EE54D23F64E740502E887629B346FC8FCCC3338D0F2921131B84590B32C7CB82CBA8BB3B81EF7BC5CB12F0AA0B3C6A5B2878DC4F868057C68460C71D40D4263AC5C8B8317D2D0B63403C7549439A9EF227268372EC3A54CF8EE97714BC4B55007F92B1A32238659EC1EE27D6F2987AB06FEE84C3AFDFA73240963F076A955BF3C19410E1DA6A19B3EA3AE2DD8766082D3295D35436597783DAFDADB905465D05FC21FA8AC2737A52FA8AAEFBD2ED83F12545C1FA3198FF225D37070694C9392738E89467EDB2DA3CD1734CE398E32BCB1FEA2E4FE1260A2D9F9EDC3607A8AC8A51D5DA36E99B31903025E0CB157FD2FF5B51C9191CC16A9CCB870B4060CFB0FD900AEF62738A58C5726F5164417F084EF14FC0953E3C6036B818C21CA3476B8CC5F8EBAACE257A0315031A03E64E7F749B9DF99BB56CEEBBAA4333BC7270EDEE90FA2715BDDC38D44898A41998B2374B6EE3B8524D3A385C03868EE9479355092C4D20EC32DEB51497F4FF34AE7E7EA4828C288F46E5148DE28A8C660EE132E5B5489833DC66205EC968B60DAB96C2A4452A7019BBA9FE3D19D5829129E2A9C75C39416AC8695145F2B62EB9468198CBD48D7670DDC6AF2F99F77E7ACD01A34EA8E0E974206FBC22656867D09807B980563E06A559B0C3A7E6F43CF8DB75B18C0F90C12FF3BD43ABCE7DF75D17E631C08C974322010648FE2E2BC940E6510FB8835DF8384EFF3FE6A264687256C6BC0A5F9D2DDF208171DB55C4446B03CF27796BC77E3C68D8F1252BE21877D7C53747404420302CA5AE1AB57E43B158BE8B707360A2F59D6A473F98B816FDE2CCEDD92385202C419278E8B840DBA4C05E9BB65F68AE2A635A29110329E8C0C02F6FB5EEE41ED225051EE975F92DA52F93EB1FD7C0A098F6D1421701537298651313514AD31CB333E9C5DA719BBA95E73878BA41F9E2512862A80602AA2DE1E1D086576531330CC7BB8F0CEC38050B3CFAE5C8B1D6CB849A579F2294F8CE80FDE5405BFA3E6ECB01D5117203A4523591AC4030397DE9FF81D5CC91AF3002590F5854E852B88667638B2D052F2A7852425C8EC026E48D9EF5E73D1993D7F3FD7F704760562C36D2278C9CE131EC6AA444D7B2EACA3EE888D9B2AE122688DCB35455E7DE31562BA618F1183308B30D07A5C34020546218101AD42AC5054D4703587FF60E860A60375FAB12734912058D5B0B06430FABBFE0C0B43C22814F56DAE9E2713325A31C682C13F008B9A3D4FFA8A454F0F64A9213FF2D557A4CBC64EC6E4ECA0A976CD9F27497BA544DBAA3E2ECA0F54C2634C719B9C3A2CE37BCC8158A880BAA72780F8B1D3494F589E2AF3044B4FDD86F4DB2DF0843EBD9F3518870F55488F41E234CE94E907A69D28BD83347702750DB1AE2EB1454CDCA37A8B5FC90091F548BABF489E57C8919646E977274FC972088A522FFF9F9306D2F0ED6C01FF92CAE8440D7F3526B8C186D5B96942CB08032886051DA2A9FE77E38BEB18F4FB25F1152EDF9D61347A00A844929976A327BE46FFD3E2EE0B6AB1014294EC5D40CF7071C36B11127FF90720596C1B3065E7DE8010AEA469BB4F4AC5A6EFD20591CEFB7B94B2006D85CA475FEE556F24CC41237C631B75EB594F8342DEB4F976D73AA46563C1AA6D0B605A16152315626BA08807DAA6025CF62B29176F3A85E4BCA483EFFEA7E5939 +pk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sk = 95DA16B844BAF559C2CD6E68B237614BB9927D90811106347B5849FEE2F48640953252009D02F941 +smlen = 3439 +sm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count = 75 +seed = 63742CEFAE9868C3C0B31DDE0F9D378FD5D71BE7CC3F0B6ECD393DB55FB043CF00264852C45D1836CC12B9C872A20251 +mlen = 2508 +msg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pk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sk = F258FF1178CC42A3CEBE238C8418B4974812A05F43B8FA95639CC46BC0738BC568905D4B390BCEB2 +smlen = 3472 +sm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count = 76 +seed = B887F07DB5358C3FDC2402947BBC87ABD064B02A859FE8DB37B5BCBB916020443DABA5534A0778FD0B1C05EF3ABE6269 +mlen = 2541 +msg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pk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sk = 5EFBBBE99CF5C2B6830FB8E990250BE308E662200526889EA973C8D33823EC19ECE261252F9DFD35 +smlen = 3505 +sm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count = 77 +seed = D08A139CC7147ECAF4B1D1E434EB2EFA2B2607B0033D8BA989133E496DC9F3654944C7AF91CBB79866443E8C4E8217ED +mlen = 2574 +msg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pk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sk = 47A048D8799784F6EC385EB984E70C62CE7C8A107232871B69B99F7BF4C3DBB5F17F8A4D19EC24D3 +smlen = 3538 +sm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count = 78 +seed = A315BCF0E6835892ADFA07C034BFCD39F80B62925A95490B20170BD29378E11559C7F1CD296377FF1E01284EC727FFCD +mlen = 2607 +msg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pk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sk = 1D9E243A35118BC7C50A50746E1CF19C9FC310C7D54181FB95F44753EAB1B94A4A0F0F06FCDFB382 +smlen = 3571 +sm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count = 79 +seed = 8B47E0EBE786914C9A52D547106CEB4A3D3DE938B3244E02E5F9660954C4C95A23F2476FCCB487673AAD0513820905DF +mlen = 2640 +msg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pk = 95DEF1D619AAF1980327C15EB98F108A6327B1F3193EAC06F3B5B80F3C532E7CEF56A4E120E900C8D76AA6531BFA5DB7E4EC657B4AA7F4F59D22C08C2F4578F9C9717169A931BC39C0E46B6D1306C78283B646D24AF06F0B5EE4A3BC31EBDF49EC8156C6FEF5F7D980E5DA50CEA7DE1D5E5B7D333BC46212AE060D97DAB707B1B4E2FCF51000CDF2033233E39951E395F20113BEA9CAA485518EE03A65D8CACFCF875A4E3C4E3D9AFC83A29FBE7F0E6DF5961027C74EA9A7A6DA0C22E6FDF6C62E13BEBAB4E057F929A81A7B119A808745D2C99014485FF3387D0A4DF1C49349D28C0D5E06687D7F1E22A825686F7193788E24F8FE6505BA71C1D6EAA2B2B755040D93101AC892F4BDDD3113A68C05F72BDCAD2FA52C637DA9AE95005C8FB5909C151E73030753F4C83432194C3C0FBED93390455CE089F6DA05B766095744CC0E58506CF1A71FDA31F8A9612B3373EC5CD1D608AFB879F29602044634BC3737E3EFB70CE343416A6D6AA9E19733A9D44ECAE8EE2CB830DCD3B875ECCC25BA8DEE44AE35ABACE926B024FAD74457025914A020463C963B91CD7F63BFAF13736300DD5DE8CDFB323C22956D0C5E59459FE7E10CFAE346DE33A6583C384639288EF587D499DF0C18FEE84A8475DE34EC510681440A037FE18CD509E412F9BBEEB74941808632CC12EEAD3F3B6A910AC61F6639BCE7040950CDC7FC0995F1F31BB03FDFBB5E3654D1EA209808470B1B46CD05CD9EDD24287FF4F926056651DF67F304B2E7AB738C9AC1BED77FF82D3753F70A38B1AC9BDF64E1214A5939A23CA590B7643151A04B5BAEF406DAF15174158D1846D5927C6F79CAEA9EC45A3856442734768BB53919F356AA3921C764FB07C3AA9E03A509B7E85D83C8B9B18CBA692DF3E2E6C972341FFF3DA1FB19435929D40CDB3B46BD52AD5B61CAB407D97EBF3B9240B95036DD4E0DE8263A40A934F0885954B4C29104E5DB9E380B59CC97AB98D86BB0850BB156384A25A640309796CF0ADF7C7C04CF49CBFEDA48B2D98B41213A3265DD21099969433D77228451071E52C1CE8A9DFE2884A24C210AC8149309E82C31406DDF3A2197E133A5A9A9883364A363CE95FE4A2A75ACC1B81A9AD8479CD565460D6B2E4A226C5C136FBFBD9E9E2FC9D7C6E039D207A69A281F4ECB84A66F9C661BE0D7D45AD9836BC061E95043547A52A2FE01EE20D42DFA3B1937EA9DCC36308716161F0EA2F7058FE36FF05FBF03E7691D21F8FD6F32DF14FDE3B668F8E0CA1F5A32C1D52DCCAD973BABBB761D8B831581C71CB5FB5C7D28E41A43B809A7E74FFADF696F566789FC6943BAFC88090B11EAB726E8CAD80E9C63A6C08F1547E983E831C5D6079F516A27E5ECA6C1E6519B8162D8519A353A92F71D2966C5B1EAB5A9AF224CCE221E3DA60598C87473583885B795721E639AF756623F575C5B12A267C31002A2CA94AAF5E191462BF8B71CE0E44E63CA7A1DE433FBFFC4A53D991A6D587176CF6EA1FBFB27CFEB946846440D6B9F4F43A2C5598FD0F6FB2D2B57DA887CE8C85EDEDD6CEB3BCAC2E2E4E8EC811357FD5CF662D2A7CDBFFF46238EF34767B0A434F234C69A8F119F979714E25786B1A0622754D202DB6CD33D6E46B83EE5653DB329D28EC2F1C4E3B9D987BAAB797678AD67F2AF5757B88F0C66BF38392E65D3C2136C3111DC5DB289C8F8BD2AB699A7671D934A77F9B7DD523A5CE732D82F8E10947902D87762512707E65AFA1ED90FB79DE7984647E017F00D880128D50B20E2FE28D3A7C8C6067D4D8472D5F3951597BB8FA1366B2B1823164A8FDB40D8F8D3013F1110682405C887EC760E717BEAD4C9DF8342881AA344A8826D787E962C0C00045FF96FBCA885463D320F6803D739E2D052AAD28A0FEDB2F53051BCC2FEA84C8D2C8353781D114A97EBE35379E3D6E5BEB411557C88E9A58AB83B9C53DA3B73B56C90132B390A14381F8A442EE77DB55BB525611BDC9B599CA3AB5914F62ABA4DA942316CD56974EAA4FEE8BA0EAF540D01D6FEE812B17E57BA1A4069BF8020C726D12C8DCA79A0DA393F9FA7BC5B2B003ECC6CCEFE85B60853EB5A3395BBCB83C468888B4B6584FED5A3F02BD2F4000468209ACD436E99769800D0D329F774AF5869665C017DE693CAD4581B6626EE5D62B150B2CE397CF1817D24AB89FA3A0EE0F6AA7590249956086F76CB7079B2A030BAF5FFADF14A5BB6A92E90F1C9910C4215C206DC7F62982D6744D0377CEC1A40575DEA9F622C99F83F71E3E3C1ACCAE772430A9A29DCD1B79A345E4DDDB2B3596F4F39D701A5834535947CCA9DE4C3B754377C5D28BCD4C7BC7DE08633E3DFBB6E1CC80B35B341A8F617C1C25538B6B789FCE6A5DC5A7D2F073EC38B098145AA23E3BF7C625FA9191344E7B5237C19E14DE89809AD963D60D8DA8CF4C57475B089AE5789A9C63F60571514E5159C481B5D1AEC1934ECAF4AD972318D1C580B522160B2527DEF750C83D8DE5EB061396773D0591FDDEAF8CA0C47854CE6446600E8D5B0CA06AC160828543895C7C56E2F16F824DC596A13D8E143B8012B46D13A72FEE8C91C58958A6CA25435CAF27632A31170EE772EC99FD140C09A56AEB50BE1EBC03D31C20EC91E26EBA440E58EBCCCB1B3EFBE76C4534AD18BD4879990FF81145C186DB96B06CC9E77BCB46C1D9DD6E3A43F8A9A64F02CCFADAB65B63E0BB9B833B790D009B8F023F819E4F794D3830F7F40A44428A13E6983EEF63722A4503F808523B518B45A5E46EB04FD3F51BFA58B881950089726D23D7E890AC4FAFBC7F4C59D98A5C3269F69951C37360A3A3089F0178B4C0B56C299DC5AD7B8112DF5DE94029E180ECD7931206B22BCC55C34782BB3993906289EC032F997D348B3ADDA2D4329B3D4C3F8C21CE67CA2DBB6CE3EBEE55544A9752E289817A93D5F348714849E5747FB04E49008EC535D110618F46788D4AEF02CF7801BDD75255D7A79A4E5826A9065A7FF38DD4871E88D8BB1F6A7E876B299BA5AE912A50EB97D9D993E12032CB466B3800DF1482650D7F18EEF289CC083F84F7F11C222640B257B44CB25F890FF2473A300900513A819D65624891D74FE55FD83FE9D18E5908644F7E440DEEB9F5606C9E7B510627847E0EC4D58DD95F0EF1C3C45D3F8FCEADD1D5FE32690FBD086DEE88707272AEFE8515ED2BB61EBE83C74C381DAD907CB7D32D2275651D7C53F3B8CB2403CE95620054E0567D83725D38B46B5CB6B3FBE4C3DBCA56624E66B0503E803F1340BE310461E3E9CB5B3283A7BF71868FF9125330082CF90C25CC51BEB38403D19ACCF41A519506B7322C988FD4D6FE793CB6FD3EE92C380F05C86D29B0645A30A11E84A940FB6917492369EE3ED3485146FBCB6B2EC3FB1495290BC3087D611B05B8A6F5100C11A6E6AB4B46E3AFCD527A2B292DB5977C4B421181E5CEE1E966CDDEDC4089CC2CA046C090DC5EADDDA64E43EC363763C93194F31589FD1395C78C6EB1F410A81E104923917C881C0D36D660BFEE0A4D5E32EC6CC1CCF8088367EF243006A640BCC2FBD02A32F159E66A839F1EE27C02EB0D5C1C670CB610128D8880B0995AD6EFA9715EF05AF7F5C9C8095BB10885FA14D02B6EAEE3CFB457F1127400BAB8086A5A44C68086711FA3D45AEFE8FAE3A54C122589B7086803154973AF96554858256F0D484026E2614D94FDE2B24BA3DF78CE4593AAEFF395BDEEAB24D9539D93B0E08B0FBB1CF6C6A90C6AFF0FF275842568591218A1F0235F69371319F844AAEF9AC5C5A9B0462EE658FF4E18DB63F9296A320E19DE0CE0A45CE6B6E518F0270CBDF5C8F39CB842A8A762F7D5E90A0044D47C383A73BA9341219B089B09F13B751D7D0BE444BC86B3026C303BCC74473B7669822BC18124878CDC197C04F3C84C38AA1DCD686CF9EFC05FAEEDF2B7EC4FFCD7EA50AFFED03A70A727B78958F4ABE72626AE938E0CAFC008A6295469930C758A7D9E4CC2718519E80A1A171573CE73BB1BCC96DB20814A51D84349DD35444D11E547EEA51F47323E345E56AB551FEC8192158314078E97DB7DCBB7F6C10290081BF15E0F0F08D572E514F2D2D909EB31BECB63C189D2AFE5685DAADECB2103D12B13222BAAB3219C3B99E29AE5405E6CCA0BD9A580EFCCF48DE5F3B64D359AB19C6A9EBD561A256D76349D1FBA48FDCC3160E062A0326177466F8854E703C2952DEC412422C9EBEB7095DCA850C6D91319E4F2F7876D9AFDCADBD20FBA2C8B43E4B6253F98A55211D0AA0A8646C2A7F3D02B21E96A648DA83A074D6FBBAF246373CEC4810BF077999701E43E994FAF46271AA2C4EE99BA8A3229F8A2C7F72231002019C0568902FB131969FDCDF497614E3726D3A7D8F41F2729FD261042626D8F7D99CB4B34326BA659F0A40F0AD2BACF6FD0B404EA646440CCA76B6EFB3C42F7B7AACC2E896B549D30DDABF9DF4F35CCF2A0A91797F9B4E5AF99B3A8BD2309C7ABA734B6DBC4B2C2BD0365A2FA7BC828DBF80352061F582C91B1D6E90DA54B27AD354B94AD686A9C46788D059F18ACFE01DB3B3501A0232D06CA38711F64BF5586BBF8CFD5635DCB2D1651CC6E57F17B861610EBA6E60CC136FC26E299D631CD2B48C20523F39DA897FE33D11AA605A737DF58FA23421D00466CA489B3829CE7293E8A5E4EA598EAC6C230C8DF7B716402A10330C4E8C85C9438E1E8FB8643300A9544E3B78B17FE7CE72ED1AD9439A9C3F2F510252612CC35B2858945ABF1989AF0F4A3D933934C8E71609A28D269D4C49DACB987EABF284C6693B63BE429C8BEC81FD0CEC584ECCA7019FA6510A01B2CAF5E95FE52DB9D5DCFB5159C6F3233C88F786C52012E54D6DDB871596217D7B2686BC12F7148F17E9DBED736985922BF63087C11D80FBC3DFC72C6F1532A390E95E7555A1BFCCDD26C07DCF18BC5680208939F1D10ADE4B71983E6F873B2A97511773DD307886A8E7530B610D25033AC447D45718DBE4E09ABBCE816E9C68AE51882F1DFCAD350C4D52AD19D5D587A7D11AF739581A124825CC2B7F7C326607525D1D7ACFFA8031BB3D2077EFCC6CD2060838D87EC11CF9A51CB50B6EBFBD9BCE827880B5C787E87BCEF61EACBC8AFEF9050FD4D0CACA797532F955D2F0C28B3BAEDC76DF54663B2850C18F5EA1C7467DE9C556DE4350A00A12CAFBF9785B84C0BFC724DFFCCBC53205D5BB468BC09BF50B0B73A08D56FA89019BCA04561CC18DB18C2088AA3A30FC7CED44B77BD980F9CBEF76151C5C01EBB7D9301AB573041014DAF180E98BCBEB117F12CDBD3CA0FD3352BA6BEB73AE91EFE95DAB38A9D49609854C87D2F3433E7F3ABAFA2FFED076923522E17ACB2B98AC61302761724C7DC0465F519B49371E99C6248376A5E810021B5F5333A2FF60C5071F53B7DB237FD3D41874A6551182CA6A62320DADB1D22B10AFADC5030A771C887FEE6A1447B2B122981BDA96DF071C6BD694EA7065FFB15649DD072C7A2B716A0FB0451A84E76B65FCFEF0681E64C0DA3EBF62C4706B336922DE914FE5A92432216EC6952B4695F2A51C498729F81D29F25ED6ACCB52D823A48C30B6BBCD0D83C33DA81D70335A85A3C833A698220011B5736643AC5898F075DBC7BFDC07320E1EC2B68CA5B1DD81DB06CCFF900E6499A88AE8863BBC228E609E2926ACA9E920AEB29CE048BAC91C45A299662806BCE9F4C478EAA56734D05033024A02D8D8B67D98A19EC2316CAB31ED0F31E25E99808DD8DE42CC1F929FCED2B963DEAB0A622E2AC40D93270FB2A480042FFAC0306E15BDB41EC9DC704F89EF6E582BDD0A71BB7753CFD441BAF184D9B693418AD982F136C6123251D2A60CED057C1B01E20EEB1AAD76204C3D9C6587E80C4FC5661C5A08944A797923BF49AEA9D2148F06432B53AC308AA75926F42114FDBBF2833CCEC1483BFFCA85BB783495E3229EC3DE896B98B7E3B57595F903583E0311972612C6A23C3B22F75A7EEE82E2F411366E2BFBCC6D677E8E51C532D677097CA8A43383243167A3B17DAA0E1A4309761ACABC74ECA0401567CC1830460E590C7EDF5DFE66B399C265D7D8B9DD6BE4D76C74B8A874896EA978864F355C6BB3EE178A71B608CF24D8C0765C3C60F3B7AD896FA59B1756CDF774C3B37E94E3FF37EF60A60ABA86FD8D46736FBAACBE72D70DA80DE308A8779B56ACB30D4985FEFE46C41421351CEDB2BDFB2F9EBEDD52BD908C4BE4695B8BE070FA6483404DA733C7EF60E14603853C2EBE6337A34E10EABE5A678D91852F8226B10E69CDC0A26BA999EEAA46E387CCD446706F7ACBF314CFDB34326D6DA04F90F882869C7070D0FE5AA8AF1F4B4875CE80881157F0C575CCAD0BF88ED59C5FDFC33554C6F31C72D078D8B874AE3E3DF10ADACE05408804660089A64D09613F3B32C1AEBB133F6FF48DDBDCC1C6EB857D6E23FCC93369CB15C359D8310DAA2A3F81C0F468A2753CCD5F9AFC11CDF797FD9E3DF6FCA2F385568FAC8770E162F299D2A2AFB0D0724E25C8DBC6DCE7B5AF4CF91E5DDA2B80C260659A4C4710C84C869DBB36CE551019E65A8745E303EC22A9DF1FDFA279EE61BFFAFBF767B82987D73005A87B79605BB0275BCADCE4799AF406CCCE825298E93D7502687E556C7400FF92079252C6B43D138E97748099F99EA9BD70E3D34C71DC5A583A0A357CA1208C75DAE8A895468309DE1027B63AEB926982116C97AE7B17CBDB0B242CDC378A83393EAA23AA808CA5CAB9435AD2B3BD6F81C0A277783A134D4B3319D0367FC16BBB75862EBAADCDDDE441BF27C6B2011D051D094773A962399D47F0B76CCD55BF95D2EB14DDE28802936D2CA6B84C85675D03EA7734866AD9D39B85854722AFE06C88F54BD19DB7033E55F3F5DB20CB577C9D8DC88D9C61E502ADCDDC66BF89A5B47B56351F193CDDD073E30DF56FD3BBC3365FDB4A6637D4ADA474E4990C6707B3E91DE7BCCB0BC4E6CCEE6F9933EBB730E3FA155294102A7FDEFEEC04CFD8518C9628A5E606F0E8D1BECD9BF6E76BE950A4A377C506BAF0A571CC0D7D2E8E82344693BDBC5B562AA0E86349070A6EE26D7629EFF51BA5BDF082C21FA688FCE466372E065AF5276A57D7058693E296C8DB9E9AC92E133CCBA59EE1859FFF93824815EB275068F04C9BBF54FAFF27D2C55FC78A34C03230DFE6E7DCD87119F7702BE3C4F62AAF2850771FF931C00F196CCF1B5F2AD176F8BF2C856D15B73307B6C5056ED68E59F71C4DAF82DD733BB7ECFF6BF084986327D6DCE239488459C367823E0946BC3A219D6C2AC3D994B262AD84D009DFDF8A388D14D1068D82EB36FCD43227BA6E9E39F06C682B10A4AE2AD1DBD56281D444409265BD671BEDF985F294EC6AFE0D4D5B6B87024B3DBD521CA2CB87E5CB86F786CBC069FDDFB56DCD0B24D827F102DA8552BA3F8C0E160E5CB3808400F9CEE1E584D33D71A238AE403F5B46A19305803B26293A9F8613645B481A2C49CEA8F1905F2C25C41A908118D8C9D12254470928FEE059F920A33099FB6F9B5EDA180866D2EF800A6F983AB2C609D4679360F4C95882C41AF6718C0B677FDF9A1548617E9C4984A61CA23C43510C1AEE4E3F146CF63D307AB937617BA6CCD17A566733133EF5F16A2A6BFE26A55547527D42031890F0EBC8C040AAB2D74D0CAD3B3D941CD40FEAE1EC56174D08FD7A799843D38477F5BD0E98B4CB297D74B3E254CCB21D1688B18F3DFFF7B82308E6BD0D920DD9CE5336735D9DD0883DD4C98CDE6C3A223495ACD4BDDB6DAA7AF0DFE2E2CF51F878815A7890BD3993E03E76EEB4DC0F247047B060CCD188D9D125166874AC542D97EA083193264C9BF595E3F7F366E4DA471C7671 +sk = 0A46FDA6BA71125F3415E8BB6C2D8C00601107FA563E7F6386486A88F87701FBC729A41DB528D9BC +smlen = 3604 +sm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count = 80 +seed = 07CD8F8AB7CD12EA7CC94103B8623D6F0FEA2BAFD2325BF6089DF5351BDBB9A94525C3C6B72D3820F2E4D5F9E7C849F8 +mlen = 2673 +msg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pk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sk = 5229DFE11090EFFBE94EE161054CD5FF58B31E23F567B282DB42EB1FE42E44AA3C7CA4AAE69ABD4B +smlen = 3637 +sm = 07C1EABDD48A469B4FAB939A1A2C2279554FC089B3F155714EFD174CA7B6610F69A032D91C98B7590205B8FC62E4EE04BC321F13F1DF49F6F4591A86BC3B1EA29D0A971D7F51577D21098F781374B8BEABD2A407FBF49614DE4D5B8E6E595D6DD7046C5542600DE17E99558DBB7ECD27A78FEEA8126B8063CB4EF7C28E81284C19533A50FBC82D21895F49ED4B737533BF1D7C1A26B583525C4E1D90710CDFD25FFF9D01820E31B69158A603426EE90E93604A79CDC52BFA57FC7C2AB2D3E760CEA50BCD3CF1C883027FF9445A44B5B3B4678CECEABA819196982C8281380BD931AF81D988592FC73B3BEC83AA2C4C83E268E5D346D159284CACD4F3C2F2C0C7F5C25D5195A9F084B4C496949CA865BA29D6972F53E06031F686B89B4F9B3131889401EA95B77FB6A9A4E1352B58BDA5446307886DA15BCF0BD177ABFA3A6B31CFDCF77AEF9E5F28698EF7BF5F7E2DB41C6C190E66F3353A3F037417B7648152D0C4A9111A7A272373FE7478AFE20994BBB5CC9D03547558890437FC7C9E9748780FA3C1B87600D3513D9A83ECC6A39E0B8F03A3A41B94057E6A1FEB73937C5E4B9BBEC7AA59BABE89446F3894FDC791EC8AD93B3F4499BF08FB23E00F6114775C79A0D43F97728D0F34A22B9E92C741D362011ECE5559DA88A6BB8933E4B855B9AA1BCC2A51D137FC91FCD32DC8C6D0188308CC4BE9870550E34AF8E9AE691A5494EA9506A6FB0EAACFEB50C93251C58BD42D5B5ED472DB9E41B048F96D65DB425FC4466C44240D3BF033ED4E15C148F22B6D43254D0C948B176F0D3828833CE8CD17BD552F4F59513F91258C6A0C587D338796570856353793048111A4316717464E732D72484CD1736093DC04757670B5A830AF0EE19AB34B4A13B53C7248C84D3E44EEF252F606EEE8F0074B9C9A0E428ED27443E0A40ABD60AFB74212D5DA667B45A4E76578CAA504553EBE20CE158518C6EE6F3FAA95E02BD3C99B9464D00C84DE04727B403F2A919E28FD118A838BCBD4748F78E79E2708CEA9CFCED287070E30090A2B68E8321B5F1070CEBA5EA92BF19D59B3BC47AEAF42F0E6343217E0FD4E24D7F5A1A908EE3E325A828C99C9C513C41F0A784593090147E0D17042F4B5040FBDCB44154B3DFD1EB09BB43D90C1C7AE01B6AD0C80869453638D7C067DE13808A3070962D81B72DF2ABCAA8EEFA962BCCA142DCCC010C0CD99A0451B95EDB9D29AE6249978BF338F75CD8384FE425EC1BB9963B089DCC95A4D77893A4871194E536DEF7DEBBD8FEA97AC670469EC961139145BA9557207EDFD223D771962EC28BEE7B58090C9045E847E20999C73370A7B685A88FF8552EEE597BDEDB8A2E9AAFA792BFF719A3B794B2F8198EBD1556889C8C61EE6A51470AC9B274CB162AF44A26E2BA5EA7663C4C78B4B66B322ECACA8F2EBB6A610B51D7C4399F4A64A870C038797CAC80F709CA5C3C9FAFF7D797963E60983B584130C1B99328AADB2D261217CB95A535B8518A78A6D2F6CB8400C2AAA2DAF451391F7B8AB0277A3AF88E1CE6F1D3DBC386CBAFF15308F073D29838692E645F566D4B3DB4186C259BC84606855EA88938CEC4F7211BC9B461E39DFBB9E44CBC273E02D4314A037E0A26D60985EF5A35F069D8B51F86E9B6801CA067AB75565D73581EBBBBD98ECB5AF47509C8729D82EA0B35F0A376EBE6D90108CD61FBD0CEC966C17264F6A87864457F41162FF7210049E6CE2B5354F8F19161E0866D6BC3935815D9267C600DC529521FD092B126EC440D49B8E3A166587657B52AE9E2923644F72876EE94A61D2DB0EF4DAB33ABEC0C47A6A725D4CDABD06D4F6A30BD7C90DB3778C17B7D8CE82A5123B798D8B47C7F3E968C9E9F82A6EB3C2BDD8FC06D282F5CBF3050F6FF71E2EDF7A109F23AB47F427BD75163162C37722BF70A6BBEBEBE8FD9C39152AFEB78C37D718014F739F20BAAD1597B1F9C4E0B59FD82B834D83DAFFC935DE4A3272D7C2454508C07502943E90FDB56128D6E6009ED09CE80A9B60D51AA2E4E162F7F0C362F6886BBCABE29EF6C7F38B742000B9D152FF709082FAFE809C5DC9BCBC6F300B0A7840D0D36F39567D14D8227E7145F7CA670EFE917E0F18B0570DA3E05DDE56883FF12BC0C76C2A1E9FEFFBB728D991769B7D0B0D34853C76FC0655AE200501C28755F57934BB9F46A3C6AB1DD8E0161C698133F4F2D7CAF3392576B4BD2B6F8735D80BCF60656E132442BB7FCFDAE160A2DFE3F3FB8209B5C933201785A7E8206096B84A222A68E62501846273F6A9145820F87F450D12C64FF79A843E897C8394AD54AAF4F3B886FB00A6C37B2EFD0F6D4DD639C9989E7CA30E4F12EEF440946B61D7A28904E1D74009B6D1AEDF2FDA8B5991CB37795A8EE51BBDAAEA34A4C7040944761B9B4B4C12F455C536992A0852F7F07A9AEDA8E522591CB4831B0C79FA977AB6BC49C9730186855986035D2C6E5A6D93DA43E8825753721978AAEB433CE2F2A7D67C1FFEBFEA6F6059474D3022817A7329D9DD0E4A292302E4A57174B9C5346E4B6D75D65882CA7339A48C6E7AF776A8515014A20E4390F6B4F4A19990FA725F5A69B9C3BD4E8BBAEAE49979AC19600A3CEC6DE154985E236C3D0684269974BFC82301AC7196675F618182D7CF15EE5CE3B7ABEE0DEEA5C72F54CAFEF203D556B31327089A0C0DE94F74458CFECB481ADFE3CBB5DA422BD3626B00C4572B4C2BD7584ACD9129A76C616AAE51F944BECC4682AACAFB8E3BB1A42A6A8E5FE7BDEB43305A34A98308EF2D49EDE4F41361446A9AE4DFC1EE13D12821BE0B01E55B865B563633E5A19DFB6425CB60159C147B18A6419F5085C5D0882656ED533EEDF97674D0BABB6CF32F696DEC0F9921CB3DC9E6021FA198D554B1D83C42A0BF214FE4C0431547384F45AED9190CBCF98ED8278E8A03D551FA284C8A26218F0B0B58D99879DB98449CC99B6B399DDDAD9924E6A7EB20A0F1FDAD2F8138BDC7B445BC01503C509066B1603CDA76FE41727AB5E027DCB15032E8F66BFA84544D22C501AA6F62B02C0F8764387163CCADBF1ED7238E7F16C80E6C37AFEC2E10FFB95AB0A39784F9FCCD8AE263758ABE392727E9AD442A44738D77CB61A6B1540ADE751130489015AE5917C927232EED27BBF88481F3CA0C5ED2C31DFA943B2EAD4A8C80B4946E3C138A61BAF43A72C7A25E16874CBAE254D3F14C154F7C60CCF665B566799A01E0F769B60F73C17C840E0018C6FBC10EEDA3E35A77586B3A5936B363B2D5CB25C78A3E3AABBB84F1E64DF47F97AE1645650FE1751A724EA9BF80744D0F33DA6F313A3CC17D8F261585B62A75C167126D899219A26210DC55AB6DB2B94E6993849B4986F988EFB07478D6621CBF4B8ED772E61B0246A5582242FA20339B2D6CB89BA1B9210A318EB4697FD21EFCFD230DE9680514A442A13B29D8CB2627A6970BB97BF09C79C6ED7A27247662B25F39C8D675B0747F1A6D9EBBF7CFA7BC51A7EA3A7307EA4FA2A463BF53A645FE701FBF26628731CBC18636567AE633A49E59F6F049447803FA3D4F1F79F38026DE9B07D8610C9F01BEFB7054AA46E523E001C1EC3A4E7084DE0CCE596DC63D9C1F1DC03F35F9B1918E62ACB2640102E1D520E900969D53E83D2DBDDC80D1DC54BEE99531FAA5A8D2DBF8346C7ED123587353DD63823453DE350545C176446845BB3522A862F5D675419DA901CF7D2D1F7050ABFA3237D42753203BE251B0364379232D2D9D8642D52A60F6F4CB09EF29FA1E6069F97A1175F8447FE98A813CC182E33FFD8B8CAD93BF32A60F1A9E63A79A7F7FB9162783B89BB57F3E73155CED1D0084D5BA967F76C89C61C1A3E944F3B6F78D6CD3D1139A315C5276493481F3FFF9B6A6B40C920EEED9EFC74108C6BBA5A15DA736680A23DB5672C5A32ABDA24B49F2011F44FA8FF9C73609EC195025F0456D753C848DC6296920FC32DDE2174D37BFBCB86CF618AA0D486EE46C5E1EA14A3BAE4952AF5D4837F9B8122A19D1E59B909ACEBA6C849C8B452CD6CEF877A65FD83E6D0C6EE35886688F1D877612CB8E671D83216A1F76693D6A4D6A2EC13EB6CA2005328B3C91F51B352A707EF8180F320D6E1685C1EF4D87E3CB77FA549BC12727E59C11BDF8A9631CC272998253028CECEE8A2914182B90F586D80E7ECE370979BDE683F37123090012AB9243A4C145D6349C2791DC44E54956C5E9B59FAD017D3EA27D85B48A896671A0AC14A73B5AB9145D8BA6AEBF9EA25AC2E8E2C4D16C5009A83D0E84CEB80E95DF2CEC4CBEFC7F5B90A84D408E8C4855F9AA2987D9FC9D8A451F32B367BB1DE5271ED35EA153B5D400A6D8050EE82F519BD930245A96C9727FD24D8B94DC53D4B4F00D03172CD6B7F2BE163B6D16FD6247B01988A6EE6CE7BFEAFF78E983B8DDFBA4242730E52B57876E3719D1F9F6CBCC81620F848D23C31E3FFF7EBF2AFE5011E6466B1889E7EF6281FAF8B18A012CEB96796FCA9B28E78335DFCB85BBEAFAEBB0FA75EE2D0D391CA97E05F0FE43475135B13613206A0D88438F17EC8E604B007AFDCB9FA1378B7CB96675E0B19DC6FB02508E05A7FDAAF09297A3884AA051B6389A52F921F8FF31970FB082DF554226C2613B80CC1ADFF770024D6BF011C0F028A012597AE56F36EB6B3E864D79639810B8BA7258B18192B5CAA80DEA4B140D3C6F1D707ACD2256D676AE90980BA80E10B44109211ABA830EE96E1BBD248315C804D391A86AB7D4B3A4A37FED90D9867DA4B93FC32E79403E5D78AE99AF1CD2ACCE65D4F3384D9CEAB71B1E93B99704C64CAF17B999234361E378B9362D14BE3FD9E6C268013CB1FA2EA8361749D635C0429F796EB15A685E31DFE7A76AE870EBA120331AC830F8C486F6C0C4F07B658EBB9274A463E0EEA101481DD6B58835A303ACE802AE79EBEF51ADD98A67B7FF7968815ACF4504B9D360F7C0120A00ABA1FC558E6CBD8324EC35E0985294563A8D7ECCCCD9E3D1557A09885770836ECCC7AEE0F18B81E30F85D695440B5BCE29945CBF60FF402B281942D38EA33A4B03E9FCBBBEFAAC2C455E8A03FF3F35154132C538EA16F0605EFB788C3CA8435F6D595F776433585094ABC75BA581EC59AF701F66DD6091623E4676D167 + +count = 81 +seed = 3D598F7C498D8A1095C40945975380554BEF6142578638A7627E2C0A21C59C579F8E8CDA309348FC54C764C899FB93E9 +mlen = 2706 +msg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pk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sk = 18AA77795AA6D7ADE8B6CDCED81A1959A8329677F042283DC8CA71E13EB3ADEE09C23920DE3CDEEA +smlen = 3670 +sm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count = 82 +seed = 6CDB757AD36DF99E52F535C2680431D5FF36C812D8EA19399F666F2FDD66D3A842A7A5AE1038359AB618FA58A0A6E840 +mlen = 2739 +msg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pk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sk = 4B2D6EC32BE9C5D8FA11F3FC0008F4F26B945064D98362AD912F452692AC383DF44AA3D966472427 +smlen = 3703 +sm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count = 83 +seed = A97269579EB70D268C58D94FF744329B197F722A8A407B788510DDCACA34C8CD4C72FFC14B76300C86AEA1E4CFA66BA4 +mlen = 2772 +msg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pk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sk = 196B8144DFBFB47EC01E96A6B8443211D6C9C4AA7853A8131B5218349BD6D9535A71E4023D8423FE +smlen = 3736 +sm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count = 84 +seed = 483A81716F91A43ACA6764C4BD2A57C9156B762E9174EA49730A6BEB9CB19A0B3755E37BA47EC524BBE2FA25B9FEF687 +mlen = 2805 +msg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pk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sk = C171793029D0CBAF8D2661A823243AD50D67F2619533180F25B50C94B1310389FDEF331C21A5ADC5 +smlen = 3769 +sm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count = 85 +seed = 30F0E117513AAF27AB2516BCEADD1188B4BBDE76E57DFAF43CBF2D70723D941E8F875C5EBF02BD7D67AE81ABCC54440A +mlen = 2838 +msg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pk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sk = 615FA91F3D206B908649399F216950EC7B2420EB04AEC6ABFCB7B4528E8E33E676C36F3347F6DB3D +smlen = 3802 +sm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count = 86 +seed = 070FFB907EE8AB7152A9D380DEA2C4C4796780FCFD80906C5E489B917A45D5E7EDFE6F37C4420E5480E8BB599FE36451 +mlen = 2871 +msg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pk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sk = 626C19B8553B2D9E5A47A758615D80B15BE11FD016D3A1962D8DE58ED5CA2219CEA74C198C0D2036 +smlen = 3835 +sm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count = 87 +seed = EDBCC4F6AD0F30066947D678A368B960CCD164889D77730516B444ED2DF10B49C101902F5FA227377C3163A0045B34E4 +mlen = 2904 +msg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pk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sk = B0D4BA39ADB4E8712B3A3E6495ABA2F04A29E45C68671A960BC0D8D89900C97EB6C2F0A9E33ADD3D +smlen = 3868 +sm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count = 88 +seed = DEEE61A2FAC04E4D6B7A250124DFD91518D9B90A71FA02665E3088760BF69CB3CD7B6977F860A7026819D178623C9676 +mlen = 2937 +msg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pk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sk = E04328A783C10DACD96702D2E726BB11CE4ECC571564CE7CB10722D1C98C28420A8E86FA6A1625E1 +smlen = 3901 +sm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count = 89 +seed = DAB6C05E29342106CC34769BF419ADCC88010C05B57E673A503E63AE7A4EE55B72AB2CA86C4EF57FC8C02D2E0C8694A1 +mlen = 2970 +msg = 4D83349DD620DC2CC0E9ADA524B9BE9B195973A839A042F4342D69E6B38918507A9747FCDD8B751D7C75ABCE2B482B3313D4C74EA4E7A4A91F2E08A059536B651508307B7F4C3AFF5CF1579F90F32BA1E847778673E3956713C14661AFA2D11CCF61FD8F9BC914D4B6E6D09C52AFF7FEFAE325C180147153C9AE1924C9A2B8DE4900BFBBC6797558B000C5ADB9A8DC4CAFB458AD328F19A2C55D5434BBFA7BE5057E56511529709992BD6527E913B46ABE38DBFF90D4AB3C024A66FC0F8FB34AFB96E22535A0EA8F313A087AA65355D7D5989C486E103FD526A7A6D812C0E4D8C081BCCE4DCFBC64B68436739451BE0C4B67BFCA71BE955BA9F9A23C223C7D0FFB1B2196C9C9845B6AF341A363951E2008BDC4F3296DD0E1E3F480F2E4B0EC77A002ECCFDABCC58D24CB0BAA26EACE96DECAA0F6BF1CDE0175AFA65AD5C23C5E71B50DF778208EDBE426AA6E876C12440D7C4FCCB42D039A14509092784BAAD37D9B8EDF186CD4FCB3D9F8B0397E951777D602B8AF613060FDAB6B358302B3FD28437A06694F36CE12A035F09D677E48D077CEFD1676D8FE51541BC19E3A6D6A5D879C4F9EB4713B7C0F3A652F3A05D74DABFF79A302FDAF147531FDD57924F49E52B298219B03D6DF166B481F232FC85C7CF52838969CED2DCFC18DD8C95891C498FB49289D1A982922A0FC02C849AC3BB7FA92CF43A64464D5BD919F75ADA287FE657BF61DC07B3808C0FD0D71EA24DE5353268B2C17C989C29465BA49111CC479F51A8CC623CFB6FF68149E52C77A7D85B5ECCE66C05900AB9957BC7ED39E03649A103B5B6BFEEB168B7C1F30DCA84AEA509FEC2B215DD95558A2708839396552F517A8FDA28C3ED61F84E1B2E0DCDFA708DE50D44BFC65BD4E70260C437C8B5B7158EC7E2301D9C7AAA68E0ADEF89FDB601711AD2998379145B29CE3681B513DC3BA9B2EB668C1B53697833670466E21E767361C0A4362E5B8DDC38EE6A9C4DC5205EB808B93C72FFAFB635B4254E4F4496BACC753C8ED0BCAA88DB683CE77C8165E8DDDE665392CCCD57BC07573D83CB3AA10648281EFB08F92AACD8AB6F9B5D7FC66D29526BD57E421220FFE375B26C61A0DDBD9807022EB3B4B681A43E7719F5EC255C1E19AE6C542D6DEEF3B94B6960C18D0D7C8110B88F995826073B874042FAF97F1FF034B8257418CA269F5CA588223393B0179F9817E08E7212D0D410EA259EA66BC4A00E7FB1190A732BFDBF7ADEA0E4550BE90C3E37BF33BAF436955742A2632AEDE259235702EA2E079D99A22C9755ED34C1E3CCBE746E728A932B1852F692B103112B303033AD3CE1172AA066860DF570D21EBBA51FAB72D5AFC4AE8995F532AE384CCCC3C4A295AF76A803FE076CCC920A80D82A9B614760EC43208579EF5DEE164356D62EA33953E55195EEE9B2E2018E6FD9D19A9F49258702DBAF6EDBFD093919917B1B6734F012E2BEB4F758DD481FB8A8D7796E755C6647501E28862B9F5B16FFA1C5D80DCB07141806FC348881A5A8891BB632A4AE4292A102D71504D0FC12C79D15BCD0799D30C7B9E72625A7DF7DBC7ECF9EACC627CA9AE5D71E264F2F2A9D5DB8593F3A90F3915CE480ADF800C99FC2C8692F2B57B492BF9D84171F8C29AF8D5549F82D3730927096CA18FF0B0C0C0B8B800508C44D5749B92D7D48F7FBD5C86E408ECE0EAE639AF475073DF5CA2CD5083BC4FF8852DDF5C399946A6B21B0841D137F583E0DDA3A6046F082872B783ECA3E14B21A2AF61BB150847026F2371812B1A2BE72024226F4613DA860AC2FFC578DCB171DC27B896EEFE49F885F9BE4CC8766F37038E01CF20DBB661F507B2ECF2B023203A6259B0A018FC00B2CA9B3107B605F04388D5493AE7CC4BDD093CE761A92847C2A167739E0750B427B2ACEB3ABC5FF751A5F32D36B589787D4DA509C85EAD751353AB2C68A9C14B8B2C8166AEB6F27C7F101221C306AAC74AAB6B4E795525FE12038725D7AF3D2A6D60E1EA85F2B94EA24F1B72FED9DDAD4C8E5DA484E80A2150DE22E6ADEF41153D7B4331E8F011A3CD48DAB02876B067312D0DC736E465F99AC3C9C56321507E79ACCF652E3857C749AD92DAD15350A6B4B67229A3905DB18AB2053E2D4F92F156A1D76D0AA891364002C991E632B53FA217AAC1709F37F3402F43B0753361EB2F595F9FAE3D7D96FF050DCA0B9657F4C3AB49EBDBFE8816051C4E0AFF32C5137749D53B062CB61F7201171B5DD716E9CCB38D00E50955596845DFF602200B30D375A854CA4E9A7276CA1A1D9EE92A04BCD78854BE251F7080ABA6D8325D40B37054596AD80211A50AFCC1DBC177600A70E648D8BEB4FCB8919214894CDDAA6D63B6F6C445469A6866721D4BF1117F25DFF9D65FC8FBE5B0ACC8B9039C7F94B2A5CC6068A0489E2E13A731DBE1094FA8558A601ADDB9E4DAB04FA744CD5B95A9D57C52C8124AD950A5944DEE2C55E5C8540DBEE5823DAA624F57FD5BE994BAB3AD4E74EA9443F8B6024BD6B49ADF3972442D88E61E04FE8478FF28916584CCB65FB15686991D5781CB7EDA067745258EA671E0A2665F94FEA1B5490669D1EE8711518BB911094957586C8075E3BBEDC47BE059053A7658ADFA0ACEABDD46E0DD9647B34EBA32E56B6305653ED386C50E79E15084F00F003B1D12504FDD8E47D03D9F7572276047BD22B82B8E81F87C86E6F20D2A756B16F291179A97B010F993C0F839C9A1238CFC9BDE8074405CF1B35DF423C7566CE965681F21C969E4F3F8FDCA72A18D5DAA80287F53B5F8429FEA81612CF63CCF1B7A13512DB4D1DD2678FE1189398032EAEB4368332972C728AD726B7290302C3C5ACAB6E73432E825B9046F846ADCA9D93780A36095AA5C51E354CC6E9A910CABBE59130E98F4ACB3CB6D4EFDA9E2F78748ED58465937FC81C548AD038FDC32AEC46B078CC5A7207658A9706F1C9653359DE6C4457DBFA71D300F98F9BC5DAA14DBDD5EF20DCEDE7E9D3F7DA5C932AC3338BA40E46B17D89FE38F725129991983D4A81321B394F2D7B20D66E3DEAAEB6FEFC8CFF0B68A766E27CCFBA66DEDDB1F541DEB3C1892ED2AD5D073162F0DD06B82E8878477BC96E03101C9B5D9D0ADA10EC060B45E144B31E6B4DE283FD43538B47178398FDD15B01ED421EE2C65847F7A4E9AECE2F1D13971FFC0157040782AD4B591DEA0906370820DDE1000490AB1C27C03D02A0F4B4BFAB0E56D7257288441CEA63175CD6BD11382E6C873154332E627CE82E37C63889EFBD8537AC35C21AD7A09C986CFEBF13B19D5677C1104B373F3B55198D075AAC608145FF9D0C4C12C83BB41036AB32227629EEB4922F172281A66C23C35B8A3E92DE0A10D5E8C18B9A54D6C30230F3A8263986AC535B6BF63EDDAF6A02C9100B712EC4BD49851A22AF0E647F259C2E19B9ACAEB6147C476C90745A353F6252ADE8212A9F7C215C0B3053BF2B4E0AD225E8B344EC14C1B839877349C3743E8337D9C1EB128B06939C5A08F60A46FA700723EB6652FC26440D9BDA3C99C10AD0742C2F039BE6B66749B77E14F8223509365053E87ED870FE3906A16DA6C62945DD2112C96A23942B1E14431AECA7DFCE3FD4D6633E0B661FB34B0BF05C4D21E689CAC9B6ABD9F507F08E4AAB94BBEF1C629C0E1CF344E66D3A3E100B615BF762DFF0CEFC5E4CCE0DD908F46C94E7411A151E713FE0C18ED33C4C03E55E12C0AC366DA5C757C7090E0F94E2C34D93EA3B226ADB2979D23E071F18C2EFF33BCF41BAAF52F4B44E38675DDDEC89C7BFE858BFD1AE70D96D0487972D70F8D8681982656FF734BB6323AA91EA14C6330C71783D235D9F094CB111ABC4990319BBF163891535AA5F870164DA65FFF395DB68B390084D4F2448B98CD56103E49CAAEB6CD040C3ABA8290284E9B2BC423117F4104D89B1B1607C6D34AC30AA9E79D8753B97CAE90ECADA6CAFC6100D3D6D91E20393E0DC95B981FE0EDBCF88E046F74184A96705AC226FD26089468E432D525643293BDA781B64BACBDFD6C7301AC42AED7DBBCE7ABB9D67AF315BCC3509CF03523FC887E27EDCBD7C74DADFD0F126CDB49E28ECAD38080F18A775E6D824C18359935D921744EA72FE293F299B530D9DC9285EF174EE60E2DDFFCCFFE89960BABA90D955CD2C96672513C758142D29A1AD79CA9291BC6782B64717F11A71E6D65A1A71D +pk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sk = CEE2E53099D8CB576F8F76C5C155470F87A6EC5F7D73256A0A2AEE62CBC535974A7A0BC737C7A726 +smlen = 3934 +sm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count = 90 +seed = 0CAF47BD9AABD7D09FFAD404449BBAB2E1D48E80AC78550831A365BED8765420DBBE9A566EFDF20D4E5233D7848582E4 +mlen = 3003 +msg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pk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sk = 02D9755C369932E7F99A2E1614B03E2C86D713563785965E008BA987A6C89F49B00C6ABB62D4C3C3 +smlen = 3967 +sm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count = 91 +seed = 9564E88F336C091EAD50C893F3EAA8351FA388682F433F7A72A34731020B9C96DFCF75EF5EAE47E12684AFA51EFB49B7 +mlen = 3036 +msg = 2601A39B6D7D91DE539EF11C3B67AE3EB1607716F587BAD5F60D311A9F4FE7F04350CA085EDA6D41C4BB6C6E13E376BF8A314DDF791AE18BE2EC0544AFD3CC27BDF270C4550E9E78D497B92349AC07755BF9167B2958BDE919123439D6F49C3408E8D88021E668A0A5FB6799330188E35EC5939B77097E3737C4F664D01D85FAAD0F583B3E95EDE125587E2A79991750D5CF804325C72DC8DDF3471EE8FDE02519D2D0CA7EDD651EEE30B3BE335CCF7FB02059BC3A47EE3C056D4929EAD4FCD82C8CF49625D5DA460DAA299718556BF0F77CC5CBADB99B64C8EAD4474601FD5C79309D4E63AAC392853072619EFD7B958F0EBDE5CBD40ACD57DF269A8810776D6DFF2E637EA57ADBFAA08DF8D2581C38CB262DBB4D1F3C65A4FA068539D2056E08DCF03BAFF006EDC688023A20728B227A99FED3B8F2BCBED2E3E6ECD8B8665A2E4D233B78D7C33F6E3BD9D0A24D13C8EACCCB53A21DDA9E7A34F9A0F031091E65F749C9EBCCF3DDC4097A121D8C68EB7883405EE34F6A8B0208EA8D5A3FAB53FE2CAD1110BFA6E094F78D5314880BB67BFDFBC2DF8AA250F1D7200FF9A3247C4976DBD1BBE99DF02A3F246E5D466F85ED2F68E0B2DE06B0F2448A7B98FBCBF5872BCAE71BF0DB4E70105B020FF130141E8DE86DBE05B7D2A234CE2EA83A38E23A262E46FFBC837E8A71F657E443052E9A49DEA4E344D497DD2DE2AFB4009D681F232BFF4FEEB173546CBCC4C80C9F85B1CE125BE678E5EC62EF04433D55D4B8829B01AC165A440FCD6594F2C0CB456C8A47444AB05A0F0717B8185930D9738E885D24DAB98E11ECFF7D7A48A4527F94FC4C9D1B9D71F5E6BB39CF92B1A6D0509FFFD42E77AC9AD6F50F8FC649B96B8AC08673F78AE8D0BA2B7243452B33AAC44B06A2B9BE1AD6A12583D3590A3F9AF0E0DC35DA88A257170D315F32F3A889601D6729433B7ADE0F719386723EB2A008634749F5253CB7D9B2FC99A1AE1BBBE7F00A536CD38F8A7237D3992C3897DF412F5B1D45E1EF5B5DC974D49CF8DBF785160BC527543458FD9378B3D4D3124214AE5676185794209AD0EE73B063CBD5B7830D00F817CA0D5CBB597C44D28E4885D935B7BF426C1339C500DAF4F2033FA6A27A4196F233256650472F205D2C5E00E7087FB73027B0C6C9AC5C1D928CCD190B8A6BB33F512CA8E2369DAE6111156DE47A24469683F4721A25652FF87474DFD92A028B3EC5BCFC244CE442752A7DA1DA6C33FC22573BF0B13E371CA9FCC86C76FCF7A1654EEF4442E47399835A06336E62952770C6E61C573CFD07B3AB631B8831FE3F5DD2C6DF68EBF2F8E02EC9F6B90A371ED5E62C8463780AC453AB6F72D38C8F5212C8B650F63B98E3C0886B6A85AE8E7256C1EFB30969532CDBF72184AECBDE2A17B9811DD4222D080049C5D36C532CC0E910779D64AF93D750EE96BDA87562EBD3830FEAD07A3960CD6DE7146603199563693392D3CCE1332DF35C2C8A2C251911D38E95815CE5A4CE5596E2D77711D87CDD54D22E8F0AB431BF8B24CE9C7BD6D077E436543C70B02F338841AF0FB86B5EA4B6A47E27C1D83E1AB06801044F546ADADA437F3CE7D788A1C92A74BA540664658E70D4F2711979153FF1589792859C3BF122628479C7C35EEE951DAB8CDB0D4D150C2DA338346988D34F8C5E589B231B5E00849611BA09711BD3A0516FD515E6C4AE1E8A3657C282C8120C97AA7A2E3BAA22B6EABB8D8212A9A48E7759A9DAAA51B538F662A05FB897067B7CF9D2CEB47A1897214CCFC225CE47CD60E86F7DEA49E220F7DDD6894B30B66460DECBBCB2E42B31F4ADF0AACDDE544B9124EA5ECB04B03C448B17E8094D489F516D23164D2317D3A1332E0500F1423136C8535D69065E880AF34CF7E36DB5FF2C18122E41880585B4D188411E86B370A024BD6E28143EA2EAE52EB46BE334A21A02E21C6755C0182B9A055A7D4C7B056E4930CE63EDC79C9FB4E2FBFFC58F776086F3487F02F8D1E7C8519C7F452E75CE5686A037B3642B95D7526ACD4A81A47112CF96A8DA7548016A22E9359198E871DBCC5852FBE14EECF3CCC5EB2FB5EC31D10474DF7D63482A03E11F4AAA2EAEDB714786E21D03AF1CD644D06BB05FF7B3959601580BF50E5F7F82FF42E9CF2FFCA0C67FFC52CEDC53C7A5C9EFB6C21092DDA374D1CCCBC78BBD9F5EE0FDF6DA6AC60C95F7C2E96F17E3C379A52D5DBD1A92DD76D1F5DFA19EA0408E0E7F7867445445CFA60BCEFC016E68872FBAC9098FD6A8E84731C285570B1BEACCA6F4728958E7924F7A7B7730B9BDC9AAEBD9E045F464071843C650D06C96D487CF8397286F81D93D0CC2008A62EE32421E5231998140909474F6D98541D899EA53714AEFE652A3D792E4C72533332C3133707A49293E3B2E06AE18F2F81D601AADDAF2FD09EC59350E0979A5AE2B721771682A1BFB5748D000F9736031CA971288F34993DF10FC06A16A6DBEED8CDAAA8127F3B71432E723558F0281459820A0F4A75A3B2716F976BDEB88BE9C73F31623050D7C1A96C84988B01D847309E1B6D7B815883F83C9BDB7FCDAEFA8BA69E25B824812B7D54530A3ECC96611897661158DAE1B4AAC112E9AC13D07FDC03DC7D5AF23C08C5E4BBFF737238FD3F1C06F94215BF2351DCE9CAE14B4DD4745AC0CD626054469C6A5286FF821BA192706D47CCEBC443DD67FDDB76797A8B78DD0DAF850CB5D181C82298616E1D3A92F7FC82FD256857915773C7AD97CBB9710373299AE8516B8A1D647A13C7BE848E0269ED6C8A91DC50D0CAD21430A3BC9E718A13D1966A0182D9A24FFF7ECBC7876C868AF2BAF2D8B782172C6719CF140E8CB877FE6D78779E1BB31C70C6C9A6A77529C51CF78A5E4FBD7FF6153B5195817F80603E5C5810C38CF43CA812ECA52F73F045E33DF4E3D04EC8C5F8B4A7399F6CBBF0D39DC951C476B9BCC002720CE89F09C3885673BBA9C90D20DCCCA4A82CE5BEB38BCD60AFE2BA65FCFB01C8793B7ECC0F0B17A9DA74F2E0FEF4C90B5132FD6BAF8C010FCB5E8E7FAEAD7F2E0DB29BFDD1811072623CEE274EF2EFB0F7D4191F332AAF20CF36FF89A2EDF15F7B284CABBBEF46901271D8C1B180F736125C8A44FE164AC7E687E9A58C3B1775238BF1A11F99BCB583D0E3C44BF4F76DCF9496A06F80CA52E24D55B54AB849D3040B4798BF5292B0574672E9F844016A52A4D4E4DAD2053207BC97215BCC1BB93271C03C9AD2DFC7485EE2ED399236AA06CF9A12972E21AFDC587A6334CD1D71A7539362D714BA26214664E3B4BC39CDB1DB847583DB8E002A2AAB451B4E5BD6FE200730BFB2745D03C82B640F4CCF58701708F724EFFDF98CB04C78DF36B7A866CFD596BF5EA18445EEA0E34ED514D0DC2625039049A0CC82711DBBEDCE339C77F9FA1DC60EDDD8D58C8F144B0F3D00227AFD8710BDC66D29809728D7FBE85F08AA38AEBE5605DA29A09CC0526FEE84691EAA54DC3744BF5A95275037FA2F600B1F91E502D5D81AF48F8EC4C1834FE625FCDF2364067048727559047E07062B4D8A7D3851853BF28BE9D2C511451E5FDD9459270328A2612DBFF42E1DD34005A3DA1226A023162F454923C0337E6C74B44BB27A3B1AC82DFD68B0A6DAF93473D97A9E4591EC01A51CB6B47E2C7A85C1FFA73C35E5CE3003BC4534A2D9B16EBF9FED6464CB1E0CC665A451616A62B6A8481E4506A73883198C144A06331224D358196C815C811B103959EDCA35B26BCF86F41D9C7638547496787885EE62B14AF431CAB2AD4E0224D33476C58B8B0833BF13B50BE2B1D682CA7DD194B793AD2C6E4EE25AAF95459302F0B4DAED907A317BCC6A5F8D76CA9AA0D799F8EA39F330D6244BFB9F35E6223A0F665A65F55EAB9BCBAB446D7FCD424DCE87F234864D2C27EE84600ED9193AFEFB6E7681BC94F514FE0748EB32D32262CAB880D79CD4FE5CC963A4F688D448F2DB2DCC5B0CA87AC26DD8506512C100273B8D4D902FC054D48D8BF9EE818AD9619F68A8904B613256DB78C881CEA3373F0CBBAC336A78CD91AD9D60126E05CB8C16E9AA8482CF1B806B2F9C57BC8D63BF008AB2E49EDE8E788BF96B9F1DB2918DC5063F3F1D5B9B1C0327141ACC0B4B248FFDCB8BCC127050D27C805E154A4825DEE6BE9C8D4E42B1F5EFC1EECC6A45DBC119AFB15CCAD19789EAAFA8B1715111AE32E2ACED2278803B60E2FD63A43317498244A7CF7342342B60462510E19D83240DFF5D58E762C093DF326EA503FD347D2A92A5A4680D5E13B305671C729179FA21BE83B0D83144E63 +pk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sk = 2B2BF7CBB0957A86BBEC97001B60C7C6AD98A56E94542FF561F78FED211DA755FFC58C30FC8379C0 +smlen = 4000 +sm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count = 92 +seed = 4D0788DE958A707899D5DCC02F756A10DEA2EFE0214F5E01B3281DF4E013CA75523ECEC64723D6C8BEC0B92C4F821D8F +mlen = 3069 +msg = 9163116C86E64D90D35CB216FED71BDBE6A0797A48CB915F5A40FC8D31AD340767058B28CFF0C240720327E12E653C1F98B5755D8000BC01324DB2820781B94C4434FDA76223845E0613E2526A95F28FB4A768B1487AA34DADB28CBE8DF4FDB510DFFE672FF004F37C7AC32072A24C0F12A050BB396AD56346F4E0BA75C0EFAC162288A7EE8A63255DBA5CF451A0932FD56B05E40EDD491293E045A6081F6586BDCA10B41A6970D8F9A7B3B6B58AA772EEFA9ED22C9A24A384D6947770862BE4FE45C5E0E56FA4D116B79699ACE41E5D9F2E4C245059CD798DD986A3763F527E0C9D5A88A09C4D76D447348509FA7D9BFBF3DEA59EA57711A3B1A9352123D4A74DF273FA24A89BCAB42A6D455B5FE3C503F1FF638280F87C740B9E4C5FF20133CBDFB8D08CAEB7DE9F26811D437E6EC8C3143C0419C2F5135D25C7F40C7908C03F295FD26F1A03FBC7285196BE40ADC6FBDDDC912B3BC94B0BCE08DBC2185EE3CB766325068DB55C31FFEBE4B1F6848AD4FC201A5FD056916A397ABE6A66FF9BB03B037B50AC509E46CA441ED45812E3334FD7036D190A7991E55CB817EC2A63CD800F293277E7D15F086618B55AD395C614D168FCEDFB274FDF4FCD50CB976F68A266C5365E02A1ED0221BA4E13E70304824F94251249CA23C089B4D54E02EA03FB7C9841DD30404428AAB2519D68CF564D75D18530C7D062496C120A8F5305AAB23AE52255EC919EB0CD875422B144BF47F7472349558E746B0EB5493F1FC40ABDADD2ED84A8B31221A485052369FD0B552972C9FAEB1A78E826BA4DFB9E91E301DB589E9D7C256E7051692C48534C6A5E2BF0F45B78ACA66D5F53E549827E15D64E2F294F93D43B9F36BEDCE6CEBC05E56CED3F846635AE3C384C3FD55B969CA31E8C625103C2B24E7EE45E92984CA23A331C5B14281B20116069C619D82D6080C6FE35C3A3FB2E73B695CAD9C5D3300814FD65738DCC3EAFCEFCD24361AAD13A25B3570D2D509FA449612BDB5B49E0605D7EB78449D1DB40660AF0F3D8BCD4869B6F175CD28AD72FE2668C3DFC1D4963D0EAB309DD50B74B9D2947F86FBE9864AE5D0DC69B55B182AC1D914B11F631193F5F1F897CE52CEE97D7AE95631FC2F2A1AE9B672165432EB2E5633B55185AFA5E883268D8503AEC10774D25D39C800B74405414FB06C55B8C48835577884D6B4F2F128246563066F8F34D76213E0720E899FC1F11A3B0A591885D82C688E40D6B44B54D6C7C6973156E2DD50C40A28D2EBBA60F5117D64646CAEF72974F4B8362E4820EC04F2F373DA8D883AF27518567688146F16BF4E10969E70BE8ACE5D2FF6A135DB1DD738907EA355FB6D243904F6427D11592672060DA14443B55A9089167FC9D5EFB2C64B0069795C341F90DAFF684E566611EA87BC40A4C45F22C23AB6888A754B89E4C95BB54629CE74EC999889C82714B5AEC703DE7BC080B0D2E622ED53B645688CE164ECDFF4ED66C86049B2F9077F2A94CD685294F8EA9CBC1DE29A48D39F6B308288DFDB47731E39644B576A298646752F5C53D7943A5D0F7DBBC9604902B61B8EDEFEB5AB7E5BFDBC1E6723E6047894547E440E918038CC13B47424CCFE1A207E08A40524B553C750683F5F6C960F05836FB9B28C59E1B471FD5331F1811DDF3EAFF73798B7FFD6C9714978988C440CA906B4782A410372D70EE65A0A803061708003688F576E2D3A22580B706149A24B93A162BE9F1B546680A1DB2A8E54A576C28B4772C50A55161B2994514369C2192B2C90017CC8282F41D28099F38B2F1F0D2C0E46B444417A2078755591F00F01DF0CE72B1D1BD255A14D2BF67AB3E630F95A5DA9BD9E10F08EFBF6FE722CF000C32460FA3271F18B39EAA4487C1DDF828B6BEDF4523837BB3425BA1C1606E8D5D1E6182AA6A74F068F3E90B42641347CA755779216AFBC99603391FCEF4E8E5AA202BDCA24B83FF42F4F01232D3F2831CDA2DB76FB93A4CF6E9EFB71B5438A4B74C3190A8901D73566C50727559BA9BF6317D116E8F5536BACF064D3F86282E0F88DD40B63E75519C6A8E5664AF8E1029FAE87930F523E4DC7C2DD6DC3296A42A59F178D438866D929A70951BED05533EB1D818B7C7C595971C26B1D436D26897D6A6EB036A13511AC4A3BD724F2CA57FEF07D2C0730800D35683D745125F4237ADD64B538B7DAB0D0F258DAF7DE1A74F74A2FD010CDEE810F514FCF6045F0CC84E2054B5F4EC2772718FFB4CCA9C9BE77F8F007333860180D60EE4DD8CE976E63FF49AA11DD42FE6946515E59DA3E602B1861BD3F63C89362BCFE8438BC71959A617D8D63331A3D903BC5734B777FB14F7A2B063D79EA8637AC52C758EF88DF217B95FA8FDF1009AB28D8A4F318F78772568CC7AA9E3B3E001C0111B1751B698EF1B66383D6B3CA942FE4F66FC97613CFBBC03EEC9D0B7E08F80939D9A2EA1F72BDA7B0D655AC3A94B4C699D3EB1BBD6076E63EF5C1FE9CE258B55D21164CA7EE03BB53D8BA4306F695E648093542D769DA95A35FF3A2C071DD8ABD5A82E217D82317065D50A87B689AE3A2EC7887957BB243373CF986490961220EA61EBE12AC0287B185070E124FC518C300620B4B6D4F29402B18C2462A7985C00E2A87691053B1FDECB7AA264F33E27C6B201CA6065EF79E5266513AEA92E8D3E646453C089B5EBA66D14BC45844D0240D2E7737C16668FD53E38A93D6003146019777C03644C300D06927EF6994AC794914EFC5BE0CA81680CA8C9752908FBD2D56D7FD1FC1C76EED755408F1D7802F0D3D0F347D82B162EE6F0A2A890E083C20B822FA6C4AD627F4AB5D1526D83D897C244D6ED4A427B23B4A0C19F4E8889257C1373764AB7063B5DB8ED9C2443CB012381A2B3365EB568649D7CCD52271F25FD22FDC397E4C9C536EBB452CD2CD10DC5010BF433F88CB58D2B9EDF2BCBFA83B782FFD4388F1BCE3F8F9AF5AE6BE590BDCECB1BFEA846D2F0199ECCDB0C7E4D419F69B6A428EAEB462B67AA40340417BDFEBB6039AAB8242E39F6C11EC136D73FB315CF71414A2A1203AF08FDEE34ED0072C27462395815F7779012A41EC526BE53DA954E1F7A7EBBB68FEB15CBAEA8ADD6CD0F2FE3D3615991AB54F4C7884E8A80A9535F13BE2ED944B3BB315DE8AF2A70439294CD53F041F41D3562BE840C78EFCB08661B1731FEEC46A9091ECEDE3A9FBC2DAE42C72EBDD84308E95644373595DB62157DBA7DBF124BB45DE6C2837B0066673BFD215FF915A8D41637EEB029C345E444251ECBBCDF79E246A80AA4591976A00DA06C759C6160ED1986F8E15A562417DA55109174628E7B11D49586882851205755B4F99A875AB3599FDCC094E4A2164E1764D24DE805FD7B20EFEF2A8E23FEA4E206DFA1FD9C31D90C1FECF745D3EB886190827D952703AA6A99B5000D8EE9D51DE94A82DD053B6AA89CD7E94E92D4AA93A9224D3F688B5C834A53F2993638166A3DE78ABA7CB930CC5845F9915E6523683715A187E940FA2A978B5CA4C3B80DB62E96A600F1864BF0B1AAC23B1330B13EADD3A2F07CE7181D0A9497C455D228278E5CC3E4C00A2EA3EB8E5B9CE2799256302B0F8F1F829D3A3AE8AA7CC4EA229C5AF476C01B8D48A9F6987DF57C3469B6EF6DFCB488A3D5B91FE17B5798FE154AB8399A2E75F0D15B2A6AA91302056266B22A38A604EDC374E2D2155ABCA119C11DC6827A47E3CEE7032F6E0F59708DFACE221E47041CFFC59CE0334D9B7C5E91C2C320A70EC2F32906624128363C893909F47BD970DF652D5E6C2324033F32B1653A039F8C051D9DC8F839C50F5696E9E08F7F1CDAC4750B429AF03176FF6E643ECA1D8FC710C6CDB0D26074D85316F4C9084D5F453F6D36C1CEA0E389F3462E1478E2503C1DB99FC46F3F0627F173672C21F3CC3B483998192E81EFA689819D0007762ADBD141A058587E030A3568E412D25662C40ACDAFC3C6EE30C10CC23E3DDEDB6C73085C90C89B1218D67A328F06C3637A786D4715CB9F9D8B0B22D920B68B0557CC80A56FCE0B6E2D6627DE576E308757A8F37821898E96785AE323E413D3572205B0A5710143A2621C258C76C7C3FF7100A2FCAE99C84D1AB1CECF7FC5B1E4698BFA3BA2A0856A65F2D4F291A4A164C0381D70D1213F7E40FC4BA42C43EA8E70043E27C5AB0827559B7CF7F2587D0D2F93C6382CF54E92764D815280D68C554E5B6FBB351BD18635786299DDE39FCAF3EFA708A3F18701EDA1579BFB0BEE4FA1F1ED6E09D450D427E4B91F4552F87F31F06F109E74AF4BF301481452AAFA2146F6375DA467EA008BAFC3C8408AADD61B07C28C55249EC0C8BFDB00EA +pk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sk = 049569CC5FB969C6EEBB8AEA1AF1FCAF46F8A9E6CD6C796FC7193592BCA9CF23117969CEB9E380B6 +smlen = 4033 +sm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count = 93 +seed = 55A9C7A0B49706090BC0702ECFC070AB060427FFC820C3FE05B499B59AEB125F2DB4787A5910B88C6F8FAF0A69BE0AE5 +mlen = 3102 +msg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pk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sk = 9D89B9A327DF0D341CD2968BA9218BBC3E934502CD88919D8BB16DD3D39FEBF7AEA255E6536A1C68 +smlen = 4066 +sm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count = 94 +seed = CEECCCD3F7BB922650E3F6E8F20C47AF17C1C1053EA8FE08226F167D67C3B0781BD774C4C7AAD23C6AB0B9F3E3F96F97 +mlen = 3135 +msg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pk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sk = 4544C2F21054605B0EEE46F62A87DFCBC3BFEC473B9850886266F478BF9E33D7DE05F379184B19DC +smlen = 4099 +sm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count = 95 +seed = 2489C04BA57D149A60F446670C13C29998B52F3BAD548A751D7134B694DB25ABFA034FB4BA45E105AE27D575CBD02B99 +mlen = 3168 +msg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pk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sk = D9931E321732BD82EC9CA1DF12BA48549BFC7D3E76A404B71892F4198777FFBB1AF7BEAC03F707B1 +smlen = 4132 +sm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count = 96 +seed = 26CF860726D4DFA38AE07399838BB336F1BEE59E9F23AE4C81E73D49964997EF21CB5F5412F9A70A1EC39FC6228C36CA +mlen = 3201 +msg = DE897F02AE7292ABAFA6A0CAD52929113410F2BA972B4184E894C4D31081420751560956F49CE2B772635625AFC3CA6698FBFDE4D0A05EF243DF190BA1CE780EB572590E01E6E283E1963F2B0722B0CEB365552F65BD405F1A284DDBED07BA61C4453D30CC28C83E41590E09D7BB6932D231285205D61332FA9263B8A2D3D7F7FA20F521CA4B49F249896780E08C2DC41669BF0777278F87BB1F72CDDF4B998062B1642791F81AD474D6D8F963DCB4458CE11108544C41CDF19145B77038C7E8ADCD6501508C53B25BE6E787313018620D1BA647CCA4A5A8399E11815EAECEC6AE66DBC576699BB0AB44DE111AB6F252256389EFDC0546E641DE87FD6A3A724716257A9174F39542539A593864441EB79D499FCDF2F1D053CEBB3A1FCC09419D2C553C2265B3DC3943E0341BB49130E9981EC59945FA0B23E9DBDBF352ABA0D925C4333F2EE1F2C83C847EFA78BB13263B893D7CAE029BF08CEA2A5D1B5B997E403A489C6D9A124FB8386FE58C2476894E7754B8E5A162102A119482B5E59F8D89C8B1DEA70B6C80641C77BFD12D45C5B3CE0021EE500A1665ABCF740794E0D3E7E8CB5804A1E0D0C81A107DEE80BF63BFF8CE2EE2DD602DF279DE39C579B417A758356D2B48B41E83495DEE9ADFE4506E03F19DD096E81405264D408B2FBCDBF41DB5CED6FBDC2645DBEFE5BD038382993970C7686DBA3FEDC24E1F91BA4B6CF70B2E832B97BE24B6393273A519DB0B4446E98D77E86CCACFBECCB18939013C66F7A29B10DE2E88FCFAEF656B858B7DFACC4F21EF5F328C0EF604FEDD993510BA40530B79525FE8D336DEF0E5C303539E664A9360EDAD7268F70DF4DE199AB3F70EB2BA65E2752BF5FDB1E853E6F4EFCAFBB31D8CC23155413BE31082DA958B01682894A9057CAB66D4D64A6F3B1D81C5B75815A3E0CAF6486B17339174276A84E11C117B060302DC2EE06A03C0E15395C0DD32661638F059A385578C1B792349A41C511D12AC7185B060A831EE296E6626459C2750FAF3AFB579F6F6836D566C00C979B5130E8E50431E914834CBB3D26F6E5BA50BCF05D50F699FAF10767AA2831C3557A53AF14BFD9F23C00F76C2680C7DBF4A9B2A425E34C943228C3EBE55A0960ACC757D7878F7943E2E8A1CBC8C0D2139A6A6459D3492A1A7757F71E90A58A78E0FF9B04D059C5D131F6E3C30742FDE5506AE7860045A4C903DE96DC43AC6A69273BF8EDAB7E7FAFBAAD9EFA8FA609961502EFACCDE63A6D98D8D017075487C608FF701A7E3381D7A2ACB134B198950ECC6970A75AF5625FAA4EAF968CCE48FFB673F4F365802A984C609C33BA312140A60A6F0924E945D11BAACFCD643C874D352A90367EA4C59B63665364832B1A9A9A01EDA92C64F393C357158973FA7C6047B8B5E27EEDB28E26359402B63032F8B230F5AA968272819CA486A8BAFD3D66799AE951CABF04EA81E1E7E4632B915D4E8387C7D1F4FAFE1C1FC8666FE0318403EA0027487E947D844A7FA28C0523A64EBD95D2A8ABF6A71FEFB5BC059B2CBEECD4375F3A3F109DEAD98539244DDCFEE9E42DB3ABDAF943C445712EBF19508A1FFA6133C5078C1DA69A32CBE729A8876C4C73CB232024A87D87FD5F9456D3D4A936CB4CE2E00EF415406D66D344000A4A95CC9651425A16021336C4BEFF310210324C754BBE13CD0066C507413671C80CF492B4655D898A18A2F4DB5A393400C6AD821580B0712D6C919C62E87FE212260EAEF6876C409FCA1047A67B223E0766144F3F676F051FBE912C4CE4A9F7B85459DA031EC47C621F6EF06CD1621421FA52B047B51C944DFA94807083B4ED40D533B19813477193D1E4E96C8D76A5AF3100FA44A985A6513060B08A7F3848159B3CC551D43370B223037753B824A099A7C7DF59305BE09E2E79618C83818BD542F39380126A927190EA5536DFA63B664AA7601C6D82CDDF4CE4006E1AF2601EC453971828CD09C29D2F3EA6392B58D38BCF40BF6B6497F6B848CB853B187610CD23880CB09787C76087356C66565C0399BE746A81753442E4AAA54E84F1D8C2CCB2D00A551E960203D61E71A72E131ED1967DD06E72C99264EF2EE5BD156FC869B5031BA23A6D354D7CEC58F339F6BC2DD1C547F07AA733994860197DCE5BCE6024A74668ED89A2C9CAFE1F78B31638C3225D96009C260FBD28C1F0423E75C9C01A0F9E62B7F265FA3817F441F56AE79BA54A0C107FD7946A2DDDA60D0EAE428715FE2B4FF93BEF83CD10E5E17760FE028F1AAC8084A43EDCC12BFD3265D13FA94D9704809A50881D48F0080A976C5BF31B353B9043C0F0B69AE6F2B8BADD056752F2FC9E90C4B35850C2D45B9F354B41ED7826B976528875547A0C389B83725E26C006CC8240E380E3EB554DBF2133A131743539B1D174CCA6B135C59F81D499631BDA4CF90DED836E8C24C074A0BCD83271309FFEF320791C9030FC2B1F53FD2DE870E54EBA20CE9930C279B48B39CB481737F012F65933650374BA39E2222191B0E3C7DB9632CE9CB077322CEF97ED832DDD8AAEE53C52C03D2AAF8EB5597D8D6467A406BF428E2F16462E0C0D486A1C1C7348CBBF92633EC4FFA75945025A3C92095317E32290D4CBAA6CA40F3F201975F3FC8B733D1467C094E075E8415352E3AE51A6C5169A4AA430BCD66FF39B184F5B7174042DFCC6840EEF60CCDCAC12D012AE4F24F7184A038D8D9964AB405366740600B98CFE2E4737C8D846FD4E9B22B5047110D85B37BDB9E7E3BAF5298BBDC1050AA20F14E34DEC283830F5FA9C570C22CA659C1276BE8FFBC0AC3551DB8488855AE7EC21E239E88A0F68227D17DD87FFA3B3D0535F9E57807755DE56A65C0DE9F4A79F8746B20908BF9416A86F62EE2C2545BCA2D55CD4D45DCDF06DC879E1B6270A80778D0274AA658395D800EAEF367DF4F4D838EEE0A66093E0F419B9EDC5F003E31CF0EB7E1CEE9ACCDA7A2DFC920A4B5222389DBF12AD17392850C434A9B3C260159B0F52E78E7A66D28DD5B3C77662CFED2CB3DD5BC3CC26A34293EBF1FB3A9BC59BB0C104C5A9387F3893A65D145D424CE741A375F9C65E733A024E78FE274B29FF4B0EB6F21FAFC31453EAF7E48FABEC5711D3898B876F59952C73123281A8E85148CEF5A166BF45DF36053D57AE6F29D3E334BB2395FA236D4DAA8A4FDF99D80A9BCDBED36154BF4FA3D463D51974032D7B88B2504317E14165B1C3FE3D8FE366FC8284321D80F9CF512F418C63F73B7C29C07870332387BBD1A870AC39485F64086006CFD68C8299347615A423736C01FAEF2DA56CFB6FC966948649324E22D4551B9F50654EE505547F7D0B8481ADF6AAC3977F49D7E6AE5C4248DF7B43BDA7F082AACFCDCF1C1BC04F2D45F5E028498ECBCA47EC4D1DDEB03A2AB27BE9E4B80585145676F8AE7A5017BC5EFA317A576ED6E423D5A0495B8DC619712A2C3E6162B04B9BBC7DE4BE6532F6C1C019E702C014C60189A2612594BCB18317804C630264D07B7396DB562777BC305B885E00706FF6D0208737BD229BC7AEEFF5FB770A4C057B347601F1F6C16F60D4A53A0B32631AD2D41FA307F6630228E1807D22475D5E331A50A680896DC606F3941AC08F8BA46DE5A49F5ED6A94965334FDFD69C4A6C7973D9615B3FE576B15AACB9B98D9E498D2A3A89B4F8EEE715ED5F29F13DDE7629BB386F7CC800F16F3B5BA8BD0E14CD8D9BB0F0AA615BE9D7557F6EFD00F7BBEF9989E7F463279408E6AD77E100AE4457D57424F2B1CAEF43052C5B25C896BAA1C2FE67D1D6F669311F17D39460F0B176A7727F53257A36FAACBF3DFE623D8F882F8EE41BA1CE387E1D1860F4BABE26ED678395B9979D84DEA5C7B38905D4C7FD867ED7722D066BFF3A833D3282BB40D1CD310DC8DAC9270A49B65B5181EB30F166CAF0832A8DC56B9D135550B506D98D036BE7876836AAE669507990DE6D03E78A38139CF64F65FB410F192E30B045C93FE259C10E0C5B56A2B5F0605DA0851104C4BEEB4E3B30135CAE5A6C68403C63121B0993832834A3B5EBDD345C41B26DD219560B624024B8B945A10D385B3CE4E0BD54E10A64ACA59D283302028A9592120D142CCEB1CC30E1F96AD041F1E17BCDC3C68C2EA2E0D65D6BA3696166CB365CC461ABC4D67D504E8290EB452ECB77F6D5FAA5053D01317646242384C5C510BD43C5780BBD01EBC3AF33D29D8A09EF39AC85E70398D2A64DFFA72B3EFD8D6D57AA2F9DAC0CC6EEAB27B69FDF2403A5FEDE0BFAF441619BE03FDE44C49FF0A34E9C37D2B9AEB726D56EB646A67BF349323F397DB056D71DE72A2597D780942554C8F8273E307DBA6BD02E944E0559509E1F28B511BD709D03EA2451EF234DF6F077E06AA01E2806D5BDF89DF29F1B3D8C6D8014496AD83857F7465F1072E88709D0194733E1FC8C9F092DF5B9802FD2DDDA8B142217B9532D8604E2F32D06F6400025930DA2BE9B25529788E6BF4EB7F84C272DF455CE2ADA291CFDB5FE815129E4AED59625C879E99B3E3C1B6C5D7 +pk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sk = F838451E4A5929B8BAE9084B40B1DC0EDFB76A9354BF27F981960C88B0BA3A1114CEA7AB20EAED14 +smlen = 4165 +sm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count = 97 +seed = 13F1F446D9AA5AC853278BF74C9E6447A6CE4294C037867F43DF554370EE261D05C7260EEBF46D6694D0850B8343FBE5 +mlen = 3234 +msg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pk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sk = 8E4334B2589D0CAECF0FD9BA584EA26A4123D4543A8A0FE126D4A7E07F6067AFEFD08C29D01829BA +smlen = 4198 +sm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count = 98 +seed = 6F6E47E8336ADEE99B2C52CF2DC8D461E0A54C3DF2F08199A9F0816AF8455381054CE47A7766726D3AFC2E2F2BEAF8E8 +mlen = 3267 +msg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pk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sk = 37519A02E8021F2257259C0D2E499AF3533C8ED8DD5BF7751CCE920D79B518FA1CE4F13E8E578198 +smlen = 4231 +sm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count = 99 +seed = CB2E6226615393FC3BD4AB3A412AAA030AAD40E8648EE6B56D2C1591D8B97915D88F2D22F7221377B4B04CF2AE9ECC4E +mlen = 3300 +msg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pk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sk = 690482BFF6C1D0BA6C071DD395ADF69E55E1BFC4E0992A8650FFB5E60A02B1724B19E84C64F239DD +smlen = 4264 +sm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diff --git a/test/zencode/generic_mayo.bats b/test/zencode/generic_mayo.bats new file mode 100644 index 000000000..6caa6ce09 --- /dev/null +++ b/test/zencode/generic_mayo.bats @@ -0,0 +1,145 @@ +load ../bats_setup +load ../bats_zencode +SUBDOC=mayo + +@test "Generate asymmetric keys for Alice and Bob" { + cat < wrong_message.zen +Rule check version 2.0.0 +Scenario mayo +Given I have a 'mayo public key' +and I have a 'mayo signature' +When I write string 'This is the wrong message.' in 'message' +and I verify the 'message' has a mayo signature in 'mayo signature' by 'Alice' +Then print the string 'Signature is valid' +and print the 'message' +EOF + run $ZENROOM_EXECUTABLE -z -a sign_pubkey.json wrong_message.zen + assert_line --partial 'The mayo signature by Alice is not authentic' +} + +@test "Fail verification on a different public key" { + cat < wrong_pubkey.zen +Rule check version 2.0.0 +Scenario mayo +Given I have a 'mayo public key' +and I have a 'mayo signature' +When I write string 'This is my authenticated message.' in 'message' +and I verify the 'message' has a mayo signature in 'mayo signature' by 'Alice' +Then print the string 'Signature is valid' +and print the 'message' +EOF + run $ZENROOM_EXECUTABLE -z -a wrong_pubkey.json wrong_pubkey.zen + assert_line --partial 'The mayo signature by Alice is not authentic' +} + +@test "Alice signs a big file" { + cat < bigfile.zen +Rule check version 2.0.0 +Scenario mayo +Given Nothing +When I create the random object of '1000000' bytes +and I rename 'random object' to 'bigfile' +Then print the 'bigfile' as 'base64' +EOF + $ZENROOM_EXECUTABLE -z bigfile.zen > bigfile.json + cat < Date: Fri, 13 Mar 2026 22:20:42 +0100 Subject: [PATCH 06/19] chore: included mayo instructions in build files --- build/deps.mk | 9 +++++++++ build/init.mk | 13 +++++++++---- build/meson.build | 2 +- 3 files changed, 19 insertions(+), 5 deletions(-) diff --git a/build/deps.mk b/build/deps.mk index ee27331c9..f2445fba0 100644 --- a/build/deps.mk +++ b/build/deps.mk @@ -136,3 +136,12 @@ mlkem: test/build/libmlkem.a \ OPT=0 Q="" AUTO=0 MLKEM_K=4 \ MLK_MULTILEVEL_BUILD_WITH_SHARED=1 + +mayo: + $(info -- Building MAYO libs) + CC="${mayo_cc}" \ + LD=${ld} \ + AR=${ar} \ + RANLIB=${ranlib} \ + LDFLAGS="${ldflags}" \ + ${MAKE} -C ${pwd}/lib/mayo diff --git a/build/init.mk b/build/init.mk index 804c6a877..62debd83f 100644 --- a/build/init.mk +++ b/build/init.mk @@ -14,15 +14,15 @@ ZEN_SOURCES := src/zenroom.o src/zen_error.o src/lua_functions.o \ src/zen_ed.o src/zen_float.o src/zen_time.o src/api_hash.o \ src/api_sign.o src/randombytes.o src/zen_fuzzer.o src/cortex_m.o \ src/p256-m.o src/zen_p256.o src/zen_rsa.o src/zen_bbs.o \ - src/zen_longfellow.o + src/zen_longfellow.o src/zen_mayo.o ZEN_INCLUDES += -Isrc -Ilib/lua54/src -Ilib -I/usr/local/include \ -Ilib/milagro-crypto-c/build/include -Ilib/milagro-crypto-c/include \ --Ilib/ed25519-donna -Ilib/longfellow-zk -Wall -Wextra +-Ilib/ed25519-donna -Ilib/longfellow-zk -Ilib/mayo -Wall -Wextra BUILD_DEPS ?= apply-patches milagro lua54 embed-lua mlkem \ quantum-proof ed25519-donna longfellow-zk \ - zk-circuit-lang zstd + zk-circuit-lang zstd mayo pwd := $(shell pwd) mil := ${pwd}/build/milagro @@ -48,6 +48,7 @@ ldadd += ${pwd}/lib/mlkem/test/build/libmlkem.a ldadd += ${pwd}/lib/longfellow-zk/liblongfellow-zk.a ldadd += ${pwd}/lib/zstd/libzstd.a ldadd += ${pwd}/lib/zk-circuit-lang/libzk-circuit-lang.a +ldadd += $(pwd)/lib/mayo/libmayo.a ldadd += -lstdc++ # ---------------- @@ -148,4 +149,8 @@ endif # zstd settings zstd_cc ?= ${cc} -# }}} +#----------------- +# mayo settings +mayo_cc ?= ${cc} + +# }} diff --git a/build/meson.build b/build/meson.build index 8a9d65397..1ee971e75 100644 --- a/build/meson.build +++ b/build/meson.build @@ -35,7 +35,7 @@ endif ## BATS tests in vectors if suite.contains('vectors') - tests = [ 'aes', 'ecdsa_p256', 'hmac', 'eddsa', 'sha', 'rsa', 'qp', 'merkletree' ] + tests = [ 'aes', 'ecdsa_p256', 'hmac', 'eddsa', 'sha', 'rsa', 'qp', 'merkletree', 'mayo' ] foreach test_suite : tests test('vectors_'+test_suite.underscorify(), bats_bin, From c1728038a3a724004d520413169fb152a52a4125 Mon Sep 17 00:00:00 2001 From: ms8421ms <109365501+ms8421ms@users.noreply.github.com> Date: Fri, 13 Mar 2026 22:22:08 +0100 Subject: [PATCH 07/19] chore: included mayo in zencode_keyring.lua --- build/zencode_keyring.lua | 253 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 253 insertions(+) create mode 100644 build/zencode_keyring.lua diff --git a/build/zencode_keyring.lua b/build/zencode_keyring.lua new file mode 100644 index 000000000..c8c9bf46f --- /dev/null +++ b/build/zencode_keyring.lua @@ -0,0 +1,253 @@ +--[[ +--This file is part of zenroom +-- +--Copyright (C) 2021-2026 Dyne.org foundation +--designed, written and maintained by Denis Roio +-- +--This program is free software: you can redistribute it and/or modify +--it under the terms of the GNU Affero General Public License as +--published by the Free Software Foundation, either version 3 of the +--License, or (at your option) any later version. +-- +--This program is distributed in the hope that it will be useful, +--but WITHOUT ANY WARRANTY; without even the implied warranty of +--MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +--GNU Affero General Public License for more details. +-- +--You should have received a copy of the GNU Affero General Public License +--along with this program. If not, see . +--]] + + +-- DESCRIPTION: Special keys schema has optional members common to +-- multiple scenarios, it provides a common interface to create keys, +-- verifiers and check their existance. It does not use the keys, that's +-- up to the specific scenarios. One single scenario may require and use +-- the same key types (one or more) as others do, for instance reflow +-- uses bls and credential, petition uses credential and ecdh. + +-- utils local functions +local function nop(x) return(x) end +-- the length of the kyber, dilithium and ntrup keys can be found in Zenroom/src/zen_qp.c +local function dilithium_f(o) + if #o ~= 2528 then + error('Dilithium key length is not correct: '..#o, 3) + end + return o +end +local function mayo_f(o) + if #o ~= 40 then + error('Mayo key length is not correct: '..#o, 3) + end + return o +end +local function kyber_f(o) + if #o ~= 1632 then + error('Kyber key length is not correct: '..#o, 3) + end + return o +end +local function mlkem512_f(o) + if #o ~= 1632 then + error('ML-KEM-512 key length is not correct: '..#o, 3) + end + return o +end +local function ntrup_f(o) + if #o ~= 1763 then + error('Ntrup key length is not correct: '..#o, 3) + end + return o +end +local function mldsa44_f(o) + if #o ~= 2560 then + error('mldsa44 key length is not correct: '..#o, 3) + end + return o +end +local function rsa_f(o) + if #o ~= 1280 then + error('rsa key length is not correct: '..#o, 3) + end + return o +end + +-- KNOWN KEY TYPES FOUND IN ACK.keyring and their import/export +local keytypes = { + ecdh = { + import = function(obj) return schema_get(obj, 'ecdh', nop, O.from_base64) end, + export = function(obj) return obj.ecdh:octet():base64() end + }, + es256 = { + import = function(obj) return schema_get(obj, 'es256', nop, O.from_base64) end, + export = function(obj) return obj.es256:octet():base64() end + }, + credential = { + import = function(obj) return schema_get(obj, 'credential', INT.new, O.from_base64) end, + export = function(obj) return obj.credential:octet():base64() end + }, + issuer = { + import = function(obj) + return { + x = schema_get(obj.issuer, 'x', INT.new, O.from_base64), + y = schema_get(obj.issuer, 'y', INT.new, O.from_base64) + } + end, + export = function(obj) return {x = obj.issuer.x:octet():base64(), y = obj.issuer.y:octet():base64()} end + }, + bbs = { + import = function(obj) return schema_get(obj, 'bbs', INT.new, O.from_base64) end, + export = function(obj) return obj.bbs:octet():base64() end + }, + bbs_shake = { + import = function(obj) return schema_get(obj, 'bbs_shake', INT.new, O.from_base64) end, + export = function(obj) return obj.bbs_shake:octet():base64() end + }, + pvss = { + import = function(obj) return schema_get(obj, 'pvss', INT.new, O.from_base64) end, + export = function(obj) return obj.pvss:octet():base64() end + }, + reflow = { + import = function(obj) return schema_get(obj, 'reflow', INT.new, O.from_base64) end, + export = function(obj) return obj.reflow:octet():base64() end + }, + bitcoin = { + import = function(obj) return schema_get(obj, 'bitcoin', BTC.wif_to_sk, O.from_base58) end, + export = function(obj) return O.to_base58(BTC.sk_to_wif(obj.bitcoin, 'bitcoin')) end + }, + testnet = { + import = function(obj) return schema_get(obj, 'testnet', BTC.wif_to_sk, O.from_base58) end, + export = function(obj) return O.to_base58(BTC.sk_to_wif(obj.testnet, 'testnet')) end + }, + ethereum = { + import = function(obj) return schema_get(obj, 'ethereum', nop, O.from_hex) end, + export = function(obj) return obj.ethereum:octet():hex() end + }, + dilithium = { + import = function(obj) return schema_get(obj, 'dilithium', dilithium_f, O.from_base64) end, + export = function(obj) return obj.dilithium:octet():base64() end + }, + mayo = { + import = function(obj) return schema_get(obj, 'mayo', mayo_f, O.from_base64) end, + export = function(obj) return obj.mayo:octet():base64() end + }, + mldsa44 = { + import = function(obj) return schema_get(obj, 'mldsa44', mldsa44_f, O.from_base64) end, + export = function(obj) return obj.mldsa44:octet():base64() end + }, + schnorr = { + import = function(obj) return schema_get(obj, 'schnorr', nop, O.from_base64) end, + export = function(obj) return obj.schnorr:octet():base64() end + }, + kyber = { + import = function(obj) return schema_get(obj, 'kyber', kyber_f, O.from_base64) end, + export = function(obj) return obj.kyber:octet():base64() end + }, + mlkem512 = { + import = function(obj) return schema_get(obj, 'mlkem512', mlkem512_f, O.from_base64) end, + export = function(obj) return obj.mlkem512:octet():base64() end + }, + rsa = { + import = function(obj) return schema_get(obj, 'rsa', rsa_f, O.from_base64) end, + export = function(obj) return obj.rsa:octet():base64() end + }, + ntrup = { + import = function(obj) return schema_get(obj, 'ntrup', ntrup_f, O.from_base64) end, + export = function(obj) return obj.ntrup:octet():base64() end + }, + eddsa = { + import = function(obj) return schema_get(obj, 'eddsa', nop, O.from_base58) end, + export = function(obj) return obj.eddsa:octet():base58() end + }, + fsp = { + import = function(obj) return schema_get(obj, 'fsp', nop, O.from_base64) end, + export = function(obj) return obj.fsp:octet():base64() end + } +} + +local function import_keyring(obj) + local res = {} + for k,_ in pairs(obj) do + local t = keytypes[k] + if not t then + error("Unsupported key type found in keyring: "..k, 2) + end + res[k] = t.import(obj) + end + return res +end + +-- used in zencode_then directly +function export_keyring(obj) + local res = {} + for k,_ in pairs(obj) do + local t = keytypes[k] + if not t then + error("Unsupported key type found in keyring: "..k, 2) + end + res[k] = t.export(obj) + end + return res +end + +ZEN:add_schema( + { + keyring = { + import = import_keyring, + export = export_keyring + } + } +) + +When("create keyring", function() + empty'keyring' + initkeyring() +end) + +-- UTILS global functions + +-- check various locations to find the public key +-- algo can be one of dilithium, keyber, eddsa +-- Given I have a 's' from 't' --> ACK.s[t] +function load_pubkey_compat(_key, algo) + local pubkey = ACK[_key] + if pubkey then return pubkey end + pubkey = ACK[algo..'_public_key'] + if luatype(pubkey) == 'table' then + pubkey = pubkey[_key] + end + if not pubkey then + error('Public key not found for: ' .. _key, 2) + end + return pubkey +end + +function havekey(ktype) + local kname = uscore(ktype) + if not keytypes[kname] then + error('Unknown key type: ' .. ktype, 2) + end + -- check that keys exist and are a table + initkeyring() + local res = ACK.keyring[kname] + if not res then + error('Key not found: ' .. ktype, 2) + end + return res + end + + -- keyring initialization +function initkeyring(ktype) + if not ACK.keyring then + ACK.keyring = {} + new_codec('keyring') + end + if luatype(ACK.keyring) ~= 'table' then + error('Keyring table is corrupted', 2) + end + -- TODO: check that curve types match + -- if ktype is specified then check overwriting + if ktype and ACK.keyring[uscore(ktype)] then + error('Cannot overwrite existing key: ' .. ktype, 2) + end +end From 3330eca43c4a73fbaf422e47e32099e5220352cc Mon Sep 17 00:00:00 2001 From: ms8421ms <109365501+ms8421ms@users.noreply.github.com> Date: Fri, 13 Mar 2026 22:23:18 +0100 Subject: [PATCH 08/19] chore: included mayo in lua_modules.c --- build/lua_modules.c | 264 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 264 insertions(+) create mode 100644 build/lua_modules.c diff --git a/build/lua_modules.c b/build/lua_modules.c new file mode 100644 index 000000000..80982238d --- /dev/null +++ b/build/lua_modules.c @@ -0,0 +1,264 @@ +/* Zenroom (DECODE project) + * + * (c) Copyright 2017-2026 Dyne.org foundation + * designed, written and maintained by Denis Roio + * + * This source code is free software; you can redistribute it and/or + * modify it under the terms of the GNU Public License as published + * by the Free Software Foundation; either version 3 of the License, + * or (at your option) any later version. + * + * This source code is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * Please refer to the GNU Public License for more details. + * + * You should have received a copy of the GNU Public License along with + * this source code; if not, write to: + * Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +// defined in lua_shims.c +#ifdef __EMSCRIPTEN__ +#include +LUALIB_API int (luaL_loadfilex) (lua_State *L, const char *filename, const char *mode); +#define luaL_loadfile(L,f) luaL_loadfilex(L,f,NULL) +#endif + +extern int lualibs_load_all_detected(lua_State *L); + +// from lualibs_detected (generated by make embed-lua) +extern zen_extension_t zen_extensions[]; +// extern unsigned char zen_lua_init[]; +// extern unsigned int zen_lua_init_len; + +// extern int luaopen_crypto(lua_State *L); +extern int luaopen_octet(lua_State *L); +extern int luaopen_bbs(lua_State *L); +extern int luaopen_rsa(lua_State *L); +extern int luaopen_ecdh(lua_State *L); +extern int luaopen_aes(lua_State *L); +extern int luaopen_ecp(lua_State *L); +extern int luaopen_ecp2(lua_State *L); +extern int luaopen_fp12(lua_State *L); +extern int luaopen_big(lua_State *L); +extern int luaopen_hash(lua_State *L); +extern int luaopen_float(lua_State *L); +extern int luaopen_time(lua_State *L); +extern int luaopen_qp(lua_State *L); +extern int luaopen_ed(lua_State *L); +extern int luaopen_p256(lua_State *L); +extern int luaopen_x509(lua_State *L); +extern int luaopen_varint(lua_State *L); +extern int luaopen_longfellow(lua_State *L); +extern int luaopen_zkcore(lua_State *L); +extern int luaopen_mayo(lua_State *L); + +// really loaded in lib/lua54/linit.c +// always align here for correct reference +static const luaL_Reg loadedlibs[] = { + {LUA_GNAME, luaopen_base}, + {LUA_COLIBNAME, luaopen_coroutine}, + {LUA_TABLIBNAME, luaopen_table}, + {LUA_IOLIBNAME, luaopen_io}, + {LUA_OSLIBNAME, luaopen_os}, + {LUA_STRLIBNAME, luaopen_string}, + {LUA_MATHLIBNAME, luaopen_math}, + {LUA_UTF8LIBNAME, luaopen_utf8}, + {LUA_DBLIBNAME, luaopen_debug}, + {NULL, NULL} +}; + + + +int zen_load_string(lua_State *L, const char *code, + size_t size, const char *name) { + int res; +#ifdef LUA_COMPILED + res = luaL_loadbufferx(L,code,size,name,"b"); +#else + res = luaL_loadbufferx(L,code,size,name,NULL); +#endif + switch (res) { + case LUA_OK: { // func(L, "%s OK %s",__func__,name); + break; } + case LUA_ERRSYNTAX: { zerror(L, "%s syntax error: %s", __func__, name); break; } + case LUA_ERRMEM: { zerror(L, "%s out of memory: %s", __func__, name); break; } +// removed in lua 5.4 +#if 0 + case LUA_ERRGCMM: { + zerror(L, "%s garbage collection error: %s", __func__, name); + break; + } +#endif + } + return(res); +} + +HEDLEY_NON_NULL(1,2) +int zen_exec_extension(lua_State *L, zen_extension_t *p) { +#ifdef __EMSCRIPTEN__ + if(p->code) { + // HEREs(p->code); + if(luaL_loadfile(L, p->code)==0) { + if(lua_pcall(L, 0, LUA_MULTRET, 0) == LUA_OK) { + func(L,"loaded %s", p->name); + return 1; + } + } + } +#else + if(zen_load_string(L, p->code, *p->size, p->name) + ==LUA_OK) { + // func(L,"%s %s", __func__, p->name); + // HEREn(*p->size); + // HEREp(p->code); + lua_call(L,0,1); + func(L,"loaded %s", p->name); + return 1; + } +#endif + zerror(L, "%s", lua_tostring(L, -1)); + lerror(L, "%s %s", __func__, p->name); // quits with SIGABRT + fflush(stderr); + return 0; +} + +int nop(lua_State *L) { + lerror(L,"illegal instruction: require"); + return 0; } + +#ifndef S_SPLINT_S +// src/lua_modules.c:139:15: Parse Error. Attempting to continue. + +HEDLEY_NON_NULL(1) +int zen_require(lua_State *L) { + size_t len; + const char *s = lua_tolstring(L, 1, &len); + // HEREs(s); + if(!s) return 0; + // require classic lua libs + const luaL_Reg *ll; + for (ll = loadedlibs; ll->name != NULL; ++ll) { + if (strcmp(ll->name, s) == 0) { + luaL_requiref(L, ll->name, ll->func, 1); + return 1; + } + } + // SAFE(zen_extensions); + zen_extension_t *p; + // require our own lua extensions (generated by embed-lua) + for (p = zen_extensions; + p->name != NULL; ++p) { + // skip init (called as last) + if (strcasecmp(p->name, s) == 0) { + return zen_exec_extension(L,p); + } + } + + // require our own C to lua extensions + if(strcasecmp(s, "octet") ==0) { + luaL_requiref(L, s, luaopen_octet, 1); } + else if(strcmp(s, "rsa") ==0) { + luaL_requiref(L, s, luaopen_rsa, 1); return 1; } + else if(strcasecmp(s, "ecdh") ==0) { + luaL_requiref(L, s, luaopen_ecdh, 1); } + else if(strcasecmp(s, "aes") ==0) { + luaL_requiref(L, s, luaopen_aes, 1); } + else if(strcasecmp(s, "ecp") ==0) { + luaL_requiref(L, s, luaopen_ecp, 1); } + else if(strcasecmp(s, "ecp2") ==0) { + luaL_requiref(L, s, luaopen_ecp2, 1); } + else if(strcasecmp(s, "big") ==0) { + luaL_requiref(L, s, luaopen_big, 1); } + else if(strcasecmp(s, "float") ==0) { + luaL_requiref(L, s, luaopen_float, 1); } + else if(strcasecmp(s, "time") ==0) { + luaL_requiref(L, s, luaopen_time, 1); } + else if(strcasecmp(s, "fp12") ==0) { + luaL_requiref(L, s, luaopen_fp12, 1); } + else if(strcasecmp(s, "hash") ==0) { + luaL_requiref(L, s, luaopen_hash, 1); } + else if(strcasecmp(s, "qp") ==0) { + luaL_requiref(L, s, luaopen_qp, 1); } + else if(strcasecmp(s, "ed") ==0) { + luaL_requiref(L, s, luaopen_ed, 1); } + else if(strcasecmp(s, "es256") ==0) { + luaL_requiref(L, s, luaopen_p256, 1); } + else if(strcasecmp(s, "bbs") ==0) { + luaL_requiref(L, s, luaopen_bbs, 1); } + else if(strcasecmp(s, "x509") ==0) { + luaL_requiref(L, s, luaopen_x509, 1); } + else if(strcasecmp(s, "varint") ==0) { + luaL_requiref(L, s, luaopen_varint, 1); } + else if(strcasecmp(s, "longfellow") ==0) { + luaL_requiref(L, s, luaopen_longfellow, 1); } + else if(strcasecmp(s, "zkcore") ==0) { + luaL_requiref(L, s, luaopen_zkcore, 1); } + else if(strcasecmp(s, "mayo") ==0) { + luaL_requiref(L, s, luaopen_mayo, 1); } + else { + // shall we bail out and abort execution here? + warning(L, "required extension not found: %s", s); + return 0; } + func(L,"loaded %s",s); + return 1; +} + + +int zen_exitcode(lua_State *L) { + int tn; + lua_Number n = lua_tonumberx(L,1,&tn); + Z(L); + if(tn) + Z->exitcode = (int)n; + else + Z->exitcode = ERR_GENERIC; + return 0; +} + +int zen_require_override(lua_State *L, const int restricted) { + static const struct luaL_Reg custom_require [] = + { {"exitcode", zen_exitcode }, + {"require", zen_require }, + {NULL, NULL} }; + static const struct luaL_Reg custom_require_restricted [] = + { {"exitcode", zen_exitcode }, + {"require", nop }, + {NULL, NULL} }; + + lua_getglobal(L, "_G"); + if(restricted) + luaL_setfuncs(L, custom_require_restricted, 0); + else + luaL_setfuncs(L, custom_require, 0); + + lua_pop(L, 1); + return 1; +} +#endif + +// load the src/lua/init.lua +int zen_lua_init(lua_State *L) { + func(L, "loading lua initialisation"); + zen_extension_t *p; + for (p = zen_extensions; + p->name != NULL; ++p) { + if (strcasecmp(p->name, "init") == 0) + return zen_exec_extension(L,p); + } + lua_gc(L, LUA_GCCOLLECT, 0); + lerror(L,"Error loading lua init script"); + return 0; +} From 53ec0fca4f81ebefeeb175e0f74e8c96f9126fd7 Mon Sep 17 00:00:00 2001 From: ms8421ms <109365501+ms8421ms@users.noreply.github.com> Date: Fri, 13 Mar 2026 23:03:41 +0100 Subject: [PATCH 09/19] fix: lua_modules_c moved from /build to /src --- build/lua_modules.c | 264 -------------------------------------------- src/lua_modules.c | 3 + 2 files changed, 3 insertions(+), 264 deletions(-) delete mode 100644 build/lua_modules.c diff --git a/build/lua_modules.c b/build/lua_modules.c deleted file mode 100644 index 80982238d..000000000 --- a/build/lua_modules.c +++ /dev/null @@ -1,264 +0,0 @@ -/* Zenroom (DECODE project) - * - * (c) Copyright 2017-2026 Dyne.org foundation - * designed, written and maintained by Denis Roio - * - * This source code is free software; you can redistribute it and/or - * modify it under the terms of the GNU Public License as published - * by the Free Software Foundation; either version 3 of the License, - * or (at your option) any later version. - * - * This source code is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. - * Please refer to the GNU Public License for more details. - * - * You should have received a copy of the GNU Public License along with - * this source code; if not, write to: - * Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. - */ - -#include -#include -#include -#include -#include -#include -#include - -#include -#include - -// defined in lua_shims.c -#ifdef __EMSCRIPTEN__ -#include -LUALIB_API int (luaL_loadfilex) (lua_State *L, const char *filename, const char *mode); -#define luaL_loadfile(L,f) luaL_loadfilex(L,f,NULL) -#endif - -extern int lualibs_load_all_detected(lua_State *L); - -// from lualibs_detected (generated by make embed-lua) -extern zen_extension_t zen_extensions[]; -// extern unsigned char zen_lua_init[]; -// extern unsigned int zen_lua_init_len; - -// extern int luaopen_crypto(lua_State *L); -extern int luaopen_octet(lua_State *L); -extern int luaopen_bbs(lua_State *L); -extern int luaopen_rsa(lua_State *L); -extern int luaopen_ecdh(lua_State *L); -extern int luaopen_aes(lua_State *L); -extern int luaopen_ecp(lua_State *L); -extern int luaopen_ecp2(lua_State *L); -extern int luaopen_fp12(lua_State *L); -extern int luaopen_big(lua_State *L); -extern int luaopen_hash(lua_State *L); -extern int luaopen_float(lua_State *L); -extern int luaopen_time(lua_State *L); -extern int luaopen_qp(lua_State *L); -extern int luaopen_ed(lua_State *L); -extern int luaopen_p256(lua_State *L); -extern int luaopen_x509(lua_State *L); -extern int luaopen_varint(lua_State *L); -extern int luaopen_longfellow(lua_State *L); -extern int luaopen_zkcore(lua_State *L); -extern int luaopen_mayo(lua_State *L); - -// really loaded in lib/lua54/linit.c -// always align here for correct reference -static const luaL_Reg loadedlibs[] = { - {LUA_GNAME, luaopen_base}, - {LUA_COLIBNAME, luaopen_coroutine}, - {LUA_TABLIBNAME, luaopen_table}, - {LUA_IOLIBNAME, luaopen_io}, - {LUA_OSLIBNAME, luaopen_os}, - {LUA_STRLIBNAME, luaopen_string}, - {LUA_MATHLIBNAME, luaopen_math}, - {LUA_UTF8LIBNAME, luaopen_utf8}, - {LUA_DBLIBNAME, luaopen_debug}, - {NULL, NULL} -}; - - - -int zen_load_string(lua_State *L, const char *code, - size_t size, const char *name) { - int res; -#ifdef LUA_COMPILED - res = luaL_loadbufferx(L,code,size,name,"b"); -#else - res = luaL_loadbufferx(L,code,size,name,NULL); -#endif - switch (res) { - case LUA_OK: { // func(L, "%s OK %s",__func__,name); - break; } - case LUA_ERRSYNTAX: { zerror(L, "%s syntax error: %s", __func__, name); break; } - case LUA_ERRMEM: { zerror(L, "%s out of memory: %s", __func__, name); break; } -// removed in lua 5.4 -#if 0 - case LUA_ERRGCMM: { - zerror(L, "%s garbage collection error: %s", __func__, name); - break; - } -#endif - } - return(res); -} - -HEDLEY_NON_NULL(1,2) -int zen_exec_extension(lua_State *L, zen_extension_t *p) { -#ifdef __EMSCRIPTEN__ - if(p->code) { - // HEREs(p->code); - if(luaL_loadfile(L, p->code)==0) { - if(lua_pcall(L, 0, LUA_MULTRET, 0) == LUA_OK) { - func(L,"loaded %s", p->name); - return 1; - } - } - } -#else - if(zen_load_string(L, p->code, *p->size, p->name) - ==LUA_OK) { - // func(L,"%s %s", __func__, p->name); - // HEREn(*p->size); - // HEREp(p->code); - lua_call(L,0,1); - func(L,"loaded %s", p->name); - return 1; - } -#endif - zerror(L, "%s", lua_tostring(L, -1)); - lerror(L, "%s %s", __func__, p->name); // quits with SIGABRT - fflush(stderr); - return 0; -} - -int nop(lua_State *L) { - lerror(L,"illegal instruction: require"); - return 0; } - -#ifndef S_SPLINT_S -// src/lua_modules.c:139:15: Parse Error. Attempting to continue. - -HEDLEY_NON_NULL(1) -int zen_require(lua_State *L) { - size_t len; - const char *s = lua_tolstring(L, 1, &len); - // HEREs(s); - if(!s) return 0; - // require classic lua libs - const luaL_Reg *ll; - for (ll = loadedlibs; ll->name != NULL; ++ll) { - if (strcmp(ll->name, s) == 0) { - luaL_requiref(L, ll->name, ll->func, 1); - return 1; - } - } - // SAFE(zen_extensions); - zen_extension_t *p; - // require our own lua extensions (generated by embed-lua) - for (p = zen_extensions; - p->name != NULL; ++p) { - // skip init (called as last) - if (strcasecmp(p->name, s) == 0) { - return zen_exec_extension(L,p); - } - } - - // require our own C to lua extensions - if(strcasecmp(s, "octet") ==0) { - luaL_requiref(L, s, luaopen_octet, 1); } - else if(strcmp(s, "rsa") ==0) { - luaL_requiref(L, s, luaopen_rsa, 1); return 1; } - else if(strcasecmp(s, "ecdh") ==0) { - luaL_requiref(L, s, luaopen_ecdh, 1); } - else if(strcasecmp(s, "aes") ==0) { - luaL_requiref(L, s, luaopen_aes, 1); } - else if(strcasecmp(s, "ecp") ==0) { - luaL_requiref(L, s, luaopen_ecp, 1); } - else if(strcasecmp(s, "ecp2") ==0) { - luaL_requiref(L, s, luaopen_ecp2, 1); } - else if(strcasecmp(s, "big") ==0) { - luaL_requiref(L, s, luaopen_big, 1); } - else if(strcasecmp(s, "float") ==0) { - luaL_requiref(L, s, luaopen_float, 1); } - else if(strcasecmp(s, "time") ==0) { - luaL_requiref(L, s, luaopen_time, 1); } - else if(strcasecmp(s, "fp12") ==0) { - luaL_requiref(L, s, luaopen_fp12, 1); } - else if(strcasecmp(s, "hash") ==0) { - luaL_requiref(L, s, luaopen_hash, 1); } - else if(strcasecmp(s, "qp") ==0) { - luaL_requiref(L, s, luaopen_qp, 1); } - else if(strcasecmp(s, "ed") ==0) { - luaL_requiref(L, s, luaopen_ed, 1); } - else if(strcasecmp(s, "es256") ==0) { - luaL_requiref(L, s, luaopen_p256, 1); } - else if(strcasecmp(s, "bbs") ==0) { - luaL_requiref(L, s, luaopen_bbs, 1); } - else if(strcasecmp(s, "x509") ==0) { - luaL_requiref(L, s, luaopen_x509, 1); } - else if(strcasecmp(s, "varint") ==0) { - luaL_requiref(L, s, luaopen_varint, 1); } - else if(strcasecmp(s, "longfellow") ==0) { - luaL_requiref(L, s, luaopen_longfellow, 1); } - else if(strcasecmp(s, "zkcore") ==0) { - luaL_requiref(L, s, luaopen_zkcore, 1); } - else if(strcasecmp(s, "mayo") ==0) { - luaL_requiref(L, s, luaopen_mayo, 1); } - else { - // shall we bail out and abort execution here? - warning(L, "required extension not found: %s", s); - return 0; } - func(L,"loaded %s",s); - return 1; -} - - -int zen_exitcode(lua_State *L) { - int tn; - lua_Number n = lua_tonumberx(L,1,&tn); - Z(L); - if(tn) - Z->exitcode = (int)n; - else - Z->exitcode = ERR_GENERIC; - return 0; -} - -int zen_require_override(lua_State *L, const int restricted) { - static const struct luaL_Reg custom_require [] = - { {"exitcode", zen_exitcode }, - {"require", zen_require }, - {NULL, NULL} }; - static const struct luaL_Reg custom_require_restricted [] = - { {"exitcode", zen_exitcode }, - {"require", nop }, - {NULL, NULL} }; - - lua_getglobal(L, "_G"); - if(restricted) - luaL_setfuncs(L, custom_require_restricted, 0); - else - luaL_setfuncs(L, custom_require, 0); - - lua_pop(L, 1); - return 1; -} -#endif - -// load the src/lua/init.lua -int zen_lua_init(lua_State *L) { - func(L, "loading lua initialisation"); - zen_extension_t *p; - for (p = zen_extensions; - p->name != NULL; ++p) { - if (strcasecmp(p->name, "init") == 0) - return zen_exec_extension(L,p); - } - lua_gc(L, LUA_GCCOLLECT, 0); - lerror(L,"Error loading lua init script"); - return 0; -} diff --git a/src/lua_modules.c b/src/lua_modules.c index d48b6c988..de438bebd 100644 --- a/src/lua_modules.c +++ b/src/lua_modules.c @@ -63,6 +63,7 @@ extern int luaopen_x509(lua_State *L); extern int luaopen_varint(lua_State *L); extern int luaopen_longfellow(lua_State *L); extern int luaopen_zkcore(lua_State *L); +extern int luaopen_mayo(lua_State *L); // really loaded in lib/lua54/linit.c // always align here for correct reference @@ -205,6 +206,8 @@ int zen_require(lua_State *L) { luaL_requiref(L, s, luaopen_longfellow, 1); } else if(strcasecmp(s, "zkcore") ==0) { luaL_requiref(L, s, luaopen_zkcore, 1); } + else if(strcasecmp(s, "mayo") ==0) { + luaL_requiref(L, s, luaopen_mayo, 1); } else { // shall we bail out and abort execution here? warning(L, "required extension not found: %s", s); From 7fdcaede1447e4afa2beef13abf571fb6b879989 Mon Sep 17 00:00:00 2001 From: ms8421ms <109365501+ms8421ms@users.noreply.github.com> Date: Fri, 13 Mar 2026 23:32:21 +0100 Subject: [PATCH 10/19] fix: moved zencode_keyring.lua from /build to /src/lua --- build/zencode_keyring.lua | 253 ------------------------------------ src/lua/zencode_keyring.lua | 10 ++ 2 files changed, 10 insertions(+), 253 deletions(-) delete mode 100644 build/zencode_keyring.lua diff --git a/build/zencode_keyring.lua b/build/zencode_keyring.lua deleted file mode 100644 index c8c9bf46f..000000000 --- a/build/zencode_keyring.lua +++ /dev/null @@ -1,253 +0,0 @@ ---[[ ---This file is part of zenroom --- ---Copyright (C) 2021-2026 Dyne.org foundation ---designed, written and maintained by Denis Roio --- ---This program is free software: you can redistribute it and/or modify ---it under the terms of the GNU Affero General Public License as ---published by the Free Software Foundation, either version 3 of the ---License, or (at your option) any later version. --- ---This program is distributed in the hope that it will be useful, ---but WITHOUT ANY WARRANTY; without even the implied warranty of ---MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ---GNU Affero General Public License for more details. --- ---You should have received a copy of the GNU Affero General Public License ---along with this program. If not, see . ---]] - - --- DESCRIPTION: Special keys schema has optional members common to --- multiple scenarios, it provides a common interface to create keys, --- verifiers and check their existance. It does not use the keys, that's --- up to the specific scenarios. One single scenario may require and use --- the same key types (one or more) as others do, for instance reflow --- uses bls and credential, petition uses credential and ecdh. - --- utils local functions -local function nop(x) return(x) end --- the length of the kyber, dilithium and ntrup keys can be found in Zenroom/src/zen_qp.c -local function dilithium_f(o) - if #o ~= 2528 then - error('Dilithium key length is not correct: '..#o, 3) - end - return o -end -local function mayo_f(o) - if #o ~= 40 then - error('Mayo key length is not correct: '..#o, 3) - end - return o -end -local function kyber_f(o) - if #o ~= 1632 then - error('Kyber key length is not correct: '..#o, 3) - end - return o -end -local function mlkem512_f(o) - if #o ~= 1632 then - error('ML-KEM-512 key length is not correct: '..#o, 3) - end - return o -end -local function ntrup_f(o) - if #o ~= 1763 then - error('Ntrup key length is not correct: '..#o, 3) - end - return o -end -local function mldsa44_f(o) - if #o ~= 2560 then - error('mldsa44 key length is not correct: '..#o, 3) - end - return o -end -local function rsa_f(o) - if #o ~= 1280 then - error('rsa key length is not correct: '..#o, 3) - end - return o -end - --- KNOWN KEY TYPES FOUND IN ACK.keyring and their import/export -local keytypes = { - ecdh = { - import = function(obj) return schema_get(obj, 'ecdh', nop, O.from_base64) end, - export = function(obj) return obj.ecdh:octet():base64() end - }, - es256 = { - import = function(obj) return schema_get(obj, 'es256', nop, O.from_base64) end, - export = function(obj) return obj.es256:octet():base64() end - }, - credential = { - import = function(obj) return schema_get(obj, 'credential', INT.new, O.from_base64) end, - export = function(obj) return obj.credential:octet():base64() end - }, - issuer = { - import = function(obj) - return { - x = schema_get(obj.issuer, 'x', INT.new, O.from_base64), - y = schema_get(obj.issuer, 'y', INT.new, O.from_base64) - } - end, - export = function(obj) return {x = obj.issuer.x:octet():base64(), y = obj.issuer.y:octet():base64()} end - }, - bbs = { - import = function(obj) return schema_get(obj, 'bbs', INT.new, O.from_base64) end, - export = function(obj) return obj.bbs:octet():base64() end - }, - bbs_shake = { - import = function(obj) return schema_get(obj, 'bbs_shake', INT.new, O.from_base64) end, - export = function(obj) return obj.bbs_shake:octet():base64() end - }, - pvss = { - import = function(obj) return schema_get(obj, 'pvss', INT.new, O.from_base64) end, - export = function(obj) return obj.pvss:octet():base64() end - }, - reflow = { - import = function(obj) return schema_get(obj, 'reflow', INT.new, O.from_base64) end, - export = function(obj) return obj.reflow:octet():base64() end - }, - bitcoin = { - import = function(obj) return schema_get(obj, 'bitcoin', BTC.wif_to_sk, O.from_base58) end, - export = function(obj) return O.to_base58(BTC.sk_to_wif(obj.bitcoin, 'bitcoin')) end - }, - testnet = { - import = function(obj) return schema_get(obj, 'testnet', BTC.wif_to_sk, O.from_base58) end, - export = function(obj) return O.to_base58(BTC.sk_to_wif(obj.testnet, 'testnet')) end - }, - ethereum = { - import = function(obj) return schema_get(obj, 'ethereum', nop, O.from_hex) end, - export = function(obj) return obj.ethereum:octet():hex() end - }, - dilithium = { - import = function(obj) return schema_get(obj, 'dilithium', dilithium_f, O.from_base64) end, - export = function(obj) return obj.dilithium:octet():base64() end - }, - mayo = { - import = function(obj) return schema_get(obj, 'mayo', mayo_f, O.from_base64) end, - export = function(obj) return obj.mayo:octet():base64() end - }, - mldsa44 = { - import = function(obj) return schema_get(obj, 'mldsa44', mldsa44_f, O.from_base64) end, - export = function(obj) return obj.mldsa44:octet():base64() end - }, - schnorr = { - import = function(obj) return schema_get(obj, 'schnorr', nop, O.from_base64) end, - export = function(obj) return obj.schnorr:octet():base64() end - }, - kyber = { - import = function(obj) return schema_get(obj, 'kyber', kyber_f, O.from_base64) end, - export = function(obj) return obj.kyber:octet():base64() end - }, - mlkem512 = { - import = function(obj) return schema_get(obj, 'mlkem512', mlkem512_f, O.from_base64) end, - export = function(obj) return obj.mlkem512:octet():base64() end - }, - rsa = { - import = function(obj) return schema_get(obj, 'rsa', rsa_f, O.from_base64) end, - export = function(obj) return obj.rsa:octet():base64() end - }, - ntrup = { - import = function(obj) return schema_get(obj, 'ntrup', ntrup_f, O.from_base64) end, - export = function(obj) return obj.ntrup:octet():base64() end - }, - eddsa = { - import = function(obj) return schema_get(obj, 'eddsa', nop, O.from_base58) end, - export = function(obj) return obj.eddsa:octet():base58() end - }, - fsp = { - import = function(obj) return schema_get(obj, 'fsp', nop, O.from_base64) end, - export = function(obj) return obj.fsp:octet():base64() end - } -} - -local function import_keyring(obj) - local res = {} - for k,_ in pairs(obj) do - local t = keytypes[k] - if not t then - error("Unsupported key type found in keyring: "..k, 2) - end - res[k] = t.import(obj) - end - return res -end - --- used in zencode_then directly -function export_keyring(obj) - local res = {} - for k,_ in pairs(obj) do - local t = keytypes[k] - if not t then - error("Unsupported key type found in keyring: "..k, 2) - end - res[k] = t.export(obj) - end - return res -end - -ZEN:add_schema( - { - keyring = { - import = import_keyring, - export = export_keyring - } - } -) - -When("create keyring", function() - empty'keyring' - initkeyring() -end) - --- UTILS global functions - --- check various locations to find the public key --- algo can be one of dilithium, keyber, eddsa --- Given I have a 's' from 't' --> ACK.s[t] -function load_pubkey_compat(_key, algo) - local pubkey = ACK[_key] - if pubkey then return pubkey end - pubkey = ACK[algo..'_public_key'] - if luatype(pubkey) == 'table' then - pubkey = pubkey[_key] - end - if not pubkey then - error('Public key not found for: ' .. _key, 2) - end - return pubkey -end - -function havekey(ktype) - local kname = uscore(ktype) - if not keytypes[kname] then - error('Unknown key type: ' .. ktype, 2) - end - -- check that keys exist and are a table - initkeyring() - local res = ACK.keyring[kname] - if not res then - error('Key not found: ' .. ktype, 2) - end - return res - end - - -- keyring initialization -function initkeyring(ktype) - if not ACK.keyring then - ACK.keyring = {} - new_codec('keyring') - end - if luatype(ACK.keyring) ~= 'table' then - error('Keyring table is corrupted', 2) - end - -- TODO: check that curve types match - -- if ktype is specified then check overwriting - if ktype and ACK.keyring[uscore(ktype)] then - error('Cannot overwrite existing key: ' .. ktype, 2) - end -end diff --git a/src/lua/zencode_keyring.lua b/src/lua/zencode_keyring.lua index 02e95ec10..c8c9bf46f 100644 --- a/src/lua/zencode_keyring.lua +++ b/src/lua/zencode_keyring.lua @@ -35,6 +35,12 @@ local function dilithium_f(o) end return o end +local function mayo_f(o) + if #o ~= 40 then + error('Mayo key length is not correct: '..#o, 3) + end + return o +end local function kyber_f(o) if #o ~= 1632 then error('Kyber key length is not correct: '..#o, 3) @@ -121,6 +127,10 @@ local keytypes = { import = function(obj) return schema_get(obj, 'dilithium', dilithium_f, O.from_base64) end, export = function(obj) return obj.dilithium:octet():base64() end }, + mayo = { + import = function(obj) return schema_get(obj, 'mayo', mayo_f, O.from_base64) end, + export = function(obj) return obj.mayo:octet():base64() end + }, mldsa44 = { import = function(obj) return schema_get(obj, 'mldsa44', mldsa44_f, O.from_base64) end, export = function(obj) return obj.mldsa44:octet():base64() end From af5dac4e3b2f5a7258a6c0b9f6f4a12ac99cfb50 Mon Sep 17 00:00:00 2001 From: ms8421ms <109365501+ms8421ms@users.noreply.github.com> Date: Mon, 16 Mar 2026 12:05:13 +0100 Subject: [PATCH 11/19] fix: rename dilithium_signature_f to mayo_signature_f --- src/lua/zencode_mayo.lua | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/lua/zencode_mayo.lua b/src/lua/zencode_mayo.lua index b2b8d5907..00ff9b273 100644 --- a/src/lua/zencode_mayo.lua +++ b/src/lua/zencode_mayo.lua @@ -9,7 +9,7 @@ local function mayo_public_key_f(obj) return res end -local function dilithium_signature_f(obj) +local function mayo_signature_f(obj) local res = schema_get(obj, '.') zencode_assert( mayo.signature_check(res), @@ -21,7 +21,7 @@ end ZEN:add_schema( { mayo_public_key = {import=mayo_public_key_f}, - mayo_signature = {import=dilithium_signature_f} + mayo_signature = {import=mayo_signature_f} } ) @@ -54,4 +54,4 @@ IfWhen("verify '' has a mayo signature in '' by ''",function(msg, sig, by) mayo.verify(pk, s, zencode_serialize(m)), 'The mayo signature by '..by..' is not authentic' ) -end) \ No newline at end of file +end) From c2979ecba7d6343c99b44f6be87ef69eeae82866 Mon Sep 17 00:00:00 2001 From: matteo-cristino Date: Tue, 17 Mar 2026 10:09:33 +0100 Subject: [PATCH 12/19] chore: reuse compliant --- REUSE.toml | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/REUSE.toml b/REUSE.toml index f8fb6bcc7..5a092ecf0 100644 --- a/REUSE.toml +++ b/REUSE.toml @@ -77,3 +77,8 @@ precedence = "aggregate" SPDX-FileCopyrightText = "Copyright (c) 2025 Google LLC." SPDX-License-Identifier = "Apache-2.0" +[[annotations]] +path = ["lib/mayo/**"] +precedence = "override" +SPDX-FileCopyrightText = "Copyright (c) MAYO-C authors" +SPDX-License-Identifier = "Apache-2.0 AND MIT" From 8008ffe4495e990ec2d3c39a0a4126d5e46cef7c Mon Sep 17 00:00:00 2001 From: ms8421ms <109365501+ms8421ms@users.noreply.github.com> Date: Tue, 17 Mar 2026 10:22:12 +0100 Subject: [PATCH 13/19] fix: add sk_to_pk function and rename mayo class functions --- lib/mayo/mayo.c | 62 ++++++++++++++++++++++++++++ lib/mayo/mayo.h | 19 +++++++++ src/lua/zencode_mayo.lua | 44 +++++++++++++++----- src/zen_mayo.c | 74 +++++++++++++++++++++++++--------- test/lua/mayo.lua | 2 +- test/vectors/check_mayo.lua | 2 +- test/zencode/generic_mayo.bats | 56 ++++++++++++++++++------- 7 files changed, 215 insertions(+), 44 deletions(-) diff --git a/lib/mayo/mayo.c b/lib/mayo/mayo.c index e3c8f2f3a..5ac21d4ef 100644 --- a/lib/mayo/mayo.c +++ b/lib/mayo/mayo.c @@ -605,6 +605,68 @@ int mayo_keypair_compact(const mayo_params_t *p, unsigned char *cpk, return ret; } +//// ADDED FOR ZENROOM INTEGRATION + +// To derive the compact public key from the compact private key +int mayo_derive_cpk(const mayo_params_t *p, unsigned char *cpk, + const unsigned char *csk) { + int ret = MAYO_OK; + const unsigned char *seed_sk = csk; + unsigned char S[PK_SEED_BYTES_MAX + O_BYTES_MAX]; + uint64_t P[P1_LIMBS_MAX + P2_LIMBS_MAX]; + uint64_t P3[O_MAX*O_MAX*M_VEC_LIMBS_MAX] = {0}; + + unsigned char *seed_pk; + unsigned char O[(V_MAX)*O_MAX]; + + const int m_vec_limbs = PARAM_m_vec_limbs(p); + const int param_m = PARAM_m(p); + const int param_v = PARAM_v(p); + const int param_o = PARAM_o(p); + const int param_O_bytes = PARAM_O_bytes(p); + const int param_P1_limbs = PARAM_P1_limbs(p); + const int param_P3_limbs = PARAM_P3_limbs(p); + const int param_pk_seed_bytes = PARAM_pk_seed_bytes(p); + const int param_sk_seed_bytes = PARAM_sk_seed_bytes(p); + + uint64_t *P1 = P; + uint64_t *P2 = P + param_P1_limbs; + + // S ← shake256(seedsk, pk seed bytes + O bytes) + shake256(S, param_pk_seed_bytes + param_O_bytes, seed_sk, + param_sk_seed_bytes); + // seed_pk ← s[0 : pk_seed_bytes] + seed_pk = S; + + // o ← Decode_o(s[pk_seed_bytes : pk_seed_bytes + o_bytes]) + decode(S + param_pk_seed_bytes, O, param_v * param_o); + +#ifdef ENABLE_CT_TESTING + VALGRIND_MAKE_MEM_DEFINED(seed_pk, param_pk_seed_bytes); +#endif + + expand_P1_P2(p, P, seed_pk); + + // compute P3 (modifies P2 in the process) + compute_P3(p, P1, P2, O, P3); + + // store seed_pk in cpk + memcpy(cpk, seed_pk, param_pk_seed_bytes); + + uint64_t P3_upper[P3_LIMBS_MAX]; + + // compute Upper(P3) and store in cpk + m_upper(p, P3, P3_upper, param_o); + pack_m_vecs(P3_upper, cpk + param_pk_seed_bytes, param_P3_limbs/m_vec_limbs, param_m); + + mayo_secure_clear(O, sizeof(O)); + mayo_secure_clear(P2, PARAM_P2_limbs(p)*sizeof(uint64_t)); + mayo_secure_clear(P3, sizeof(P3)); + return ret; +} + +//// + int mayo_expand_pk(const mayo_params_t *p, const unsigned char *cpk, uint64_t *pk) { expand_P1_P2(p, pk, cpk); diff --git a/lib/mayo/mayo.h b/lib/mayo/mayo.h index 7cee7298e..8d0f13ca8 100644 --- a/lib/mayo/mayo.h +++ b/lib/mayo/mayo.h @@ -390,6 +390,25 @@ int mayo_open(const mayo_params_t *p, unsigned char *m, int mayo_keypair_compact(const mayo_params_t *p, unsigned char *cpk, unsigned char *csk); +//// ADDED FOR ZENROOM INTEGRATION + +/** + * Mayo derive compact public key from compact secret key. + * + * Deterministically generates the compacted public key from an existing + * compacted secret key (seed). + * + * @param[in] p Mayo parameter set + * @param[out] cpk Mayo compacted public key + * @param[in] csk Mayo compacted secret key (read-only) + * @return int status code + */ +#define mayo_derive_cpk MAYO_NAMESPACE(mayo_derive_cpk) +int mayo_derive_cpk(const mayo_params_t *p, unsigned char *cpk, + const unsigned char *csk); + +//// + /** * Mayo expand public key. * diff --git a/src/lua/zencode_mayo.lua b/src/lua/zencode_mayo.lua index 00ff9b273..3f8844417 100644 --- a/src/lua/zencode_mayo.lua +++ b/src/lua/zencode_mayo.lua @@ -3,7 +3,7 @@ local mayo = require 'mayo' local function mayo_public_key_f(obj) local res = schema_get(obj, '.') zencode_assert( - mayo.sigpubcheck(res), + mayo.pubcheck(res), 'MAYO public key length is not correct' ) return res @@ -27,14 +27,40 @@ ZEN:add_schema( --# MAYO #-- --- generate the keypair -When("create mayo key pair",function() +-- generate the private key +When("create mayo key",function() initkeyring'mayo' - empty'mayo public key' - local keys = mayo.sigkeygen() - ACK.keyring.mayo = keys.private - ACK.mayo_public_key = keys.public - new_codec('mayo public key') + ACK.keyring.mayo = mayo.secgen() +end) + +-- generate the public key +When("create mayo public key",function() + empty'mayo public key' + local sk = havekey'mayo' + ACK.mayo_public_key = mayo.pubgen(sk) + new_codec('mayo public key') +end) + +local function _pubkey_from_secret(sec) + local sk = have(sec) + initkeyring'mayo' + mayo.pubgen(sk) + ACK.keyring.mayo = sk +end + +When("create mayo key with secret key ''", + _pubkey_from_secret +) + +When("create mayo key with secret ''", + _pubkey_from_secret +) + +When("create mayo public key with secret key ''",function(sec) + local sk = have(sec) + empty'mayo public key' + ACK.mayo_public_key = mayo.pubgen(sk) + new_codec('mayo public key') end) -- generate the sign for a msg and verify @@ -54,4 +80,4 @@ IfWhen("verify '' has a mayo signature in '' by ''",function(msg, sig, by) mayo.verify(pk, s, zencode_serialize(m)), 'The mayo signature by '..by..' is not authentic' ) -end) +end) \ No newline at end of file diff --git a/src/zen_mayo.c b/src/zen_mayo.c index 7d5b30f55..15ee7f625 100644 --- a/src/zen_mayo.c +++ b/src/zen_mayo.c @@ -8,30 +8,63 @@ #define MAYO_BUILD_TYPE_REF 1 #include "api.h" +#include "mayo.h" -static int zen_mayo_keygen(lua_State *L) { +static int zen_mayo_secgen(lua_State *L) { + BEGIN(); + Z(L); + register const size_t sksize = CRYPTO_SECRETKEYBYTES; + octet *sk = o_new(L, sksize); SAFE(sk, "Could not create secret key"); + register size_t i; + for(i=0; i < sksize; i++) + sk->val[i] = RAND_byte(Z->random_generator); + sk->len = sksize; + END(1); +} + +static int zen_mayo_pubgen(lua_State *L) { BEGIN(); char *failed_msg = NULL; - lua_createtable(L, 0, 2); + octet *pk = NULL, *sk = NULL; + sk = o_arg(L, 1); SAFE_GOTO(sk, "Could not allocate secret key"); + SAFE_GOTO(sk->len == CRYPTO_SECRETKEYBYTES, "Invalid size for MAYO_5 secret key"); + pk = o_new(L, CRYPTO_PUBLICKEYBYTES); SAFE_GOTO(pk, "Could not create public key"); + pk->len = CRYPTO_PUBLICKEYBYTES; + + // params = NULL if compiling with ENABLE_PARAMS_DYNAMIC off (static) + mayo_derive_cpk(NULL, (unsigned char*)pk->val, (const unsigned char*)sk->val); +end: + o_free(L, sk); + if(failed_msg) { + THROW(failed_msg); + } + END(1); +} + +// For generating directly the keypair (as in Dilithium) +// static int zen_mayo_keygen(lua_State *L) { +// BEGIN(); +// char *failed_msg = NULL; +// lua_createtable(L, 0, 2); - int sk_len = CRYPTO_SECRETKEYBYTES; - int pk_len = CRYPTO_PUBLICKEYBYTES; +// int sk_len = CRYPTO_SECRETKEYBYTES; +// int pk_len = CRYPTO_PUBLICKEYBYTES; - octet *private = o_new(L, sk_len); SAFE_GOTO(private, "Could not create private key"); - lua_setfield(L, -2, "private"); - octet *public = o_new(L, pk_len); SAFE_GOTO(public, "Could not create public key"); - lua_setfield(L, -2, "public"); +// octet *private = o_new(L, sk_len); SAFE_GOTO(private, "Could not create private key"); +// lua_setfield(L, -2, "private"); +// octet *public = o_new(L, pk_len); SAFE_GOTO(public, "Could not create public key"); +// lua_setfield(L, -2, "public"); - crypto_sign_keypair((unsigned char*)public->val, (unsigned char*)private->val); - public->len = pk_len; - private->len = sk_len; +// crypto_sign_keypair((unsigned char*)public->val, (unsigned char*)private->val); +// public->len = pk_len; +// private->len = sk_len; -end: - if(failed_msg) { - THROW(failed_msg); - } - END(1); -} +// end: +// if(failed_msg) { +// THROW(failed_msg); +// } +// END(1); +// } static int zen_mayo_sign(lua_State *L) { BEGIN(); @@ -171,8 +204,11 @@ static int zen_mayo_signature_check(lua_State *L) { int luaopen_mayo(lua_State *L) { const struct luaL_Reg mayo_class[] = { - {"sigkeygen", zen_mayo_keygen}, - {"sigpubcheck", zen_mayo_signature_pubcheck}, + {"keygen", zen_mayo_secgen}, + {"secgen", zen_mayo_secgen}, + {"pubgen", zen_mayo_pubgen}, + {"pubcheck", zen_mayo_signature_pubcheck}, + {"checkpub", zen_mayo_signature_pubcheck}, {"sign", zen_mayo_sign}, {"verify", zen_mayo_verify}, {"signed_msg", zen_mayo_signed_message}, diff --git a/test/lua/mayo.lua b/test/lua/mayo.lua index 6b1167308..e805f45e8 100644 --- a/test/lua/mayo.lua +++ b/test/lua/mayo.lua @@ -4,7 +4,7 @@ print() local mayo = require'mayo' -local kp = mayo.sigkeygen() +local kp = mayo.keygen() local msg = [[ Lorem ipsum dolor sit amet, consectetur adipiscing elit. diff --git a/test/vectors/check_mayo.lua b/test/vectors/check_mayo.lua index d70e79460..24622b5fc 100644 --- a/test/vectors/check_mayo.lua +++ b/test/vectors/check_mayo.lua @@ -26,7 +26,7 @@ for line in newline_iter(DATA) do if curr_fields == 5 then -- Here starts the test - assert(mayo.sigpubcheck(test.pk)) + assert(mayo.pubcheck(test.pk)) assert(mayo.signature_check(test.sm:sub(1, mayo.signature_len()))) assert(mayo.verify(test.pk, test.sm:sub(1, mayo.signature_len()), test.msg)) assert(test.msg == mayo.verified_msg(test.pk, test.sm)) diff --git a/test/zencode/generic_mayo.bats b/test/zencode/generic_mayo.bats index 6caa6ce09..aa84ce865 100644 --- a/test/zencode/generic_mayo.bats +++ b/test/zencode/generic_mayo.bats @@ -3,23 +3,52 @@ load ../bats_zencode SUBDOC=mayo @test "Generate asymmetric keys for Alice and Bob" { - cat < wrong_pubkey.zen Rule check version 2.0.0 Scenario mayo @@ -102,13 +131,12 @@ EOF @test "Alice signs a big file" { cat < bigfile.zen Rule check version 2.0.0 -Scenario mayo Given Nothing When I create the random object of '1000000' bytes and I rename 'random object' to 'bigfile' Then print the 'bigfile' as 'base64' EOF - $ZENROOM_EXECUTABLE -z bigfile.zen > bigfile.json + $ZENROOM_EXECUTABLE -z bigfile.zen > bigfile.json cat < Date: Wed, 18 Mar 2026 17:39:18 +0100 Subject: [PATCH 14/19] fix: indentation and spaces --- lib/mayo/Makefile | 2 +- lib/mayo/aes128ctr.c | 376 +++++------ lib/mayo/aes_c.c | 974 ++++++++++++++-------------- lib/mayo/aes_ctr.h | 10 +- lib/mayo/api.c | 30 +- lib/mayo/api.h | 16 +- lib/mayo/arithmetic.c | 186 +++--- lib/mayo/arithmetic.h | 50 +- lib/mayo/arithmetic_dynamic.h | 70 +- lib/mayo/arithmetic_fixed.h | 92 +-- lib/mayo/debug_bench_tools.h | 60 +- lib/mayo/echelon_form.h | 214 +++--- lib/mayo/ef_inner_loop.h | 44 +- lib/mayo/fips202.c | 1110 ++++++++++++++++---------------- lib/mayo/generic_arithmetic.h | 402 ++++++------ lib/mayo/mayo.c | 1144 ++++++++++++++++----------------- lib/mayo/mayo.h | 76 +-- lib/mayo/mem.c | 18 +- lib/mayo/params.c | 44 +- lib/mayo/simple_arithmetic.h | 148 ++--- src/lua/zencode_mayo.lua | 12 +- src/zen_mayo.c | 272 ++++---- test/vectors/check_mayo.lua | 42 +- 23 files changed, 2696 insertions(+), 2696 deletions(-) diff --git a/lib/mayo/Makefile b/lib/mayo/Makefile index 078ee16e7..fa099f955 100644 --- a/lib/mayo/Makefile +++ b/lib/mayo/Makefile @@ -10,4 +10,4 @@ libmayo.a: ${MAYO} clean: rm -f *.a - rm -f ${MAYO} \ No newline at end of file + rm -f ${MAYO} diff --git a/lib/mayo/aes128ctr.c b/lib/mayo/aes128ctr.c index 6fa736c83..9bc1ac9b0 100644 --- a/lib/mayo/aes128ctr.c +++ b/lib/mayo/aes128ctr.c @@ -12,12 +12,12 @@ // crypto_core/aes128ncrypt/dolbeau/aesenc-int // (https://bench.cr.yp.to/supercop.html) static inline void aes128ni_setkey_encrypt(const unsigned char *key, - __m128i rkeys[11]) { - __m128i key0 = _mm_loadu_si128((const __m128i *)(key + 0)); - __m128i temp0, temp1, temp4; - int idx = 0; + __m128i rkeys[11]) { + __m128i key0 = _mm_loadu_si128((const __m128i *)(key + 0)); + __m128i temp0, temp1, temp4; + int idx = 0; - temp0 = key0; + temp0 = key0; #define BLOCK1(IMM) \ temp1 = _mm_aeskeygenassist_si128(temp0, IMM); \ @@ -29,57 +29,57 @@ static inline void aes128ni_setkey_encrypt(const unsigned char *key, temp1 = _mm_shuffle_epi32(temp1, 0xff); \ temp0 = _mm_xor_si128(temp0, temp1) - BLOCK1(0x01); - BLOCK1(0x02); - BLOCK1(0x04); - BLOCK1(0x08); - BLOCK1(0x10); - BLOCK1(0x20); - BLOCK1(0x40); - BLOCK1(0x80); - BLOCK1(0x1b); - BLOCK1(0x36); - rkeys[idx++] = temp0; + BLOCK1(0x01); + BLOCK1(0x02); + BLOCK1(0x04); + BLOCK1(0x08); + BLOCK1(0x10); + BLOCK1(0x20); + BLOCK1(0x40); + BLOCK1(0x80); + BLOCK1(0x1b); + BLOCK1(0x36); + rkeys[idx++] = temp0; } void oqs_aes128_load_schedule_ni(const uint8_t *key, void **_schedule) { - *_schedule = malloc(11 * sizeof(__m128i)); - // assert(*_schedule != NULL); - __m128i *schedule = (__m128i *)*_schedule; - aes128ni_setkey_encrypt(key, schedule); + *_schedule = malloc(11 * sizeof(__m128i)); + // assert(*_schedule != NULL); + __m128i *schedule = (__m128i *)*_schedule; + aes128ni_setkey_encrypt(key, schedule); } void oqs_aes128_free_schedule_ni(void *schedule) { - if (schedule != NULL) { - mayo_secure_free(schedule, 11 * sizeof(__m128i)); - } + if (schedule != NULL) { + mayo_secure_free(schedule, 11 * sizeof(__m128i)); + } } // Single encryption static inline void aes128ni_encrypt(const __m128i rkeys[11], __m128i nv, - unsigned char *out) { - __m128i temp = _mm_xor_si128(nv, rkeys[0]); - temp = _mm_aesenc_si128(temp, rkeys[1]); - temp = _mm_aesenc_si128(temp, rkeys[2]); - temp = _mm_aesenc_si128(temp, rkeys[3]); - temp = _mm_aesenc_si128(temp, rkeys[4]); - temp = _mm_aesenc_si128(temp, rkeys[5]); - temp = _mm_aesenc_si128(temp, rkeys[6]); - temp = _mm_aesenc_si128(temp, rkeys[7]); - temp = _mm_aesenc_si128(temp, rkeys[8]); - temp = _mm_aesenc_si128(temp, rkeys[9]); - temp = _mm_aesenclast_si128(temp, rkeys[10]); - _mm_storeu_si128((__m128i *)(out), temp); + unsigned char *out) { + __m128i temp = _mm_xor_si128(nv, rkeys[0]); + temp = _mm_aesenc_si128(temp, rkeys[1]); + temp = _mm_aesenc_si128(temp, rkeys[2]); + temp = _mm_aesenc_si128(temp, rkeys[3]); + temp = _mm_aesenc_si128(temp, rkeys[4]); + temp = _mm_aesenc_si128(temp, rkeys[5]); + temp = _mm_aesenc_si128(temp, rkeys[6]); + temp = _mm_aesenc_si128(temp, rkeys[7]); + temp = _mm_aesenc_si128(temp, rkeys[8]); + temp = _mm_aesenc_si128(temp, rkeys[9]); + temp = _mm_aesenclast_si128(temp, rkeys[10]); + _mm_storeu_si128((__m128i *)(out), temp); } // 4x interleaved encryption static inline void aes128ni_encrypt_x4(const __m128i rkeys[11], __m128i n0, - __m128i n1, __m128i n2, __m128i n3, - unsigned char *out) { - __m128i temp0 = _mm_xor_si128(n0, rkeys[0]); - __m128i temp1 = _mm_xor_si128(n1, rkeys[0]); - __m128i temp2 = _mm_xor_si128(n2, rkeys[0]); - __m128i temp3 = _mm_xor_si128(n3, rkeys[0]); + __m128i n1, __m128i n2, __m128i n3, + unsigned char *out) { + __m128i temp0 = _mm_xor_si128(n0, rkeys[0]); + __m128i temp1 = _mm_xor_si128(n1, rkeys[0]); + __m128i temp2 = _mm_xor_si128(n2, rkeys[0]); + __m128i temp3 = _mm_xor_si128(n3, rkeys[0]); #define AESNENCX4(IDX) \ temp0 = _mm_aesenc_si128(temp0, rkeys[IDX]); \ @@ -87,89 +87,89 @@ static inline void aes128ni_encrypt_x4(const __m128i rkeys[11], __m128i n0, temp2 = _mm_aesenc_si128(temp2, rkeys[IDX]); \ temp3 = _mm_aesenc_si128(temp3, rkeys[IDX]) - AESNENCX4(1); - AESNENCX4(2); - AESNENCX4(3); - AESNENCX4(4); - AESNENCX4(5); - AESNENCX4(6); - AESNENCX4(7); - AESNENCX4(8); - AESNENCX4(9); - - temp0 = _mm_aesenclast_si128(temp0, rkeys[10]); - temp1 = _mm_aesenclast_si128(temp1, rkeys[10]); - temp2 = _mm_aesenclast_si128(temp2, rkeys[10]); - temp3 = _mm_aesenclast_si128(temp3, rkeys[10]); - - _mm_storeu_si128((__m128i *)(out + 0), temp0); - _mm_storeu_si128((__m128i *)(out + 16), temp1); - _mm_storeu_si128((__m128i *)(out + 32), temp2); - _mm_storeu_si128((__m128i *)(out + 48), temp3); + AESNENCX4(1); + AESNENCX4(2); + AESNENCX4(3); + AESNENCX4(4); + AESNENCX4(5); + AESNENCX4(6); + AESNENCX4(7); + AESNENCX4(8); + AESNENCX4(9); + + temp0 = _mm_aesenclast_si128(temp0, rkeys[10]); + temp1 = _mm_aesenclast_si128(temp1, rkeys[10]); + temp2 = _mm_aesenclast_si128(temp2, rkeys[10]); + temp3 = _mm_aesenclast_si128(temp3, rkeys[10]); + + _mm_storeu_si128((__m128i *)(out + 0), temp0); + _mm_storeu_si128((__m128i *)(out + 16), temp1); + _mm_storeu_si128((__m128i *)(out + 32), temp2); + _mm_storeu_si128((__m128i *)(out + 48), temp3); } // Not for general use: IV = 0, nonce = 0 static void oqs_aes128_ctr_enc_sch_ni(const void *schedule, uint8_t *out, - size_t out_len) { - __m128i mask = - _mm_set_epi8(8, 9, 10, 11, 12, 13, 14, 15, 7, 6, 5, 4, 3, 2, 1, 0); - __m128i block = _mm_set_epi64x(0, 0); - // block = _mm_xor_si128(block, block); // set to zero - - while (out_len >= 64) { - __m128i nv0 = block; - __m128i nv1 = _mm_shuffle_epi8( - _mm_add_epi64(_mm_shuffle_epi8(block, mask), _mm_set_epi64x(1, 0)), - mask); - __m128i nv2 = _mm_shuffle_epi8( - _mm_add_epi64(_mm_shuffle_epi8(block, mask), _mm_set_epi64x(2, 0)), - mask); - __m128i nv3 = _mm_shuffle_epi8( - _mm_add_epi64(_mm_shuffle_epi8(block, mask), _mm_set_epi64x(3, 0)), - mask); - aes128ni_encrypt_x4(schedule, nv0, nv1, nv2, nv3, out); - block = _mm_shuffle_epi8( - _mm_add_epi64(_mm_shuffle_epi8(block, mask), _mm_set_epi64x(4, 0)), - mask); - out += 64; - out_len -= 64; - } - while (out_len >= 16) { - aes128ni_encrypt(schedule, block, out); - out += 16; - out_len -= 16; - block = _mm_shuffle_epi8( - _mm_add_epi64(_mm_shuffle_epi8(block, mask), _mm_set_epi64x(1, 0)), - mask); - } - if (out_len > 0) { - uint8_t tmp[16]; - aes128ni_encrypt(schedule, block, tmp); - memcpy(out, tmp, out_len); - } + size_t out_len) { + __m128i mask = + _mm_set_epi8(8, 9, 10, 11, 12, 13, 14, 15, 7, 6, 5, 4, 3, 2, 1, 0); + __m128i block = _mm_set_epi64x(0, 0); + // block = _mm_xor_si128(block, block); // set to zero + + while (out_len >= 64) { + __m128i nv0 = block; + __m128i nv1 = _mm_shuffle_epi8( + _mm_add_epi64(_mm_shuffle_epi8(block, mask), _mm_set_epi64x(1, 0)), + mask); + __m128i nv2 = _mm_shuffle_epi8( + _mm_add_epi64(_mm_shuffle_epi8(block, mask), _mm_set_epi64x(2, 0)), + mask); + __m128i nv3 = _mm_shuffle_epi8( + _mm_add_epi64(_mm_shuffle_epi8(block, mask), _mm_set_epi64x(3, 0)), + mask); + aes128ni_encrypt_x4(schedule, nv0, nv1, nv2, nv3, out); + block = _mm_shuffle_epi8( + _mm_add_epi64(_mm_shuffle_epi8(block, mask), _mm_set_epi64x(4, 0)), + mask); + out += 64; + out_len -= 64; + } + while (out_len >= 16) { + aes128ni_encrypt(schedule, block, out); + out += 16; + out_len -= 16; + block = _mm_shuffle_epi8( + _mm_add_epi64(_mm_shuffle_epi8(block, mask), _mm_set_epi64x(1, 0)), + mask); + } + if (out_len > 0) { + uint8_t tmp[16]; + aes128ni_encrypt(schedule, block, tmp); + memcpy(out, tmp, out_len); + } } int AES_128_CTR_NI(unsigned char *output, size_t outputByteLen, - const unsigned char *input, size_t inputByteLen) { - void *schedule = NULL; - oqs_aes128_load_schedule_ni(input, &schedule); - oqs_aes128_ctr_enc_sch_ni(schedule, output, outputByteLen); - oqs_aes128_free_schedule_ni(schedule); - return (int)outputByteLen; + const unsigned char *input, size_t inputByteLen) { + void *schedule = NULL; + oqs_aes128_load_schedule_ni(input, &schedule); + oqs_aes128_ctr_enc_sch_ni(schedule, output, outputByteLen); + oqs_aes128_free_schedule_ni(schedule); + return (int)outputByteLen; } // 4-Round AES... // From crypto_core/aes128ncrypt/dolbeau/aesenc-int static inline void aes128r4ni_setkey_encrypt(const unsigned char *key, - __m128i rkeys[5]) { - __m128i key0 = _mm_loadu_si128((const __m128i *)(key + 0)); - __m128i temp0, temp1, temp4; - int idx = 0; + __m128i rkeys[5]) { + __m128i key0 = _mm_loadu_si128((const __m128i *)(key + 0)); + __m128i temp0, temp1, temp4; + int idx = 0; - temp0 = key0; + temp0 = key0; - /* blockshift-based block by Cedric Bourrasset */ + /* blockshift-based block by Cedric Bourrasset */ #define BLOCK1(IMM) \ temp1 = _mm_aeskeygenassist_si128(temp0, IMM); \ rkeys[idx++] = temp0; \ @@ -180,45 +180,45 @@ static inline void aes128r4ni_setkey_encrypt(const unsigned char *key, temp1 = _mm_shuffle_epi32(temp1, 0xff); \ temp0 = _mm_xor_si128(temp0, temp1) - BLOCK1(0x01); - BLOCK1(0x02); - BLOCK1(0x04); - BLOCK1(0x08); - rkeys[idx++] = temp0; + BLOCK1(0x01); + BLOCK1(0x02); + BLOCK1(0x04); + BLOCK1(0x08); + rkeys[idx++] = temp0; } void oqs_aes128r4_load_schedule_ni(const uint8_t *key, void **_schedule) { - *_schedule = malloc(5 * sizeof(__m128i)); - // assert(*_schedule != NULL); - __m128i *schedule = (__m128i *)*_schedule; - aes128r4ni_setkey_encrypt(key, schedule); + *_schedule = malloc(5 * sizeof(__m128i)); + // assert(*_schedule != NULL); + __m128i *schedule = (__m128i *)*_schedule; + aes128r4ni_setkey_encrypt(key, schedule); } void oqs_aes128r4_free_schedule_ni(void *schedule) { - if (schedule != NULL) { - mayo_secure_free(schedule, 5 * sizeof(__m128i)); - } + if (schedule != NULL) { + mayo_secure_free(schedule, 5 * sizeof(__m128i)); + } } // Single encryption static inline void aes128r4ni_encrypt(const __m128i rkeys[5], __m128i nv, - unsigned char *out) { - __m128i temp = _mm_xor_si128(nv, rkeys[0]); - temp = _mm_aesenc_si128(temp, rkeys[1]); - temp = _mm_aesenc_si128(temp, rkeys[2]); - temp = _mm_aesenc_si128(temp, rkeys[3]); - temp = _mm_aesenclast_si128(temp, rkeys[4]); - _mm_storeu_si128((__m128i *)(out), temp); + unsigned char *out) { + __m128i temp = _mm_xor_si128(nv, rkeys[0]); + temp = _mm_aesenc_si128(temp, rkeys[1]); + temp = _mm_aesenc_si128(temp, rkeys[2]); + temp = _mm_aesenc_si128(temp, rkeys[3]); + temp = _mm_aesenclast_si128(temp, rkeys[4]); + _mm_storeu_si128((__m128i *)(out), temp); } // 4x interleaved encryption static inline void aes128r4ni_encrypt_x4(const __m128i rkeys[5], __m128i n0, - __m128i n1, __m128i n2, __m128i n3, - unsigned char *out) { - __m128i temp0 = _mm_xor_si128(n0, rkeys[0]); - __m128i temp1 = _mm_xor_si128(n1, rkeys[0]); - __m128i temp2 = _mm_xor_si128(n2, rkeys[0]); - __m128i temp3 = _mm_xor_si128(n3, rkeys[0]); + __m128i n1, __m128i n2, __m128i n3, + unsigned char *out) { + __m128i temp0 = _mm_xor_si128(n0, rkeys[0]); + __m128i temp1 = _mm_xor_si128(n1, rkeys[0]); + __m128i temp2 = _mm_xor_si128(n2, rkeys[0]); + __m128i temp3 = _mm_xor_si128(n3, rkeys[0]); #define AESNENCX4(IDX) \ temp0 = _mm_aesenc_si128(temp0, rkeys[IDX]); \ @@ -226,68 +226,68 @@ static inline void aes128r4ni_encrypt_x4(const __m128i rkeys[5], __m128i n0, temp2 = _mm_aesenc_si128(temp2, rkeys[IDX]); \ temp3 = _mm_aesenc_si128(temp3, rkeys[IDX]) - AESNENCX4(1); - AESNENCX4(2); - AESNENCX4(3); + AESNENCX4(1); + AESNENCX4(2); + AESNENCX4(3); - temp0 = _mm_aesenclast_si128(temp0, rkeys[4]); - temp1 = _mm_aesenclast_si128(temp1, rkeys[4]); - temp2 = _mm_aesenclast_si128(temp2, rkeys[4]); - temp3 = _mm_aesenclast_si128(temp3, rkeys[4]); + temp0 = _mm_aesenclast_si128(temp0, rkeys[4]); + temp1 = _mm_aesenclast_si128(temp1, rkeys[4]); + temp2 = _mm_aesenclast_si128(temp2, rkeys[4]); + temp3 = _mm_aesenclast_si128(temp3, rkeys[4]); - _mm_storeu_si128((__m128i *)(out + 0), temp0); - _mm_storeu_si128((__m128i *)(out + 16), temp1); - _mm_storeu_si128((__m128i *)(out + 32), temp2); - _mm_storeu_si128((__m128i *)(out + 48), temp3); + _mm_storeu_si128((__m128i *)(out + 0), temp0); + _mm_storeu_si128((__m128i *)(out + 16), temp1); + _mm_storeu_si128((__m128i *)(out + 32), temp2); + _mm_storeu_si128((__m128i *)(out + 48), temp3); } // Not for general use: IV = 0, nonce = 0 static void oqs_aes128r4_ctr_enc_sch_ni(const void *schedule, uint8_t *out, - size_t out_len) { - __m128i mask = - _mm_set_epi8(8, 9, 10, 11, 12, 13, 14, 15, 7, 6, 5, 4, 3, 2, 1, 0); - __m128i block = _mm_set_epi64x(0, 0); - - while (out_len >= 64) { - __m128i nv0 = block; - __m128i nv1 = _mm_shuffle_epi8( - _mm_add_epi64(_mm_shuffle_epi8(block, mask), _mm_set_epi64x(1, 0)), - mask); - __m128i nv2 = _mm_shuffle_epi8( - _mm_add_epi64(_mm_shuffle_epi8(block, mask), _mm_set_epi64x(2, 0)), - mask); - __m128i nv3 = _mm_shuffle_epi8( - _mm_add_epi64(_mm_shuffle_epi8(block, mask), _mm_set_epi64x(3, 0)), - mask); - aes128r4ni_encrypt_x4(schedule, nv0, nv1, nv2, nv3, out); - block = _mm_shuffle_epi8( - _mm_add_epi64(_mm_shuffle_epi8(block, mask), _mm_set_epi64x(4, 0)), - mask); - out += 64; - out_len -= 64; - } - while (out_len >= 16) { - aes128r4ni_encrypt(schedule, block, out); - out += 16; - out_len -= 16; - block = _mm_shuffle_epi8( - _mm_add_epi64(_mm_shuffle_epi8(block, mask), _mm_set_epi64x(1, 0)), - mask); - } - if (out_len > 0) { - uint8_t tmp[16]; - aes128r4ni_encrypt(schedule, block, tmp); - memcpy(out, tmp, out_len); - } + size_t out_len) { + __m128i mask = + _mm_set_epi8(8, 9, 10, 11, 12, 13, 14, 15, 7, 6, 5, 4, 3, 2, 1, 0); + __m128i block = _mm_set_epi64x(0, 0); + + while (out_len >= 64) { + __m128i nv0 = block; + __m128i nv1 = _mm_shuffle_epi8( + _mm_add_epi64(_mm_shuffle_epi8(block, mask), _mm_set_epi64x(1, 0)), + mask); + __m128i nv2 = _mm_shuffle_epi8( + _mm_add_epi64(_mm_shuffle_epi8(block, mask), _mm_set_epi64x(2, 0)), + mask); + __m128i nv3 = _mm_shuffle_epi8( + _mm_add_epi64(_mm_shuffle_epi8(block, mask), _mm_set_epi64x(3, 0)), + mask); + aes128r4ni_encrypt_x4(schedule, nv0, nv1, nv2, nv3, out); + block = _mm_shuffle_epi8( + _mm_add_epi64(_mm_shuffle_epi8(block, mask), _mm_set_epi64x(4, 0)), + mask); + out += 64; + out_len -= 64; + } + while (out_len >= 16) { + aes128r4ni_encrypt(schedule, block, out); + out += 16; + out_len -= 16; + block = _mm_shuffle_epi8( + _mm_add_epi64(_mm_shuffle_epi8(block, mask), _mm_set_epi64x(1, 0)), + mask); + } + if (out_len > 0) { + uint8_t tmp[16]; + aes128r4ni_encrypt(schedule, block, tmp); + memcpy(out, tmp, out_len); + } } int AES_128_CTR_4R_NI(unsigned char *output, size_t outputByteLen, - const unsigned char *input, size_t inputByteLen) { - void *schedule = NULL; - oqs_aes128r4_load_schedule_ni(input, &schedule); - oqs_aes128r4_ctr_enc_sch_ni(schedule, output, outputByteLen); - oqs_aes128r4_free_schedule_ni(schedule); - return (int)outputByteLen; + const unsigned char *input, size_t inputByteLen) { + void *schedule = NULL; + oqs_aes128r4_load_schedule_ni(input, &schedule); + oqs_aes128r4_ctr_enc_sch_ni(schedule, output, outputByteLen); + oqs_aes128r4_free_schedule_ni(schedule); + return (int)outputByteLen; } #endif diff --git a/lib/mayo/aes_c.c b/lib/mayo/aes_c.c index 8afec21ec..c54551fa4 100644 --- a/lib/mayo/aes_c.c +++ b/lib/mayo/aes_c.c @@ -42,17 +42,17 @@ // We've put these states on the heap to make sure ctx_release is used. #define PQC_AES128_STATESIZE 88 typedef struct { - uint64_t *sk_exp; + uint64_t *sk_exp; } aes128ctx; #define PQC_AES192_STATESIZE 104 typedef struct { - uint64_t *sk_exp; + uint64_t *sk_exp; } aes192ctx; #define PQC_AES256_STATESIZE 120 typedef struct { - uint64_t *sk_exp; + uint64_t *sk_exp; } aes256ctx; @@ -94,648 +94,648 @@ void aes256_ctr(unsigned char *out, size_t outlen, const unsigned char *iv, cons void aes256_ctx_release(aes256ctx *r); static inline uint32_t br_dec32le(const unsigned char *src) { - return (uint32_t)src[0] - | ((uint32_t)src[1] << 8) - | ((uint32_t)src[2] << 16) - | ((uint32_t)src[3] << 24); + return (uint32_t)src[0] + | ((uint32_t)src[1] << 8) + | ((uint32_t)src[2] << 16) + | ((uint32_t)src[3] << 24); } static void br_range_dec32le(uint32_t *v, size_t num, const unsigned char *src) { - while (num-- > 0) { - *v ++ = br_dec32le(src); - src += 4; - } + while (num-- > 0) { + *v ++ = br_dec32le(src); + src += 4; + } } static inline uint32_t br_swap32(uint32_t x) { - x = ((x & (uint32_t)0x00FF00FF) << 8) - | ((x >> 8) & (uint32_t)0x00FF00FF); - return (x << 16) | (x >> 16); + x = ((x & (uint32_t)0x00FF00FF) << 8) + | ((x >> 8) & (uint32_t)0x00FF00FF); + return (x << 16) | (x >> 16); } static inline void br_enc32le(unsigned char *dst, uint32_t x) { - dst[0] = (unsigned char)x; - dst[1] = (unsigned char)(x >> 8); - dst[2] = (unsigned char)(x >> 16); - dst[3] = (unsigned char)(x >> 24); + dst[0] = (unsigned char)x; + dst[1] = (unsigned char)(x >> 8); + dst[2] = (unsigned char)(x >> 16); + dst[3] = (unsigned char)(x >> 24); } static void br_range_enc32le(unsigned char *dst, const uint32_t *v, size_t num) { - while (num-- > 0) { - br_enc32le(dst, *v ++); - dst += 4; - } + while (num-- > 0) { + br_enc32le(dst, *v ++); + dst += 4; + } } static void br_aes_ct64_bitslice_Sbox(uint64_t *q) { - /* - * This S-box implementation is a straightforward translation of - * the circuit described by Boyar and Peralta in "A new - * combinational logic minimization technique with applications - * to cryptology" (https://eprint.iacr.org/2009/191.pdf). - * - * Note that variables x* (input) and s* (output) are numbered - * in "reverse" order (x0 is the high bit, x7 is the low bit). - */ - - uint64_t x0, x1, x2, x3, x4, x5, x6, x7; - uint64_t y1, y2, y3, y4, y5, y6, y7, y8, y9; - uint64_t y10, y11, y12, y13, y14, y15, y16, y17, y18, y19; - uint64_t y20, y21; - uint64_t z0, z1, z2, z3, z4, z5, z6, z7, z8, z9; - uint64_t z10, z11, z12, z13, z14, z15, z16, z17; - uint64_t t0, t1, t2, t3, t4, t5, t6, t7, t8, t9; - uint64_t t10, t11, t12, t13, t14, t15, t16, t17, t18, t19; - uint64_t t20, t21, t22, t23, t24, t25, t26, t27, t28, t29; - uint64_t t30, t31, t32, t33, t34, t35, t36, t37, t38, t39; - uint64_t t40, t41, t42, t43, t44, t45, t46, t47, t48, t49; - uint64_t t50, t51, t52, t53, t54, t55, t56, t57, t58, t59; - uint64_t t60, t61, t62, t63, t64, t65, t66, t67; - uint64_t s0, s1, s2, s3, s4, s5, s6, s7; - - x0 = q[7]; - x1 = q[6]; - x2 = q[5]; - x3 = q[4]; - x4 = q[3]; - x5 = q[2]; - x6 = q[1]; - x7 = q[0]; - - /* - * Top linear transformation. - */ - y14 = x3 ^ x5; - y13 = x0 ^ x6; - y9 = x0 ^ x3; - y8 = x0 ^ x5; - t0 = x1 ^ x2; - y1 = t0 ^ x7; - y4 = y1 ^ x3; - y12 = y13 ^ y14; - y2 = y1 ^ x0; - y5 = y1 ^ x6; - y3 = y5 ^ y8; - t1 = x4 ^ y12; - y15 = t1 ^ x5; - y20 = t1 ^ x1; - y6 = y15 ^ x7; - y10 = y15 ^ t0; - y11 = y20 ^ y9; - y7 = x7 ^ y11; - y17 = y10 ^ y11; - y19 = y10 ^ y8; - y16 = t0 ^ y11; - y21 = y13 ^ y16; - y18 = x0 ^ y16; - - /* - * Non-linear section. - */ - t2 = y12 & y15; - t3 = y3 & y6; - t4 = t3 ^ t2; - t5 = y4 & x7; - t6 = t5 ^ t2; - t7 = y13 & y16; - t8 = y5 & y1; - t9 = t8 ^ t7; - t10 = y2 & y7; - t11 = t10 ^ t7; - t12 = y9 & y11; - t13 = y14 & y17; - t14 = t13 ^ t12; - t15 = y8 & y10; - t16 = t15 ^ t12; - t17 = t4 ^ t14; - t18 = t6 ^ t16; - t19 = t9 ^ t14; - t20 = t11 ^ t16; - t21 = t17 ^ y20; - t22 = t18 ^ y19; - t23 = t19 ^ y21; - t24 = t20 ^ y18; - - t25 = t21 ^ t22; - t26 = t21 & t23; - t27 = t24 ^ t26; - t28 = t25 & t27; - t29 = t28 ^ t22; - t30 = t23 ^ t24; - t31 = t22 ^ t26; - t32 = t31 & t30; - t33 = t32 ^ t24; - t34 = t23 ^ t33; - t35 = t27 ^ t33; - t36 = t24 & t35; - t37 = t36 ^ t34; - t38 = t27 ^ t36; - t39 = t29 & t38; - t40 = t25 ^ t39; - - t41 = t40 ^ t37; - t42 = t29 ^ t33; - t43 = t29 ^ t40; - t44 = t33 ^ t37; - t45 = t42 ^ t41; - z0 = t44 & y15; - z1 = t37 & y6; - z2 = t33 & x7; - z3 = t43 & y16; - z4 = t40 & y1; - z5 = t29 & y7; - z6 = t42 & y11; - z7 = t45 & y17; - z8 = t41 & y10; - z9 = t44 & y12; - z10 = t37 & y3; - z11 = t33 & y4; - z12 = t43 & y13; - z13 = t40 & y5; - z14 = t29 & y2; - z15 = t42 & y9; - z16 = t45 & y14; - z17 = t41 & y8; - - /* - * Bottom linear transformation. - */ - t46 = z15 ^ z16; - t47 = z10 ^ z11; - t48 = z5 ^ z13; - t49 = z9 ^ z10; - t50 = z2 ^ z12; - t51 = z2 ^ z5; - t52 = z7 ^ z8; - t53 = z0 ^ z3; - t54 = z6 ^ z7; - t55 = z16 ^ z17; - t56 = z12 ^ t48; - t57 = t50 ^ t53; - t58 = z4 ^ t46; - t59 = z3 ^ t54; - t60 = t46 ^ t57; - t61 = z14 ^ t57; - t62 = t52 ^ t58; - t63 = t49 ^ t58; - t64 = z4 ^ t59; - t65 = t61 ^ t62; - t66 = z1 ^ t63; - s0 = t59 ^ t63; - s6 = t56 ^ ~t62; - s7 = t48 ^ ~t60; - t67 = t64 ^ t65; - s3 = t53 ^ t66; - s4 = t51 ^ t66; - s5 = t47 ^ t65; - s1 = t64 ^ ~s3; - s2 = t55 ^ ~t67; - - q[7] = s0; - q[6] = s1; - q[5] = s2; - q[4] = s3; - q[3] = s4; - q[2] = s5; - q[1] = s6; - q[0] = s7; + /* + * This S-box implementation is a straightforward translation of + * the circuit described by Boyar and Peralta in "A new + * combinational logic minimization technique with applications + * to cryptology" (https://eprint.iacr.org/2009/191.pdf). + * + * Note that variables x* (input) and s* (output) are numbered + * in "reverse" order (x0 is the high bit, x7 is the low bit). + */ + + uint64_t x0, x1, x2, x3, x4, x5, x6, x7; + uint64_t y1, y2, y3, y4, y5, y6, y7, y8, y9; + uint64_t y10, y11, y12, y13, y14, y15, y16, y17, y18, y19; + uint64_t y20, y21; + uint64_t z0, z1, z2, z3, z4, z5, z6, z7, z8, z9; + uint64_t z10, z11, z12, z13, z14, z15, z16, z17; + uint64_t t0, t1, t2, t3, t4, t5, t6, t7, t8, t9; + uint64_t t10, t11, t12, t13, t14, t15, t16, t17, t18, t19; + uint64_t t20, t21, t22, t23, t24, t25, t26, t27, t28, t29; + uint64_t t30, t31, t32, t33, t34, t35, t36, t37, t38, t39; + uint64_t t40, t41, t42, t43, t44, t45, t46, t47, t48, t49; + uint64_t t50, t51, t52, t53, t54, t55, t56, t57, t58, t59; + uint64_t t60, t61, t62, t63, t64, t65, t66, t67; + uint64_t s0, s1, s2, s3, s4, s5, s6, s7; + + x0 = q[7]; + x1 = q[6]; + x2 = q[5]; + x3 = q[4]; + x4 = q[3]; + x5 = q[2]; + x6 = q[1]; + x7 = q[0]; + + /* + * Top linear transformation. + */ + y14 = x3 ^ x5; + y13 = x0 ^ x6; + y9 = x0 ^ x3; + y8 = x0 ^ x5; + t0 = x1 ^ x2; + y1 = t0 ^ x7; + y4 = y1 ^ x3; + y12 = y13 ^ y14; + y2 = y1 ^ x0; + y5 = y1 ^ x6; + y3 = y5 ^ y8; + t1 = x4 ^ y12; + y15 = t1 ^ x5; + y20 = t1 ^ x1; + y6 = y15 ^ x7; + y10 = y15 ^ t0; + y11 = y20 ^ y9; + y7 = x7 ^ y11; + y17 = y10 ^ y11; + y19 = y10 ^ y8; + y16 = t0 ^ y11; + y21 = y13 ^ y16; + y18 = x0 ^ y16; + + /* + * Non-linear section. + */ + t2 = y12 & y15; + t3 = y3 & y6; + t4 = t3 ^ t2; + t5 = y4 & x7; + t6 = t5 ^ t2; + t7 = y13 & y16; + t8 = y5 & y1; + t9 = t8 ^ t7; + t10 = y2 & y7; + t11 = t10 ^ t7; + t12 = y9 & y11; + t13 = y14 & y17; + t14 = t13 ^ t12; + t15 = y8 & y10; + t16 = t15 ^ t12; + t17 = t4 ^ t14; + t18 = t6 ^ t16; + t19 = t9 ^ t14; + t20 = t11 ^ t16; + t21 = t17 ^ y20; + t22 = t18 ^ y19; + t23 = t19 ^ y21; + t24 = t20 ^ y18; + + t25 = t21 ^ t22; + t26 = t21 & t23; + t27 = t24 ^ t26; + t28 = t25 & t27; + t29 = t28 ^ t22; + t30 = t23 ^ t24; + t31 = t22 ^ t26; + t32 = t31 & t30; + t33 = t32 ^ t24; + t34 = t23 ^ t33; + t35 = t27 ^ t33; + t36 = t24 & t35; + t37 = t36 ^ t34; + t38 = t27 ^ t36; + t39 = t29 & t38; + t40 = t25 ^ t39; + + t41 = t40 ^ t37; + t42 = t29 ^ t33; + t43 = t29 ^ t40; + t44 = t33 ^ t37; + t45 = t42 ^ t41; + z0 = t44 & y15; + z1 = t37 & y6; + z2 = t33 & x7; + z3 = t43 & y16; + z4 = t40 & y1; + z5 = t29 & y7; + z6 = t42 & y11; + z7 = t45 & y17; + z8 = t41 & y10; + z9 = t44 & y12; + z10 = t37 & y3; + z11 = t33 & y4; + z12 = t43 & y13; + z13 = t40 & y5; + z14 = t29 & y2; + z15 = t42 & y9; + z16 = t45 & y14; + z17 = t41 & y8; + + /* + * Bottom linear transformation. + */ + t46 = z15 ^ z16; + t47 = z10 ^ z11; + t48 = z5 ^ z13; + t49 = z9 ^ z10; + t50 = z2 ^ z12; + t51 = z2 ^ z5; + t52 = z7 ^ z8; + t53 = z0 ^ z3; + t54 = z6 ^ z7; + t55 = z16 ^ z17; + t56 = z12 ^ t48; + t57 = t50 ^ t53; + t58 = z4 ^ t46; + t59 = z3 ^ t54; + t60 = t46 ^ t57; + t61 = z14 ^ t57; + t62 = t52 ^ t58; + t63 = t49 ^ t58; + t64 = z4 ^ t59; + t65 = t61 ^ t62; + t66 = z1 ^ t63; + s0 = t59 ^ t63; + s6 = t56 ^ ~t62; + s7 = t48 ^ ~t60; + t67 = t64 ^ t65; + s3 = t53 ^ t66; + s4 = t51 ^ t66; + s5 = t47 ^ t65; + s1 = t64 ^ ~s3; + s2 = t55 ^ ~t67; + + q[7] = s0; + q[6] = s1; + q[5] = s2; + q[4] = s3; + q[3] = s4; + q[2] = s5; + q[1] = s6; + q[0] = s7; } static void br_aes_ct64_ortho(uint64_t *q) { #define SWAPN(cl, ch, s, x, y) do { \ - uint64_t a, b; \ - a = (x); \ - b = (y); \ - (x) = (a & (uint64_t)(cl)) | ((b & (uint64_t)(cl)) << (s)); \ - (y) = ((a & (uint64_t)(ch)) >> (s)) | (b & (uint64_t)(ch)); \ - } while (0) + uint64_t a, b; \ + a = (x); \ + b = (y); \ + (x) = (a & (uint64_t)(cl)) | ((b & (uint64_t)(cl)) << (s)); \ + (y) = ((a & (uint64_t)(ch)) >> (s)) | (b & (uint64_t)(ch)); \ + } while (0) #define SWAP2(x, y) SWAPN(0x5555555555555555, 0xAAAAAAAAAAAAAAAA, 1, x, y) #define SWAP4(x, y) SWAPN(0x3333333333333333, 0xCCCCCCCCCCCCCCCC, 2, x, y) #define SWAP8(x, y) SWAPN(0x0F0F0F0F0F0F0F0F, 0xF0F0F0F0F0F0F0F0, 4, x, y) - SWAP2(q[0], q[1]); - SWAP2(q[2], q[3]); - SWAP2(q[4], q[5]); - SWAP2(q[6], q[7]); + SWAP2(q[0], q[1]); + SWAP2(q[2], q[3]); + SWAP2(q[4], q[5]); + SWAP2(q[6], q[7]); - SWAP4(q[0], q[2]); - SWAP4(q[1], q[3]); - SWAP4(q[4], q[6]); - SWAP4(q[5], q[7]); + SWAP4(q[0], q[2]); + SWAP4(q[1], q[3]); + SWAP4(q[4], q[6]); + SWAP4(q[5], q[7]); - SWAP8(q[0], q[4]); - SWAP8(q[1], q[5]); - SWAP8(q[2], q[6]); - SWAP8(q[3], q[7]); + SWAP8(q[0], q[4]); + SWAP8(q[1], q[5]); + SWAP8(q[2], q[6]); + SWAP8(q[3], q[7]); } static void br_aes_ct64_interleave_in(uint64_t *q0, uint64_t *q1, const uint32_t *w) { - uint64_t x0, x1, x2, x3; - - x0 = w[0]; - x1 = w[1]; - x2 = w[2]; - x3 = w[3]; - x0 |= (x0 << 16); - x1 |= (x1 << 16); - x2 |= (x2 << 16); - x3 |= (x3 << 16); - x0 &= (uint64_t)0x0000FFFF0000FFFF; - x1 &= (uint64_t)0x0000FFFF0000FFFF; - x2 &= (uint64_t)0x0000FFFF0000FFFF; - x3 &= (uint64_t)0x0000FFFF0000FFFF; - x0 |= (x0 << 8); - x1 |= (x1 << 8); - x2 |= (x2 << 8); - x3 |= (x3 << 8); - x0 &= (uint64_t)0x00FF00FF00FF00FF; - x1 &= (uint64_t)0x00FF00FF00FF00FF; - x2 &= (uint64_t)0x00FF00FF00FF00FF; - x3 &= (uint64_t)0x00FF00FF00FF00FF; - *q0 = x0 | (x2 << 8); - *q1 = x1 | (x3 << 8); + uint64_t x0, x1, x2, x3; + + x0 = w[0]; + x1 = w[1]; + x2 = w[2]; + x3 = w[3]; + x0 |= (x0 << 16); + x1 |= (x1 << 16); + x2 |= (x2 << 16); + x3 |= (x3 << 16); + x0 &= (uint64_t)0x0000FFFF0000FFFF; + x1 &= (uint64_t)0x0000FFFF0000FFFF; + x2 &= (uint64_t)0x0000FFFF0000FFFF; + x3 &= (uint64_t)0x0000FFFF0000FFFF; + x0 |= (x0 << 8); + x1 |= (x1 << 8); + x2 |= (x2 << 8); + x3 |= (x3 << 8); + x0 &= (uint64_t)0x00FF00FF00FF00FF; + x1 &= (uint64_t)0x00FF00FF00FF00FF; + x2 &= (uint64_t)0x00FF00FF00FF00FF; + x3 &= (uint64_t)0x00FF00FF00FF00FF; + *q0 = x0 | (x2 << 8); + *q1 = x1 | (x3 << 8); } static void br_aes_ct64_interleave_out(uint32_t *w, uint64_t q0, uint64_t q1) { - uint64_t x0, x1, x2, x3; - - x0 = q0 & (uint64_t)0x00FF00FF00FF00FF; - x1 = q1 & (uint64_t)0x00FF00FF00FF00FF; - x2 = (q0 >> 8) & (uint64_t)0x00FF00FF00FF00FF; - x3 = (q1 >> 8) & (uint64_t)0x00FF00FF00FF00FF; - x0 |= (x0 >> 8); - x1 |= (x1 >> 8); - x2 |= (x2 >> 8); - x3 |= (x3 >> 8); - x0 &= (uint64_t)0x0000FFFF0000FFFF; - x1 &= (uint64_t)0x0000FFFF0000FFFF; - x2 &= (uint64_t)0x0000FFFF0000FFFF; - x3 &= (uint64_t)0x0000FFFF0000FFFF; - w[0] = (uint32_t)x0 | (uint32_t)(x0 >> 16); - w[1] = (uint32_t)x1 | (uint32_t)(x1 >> 16); - w[2] = (uint32_t)x2 | (uint32_t)(x2 >> 16); - w[3] = (uint32_t)x3 | (uint32_t)(x3 >> 16); + uint64_t x0, x1, x2, x3; + + x0 = q0 & (uint64_t)0x00FF00FF00FF00FF; + x1 = q1 & (uint64_t)0x00FF00FF00FF00FF; + x2 = (q0 >> 8) & (uint64_t)0x00FF00FF00FF00FF; + x3 = (q1 >> 8) & (uint64_t)0x00FF00FF00FF00FF; + x0 |= (x0 >> 8); + x1 |= (x1 >> 8); + x2 |= (x2 >> 8); + x3 |= (x3 >> 8); + x0 &= (uint64_t)0x0000FFFF0000FFFF; + x1 &= (uint64_t)0x0000FFFF0000FFFF; + x2 &= (uint64_t)0x0000FFFF0000FFFF; + x3 &= (uint64_t)0x0000FFFF0000FFFF; + w[0] = (uint32_t)x0 | (uint32_t)(x0 >> 16); + w[1] = (uint32_t)x1 | (uint32_t)(x1 >> 16); + w[2] = (uint32_t)x2 | (uint32_t)(x2 >> 16); + w[3] = (uint32_t)x3 | (uint32_t)(x3 >> 16); } static const unsigned char Rcon[] = { - 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1B, 0x36 + 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1B, 0x36 }; static uint32_t sub_word(uint32_t x) { - uint64_t q[8]; + uint64_t q[8]; - memset(q, 0, sizeof q); - q[0] = x; - br_aes_ct64_ortho(q); - br_aes_ct64_bitslice_Sbox(q); - br_aes_ct64_ortho(q); - return (uint32_t)q[0]; + memset(q, 0, sizeof q); + q[0] = x; + br_aes_ct64_ortho(q); + br_aes_ct64_bitslice_Sbox(q); + br_aes_ct64_ortho(q); + return (uint32_t)q[0]; } static void br_aes_ct64_keysched(uint64_t *comp_skey, const unsigned char *key, unsigned int key_len) { - unsigned int i, j, k, nk, nkf; - uint32_t tmp; - uint32_t skey[60]; - unsigned nrounds = 10 + ((key_len - 16) >> 2); - - nk = (key_len >> 2); - nkf = ((nrounds + 1) << 2); - br_range_dec32le(skey, (key_len >> 2), key); - tmp = skey[(key_len >> 2) - 1]; - for (i = nk, j = 0, k = 0; i < nkf; i ++) { - if (j == 0) { - tmp = (tmp << 24) | (tmp >> 8); - tmp = sub_word(tmp) ^ Rcon[k]; - } else if (nk > 6 && j == 4) { - tmp = sub_word(tmp); - } - tmp ^= skey[i - nk]; - skey[i] = tmp; - if (++ j == nk) { - j = 0; - k ++; - } - } - - for (i = 0, j = 0; i < nkf; i += 4, j += 2) { - uint64_t q[8]; - - br_aes_ct64_interleave_in(&q[0], &q[4], skey + i); - q[1] = q[0]; - q[2] = q[0]; - q[3] = q[0]; - q[5] = q[4]; - q[6] = q[4]; - q[7] = q[4]; - br_aes_ct64_ortho(q); - comp_skey[j + 0] = - (q[0] & (uint64_t)0x1111111111111111) - | (q[1] & (uint64_t)0x2222222222222222) - | (q[2] & (uint64_t)0x4444444444444444) - | (q[3] & (uint64_t)0x8888888888888888); - comp_skey[j + 1] = - (q[4] & (uint64_t)0x1111111111111111) - | (q[5] & (uint64_t)0x2222222222222222) - | (q[6] & (uint64_t)0x4444444444444444) - | (q[7] & (uint64_t)0x8888888888888888); - } + unsigned int i, j, k, nk, nkf; + uint32_t tmp; + uint32_t skey[60]; + unsigned nrounds = 10 + ((key_len - 16) >> 2); + + nk = (key_len >> 2); + nkf = ((nrounds + 1) << 2); + br_range_dec32le(skey, (key_len >> 2), key); + tmp = skey[(key_len >> 2) - 1]; + for (i = nk, j = 0, k = 0; i < nkf; i ++) { + if (j == 0) { + tmp = (tmp << 24) | (tmp >> 8); + tmp = sub_word(tmp) ^ Rcon[k]; + } else if (nk > 6 && j == 4) { + tmp = sub_word(tmp); + } + tmp ^= skey[i - nk]; + skey[i] = tmp; + if (++ j == nk) { + j = 0; + k ++; + } + } + + for (i = 0, j = 0; i < nkf; i += 4, j += 2) { + uint64_t q[8]; + + br_aes_ct64_interleave_in(&q[0], &q[4], skey + i); + q[1] = q[0]; + q[2] = q[0]; + q[3] = q[0]; + q[5] = q[4]; + q[6] = q[4]; + q[7] = q[4]; + br_aes_ct64_ortho(q); + comp_skey[j + 0] = + (q[0] & (uint64_t)0x1111111111111111) + | (q[1] & (uint64_t)0x2222222222222222) + | (q[2] & (uint64_t)0x4444444444444444) + | (q[3] & (uint64_t)0x8888888888888888); + comp_skey[j + 1] = + (q[4] & (uint64_t)0x1111111111111111) + | (q[5] & (uint64_t)0x2222222222222222) + | (q[6] & (uint64_t)0x4444444444444444) + | (q[7] & (uint64_t)0x8888888888888888); + } } static void br_aes_ct64_skey_expand(uint64_t *skey, const uint64_t *comp_skey, unsigned int nrounds) { - unsigned u, v, n; + unsigned u, v, n; - n = (nrounds + 1) << 1; - for (u = 0, v = 0; u < n; u ++, v += 4) { - uint64_t x0, x1, x2, x3; + n = (nrounds + 1) << 1; + for (u = 0, v = 0; u < n; u ++, v += 4) { + uint64_t x0, x1, x2, x3; - x0 = x1 = x2 = x3 = comp_skey[u]; - x0 &= (uint64_t)0x1111111111111111; - x1 &= (uint64_t)0x2222222222222222; - x2 &= (uint64_t)0x4444444444444444; - x3 &= (uint64_t)0x8888888888888888; - x1 >>= 1; - x2 >>= 2; - x3 >>= 3; - skey[v + 0] = (x0 << 4) - x0; - skey[v + 1] = (x1 << 4) - x1; - skey[v + 2] = (x2 << 4) - x2; - skey[v + 3] = (x3 << 4) - x3; - } + x0 = x1 = x2 = x3 = comp_skey[u]; + x0 &= (uint64_t)0x1111111111111111; + x1 &= (uint64_t)0x2222222222222222; + x2 &= (uint64_t)0x4444444444444444; + x3 &= (uint64_t)0x8888888888888888; + x1 >>= 1; + x2 >>= 2; + x3 >>= 3; + skey[v + 0] = (x0 << 4) - x0; + skey[v + 1] = (x1 << 4) - x1; + skey[v + 2] = (x2 << 4) - x2; + skey[v + 3] = (x3 << 4) - x3; + } } static inline void add_round_key(uint64_t *q, const uint64_t *sk) { - q[0] ^= sk[0]; - q[1] ^= sk[1]; - q[2] ^= sk[2]; - q[3] ^= sk[3]; - q[4] ^= sk[4]; - q[5] ^= sk[5]; - q[6] ^= sk[6]; - q[7] ^= sk[7]; + q[0] ^= sk[0]; + q[1] ^= sk[1]; + q[2] ^= sk[2]; + q[3] ^= sk[3]; + q[4] ^= sk[4]; + q[5] ^= sk[5]; + q[6] ^= sk[6]; + q[7] ^= sk[7]; } static inline void shift_rows(uint64_t *q) { - int i; + int i; - for (i = 0; i < 8; i ++) { - uint64_t x; + for (i = 0; i < 8; i ++) { + uint64_t x; - x = q[i]; - q[i] = (x & (uint64_t)0x000000000000FFFF) - | ((x & (uint64_t)0x00000000FFF00000) >> 4) - | ((x & (uint64_t)0x00000000000F0000) << 12) - | ((x & (uint64_t)0x0000FF0000000000) >> 8) - | ((x & (uint64_t)0x000000FF00000000) << 8) - | ((x & (uint64_t)0xF000000000000000) >> 12) - | ((x & (uint64_t)0x0FFF000000000000) << 4); - } + x = q[i]; + q[i] = (x & (uint64_t)0x000000000000FFFF) + | ((x & (uint64_t)0x00000000FFF00000) >> 4) + | ((x & (uint64_t)0x00000000000F0000) << 12) + | ((x & (uint64_t)0x0000FF0000000000) >> 8) + | ((x & (uint64_t)0x000000FF00000000) << 8) + | ((x & (uint64_t)0xF000000000000000) >> 12) + | ((x & (uint64_t)0x0FFF000000000000) << 4); + } } static inline uint64_t rotr32(uint64_t x) { - return (x << 32) | (x >> 32); + return (x << 32) | (x >> 32); } static inline void mix_columns(uint64_t *q) { - uint64_t q0, q1, q2, q3, q4, q5, q6, q7; - uint64_t r0, r1, r2, r3, r4, r5, r6, r7; - - q0 = q[0]; - q1 = q[1]; - q2 = q[2]; - q3 = q[3]; - q4 = q[4]; - q5 = q[5]; - q6 = q[6]; - q7 = q[7]; - r0 = (q0 >> 16) | (q0 << 48); - r1 = (q1 >> 16) | (q1 << 48); - r2 = (q2 >> 16) | (q2 << 48); - r3 = (q3 >> 16) | (q3 << 48); - r4 = (q4 >> 16) | (q4 << 48); - r5 = (q5 >> 16) | (q5 << 48); - r6 = (q6 >> 16) | (q6 << 48); - r7 = (q7 >> 16) | (q7 << 48); - - q[0] = q7 ^ r7 ^ r0 ^ rotr32(q0 ^ r0); - q[1] = q0 ^ r0 ^ q7 ^ r7 ^ r1 ^ rotr32(q1 ^ r1); - q[2] = q1 ^ r1 ^ r2 ^ rotr32(q2 ^ r2); - q[3] = q2 ^ r2 ^ q7 ^ r7 ^ r3 ^ rotr32(q3 ^ r3); - q[4] = q3 ^ r3 ^ q7 ^ r7 ^ r4 ^ rotr32(q4 ^ r4); - q[5] = q4 ^ r4 ^ r5 ^ rotr32(q5 ^ r5); - q[6] = q5 ^ r5 ^ r6 ^ rotr32(q6 ^ r6); - q[7] = q6 ^ r6 ^ r7 ^ rotr32(q7 ^ r7); + uint64_t q0, q1, q2, q3, q4, q5, q6, q7; + uint64_t r0, r1, r2, r3, r4, r5, r6, r7; + + q0 = q[0]; + q1 = q[1]; + q2 = q[2]; + q3 = q[3]; + q4 = q[4]; + q5 = q[5]; + q6 = q[6]; + q7 = q[7]; + r0 = (q0 >> 16) | (q0 << 48); + r1 = (q1 >> 16) | (q1 << 48); + r2 = (q2 >> 16) | (q2 << 48); + r3 = (q3 >> 16) | (q3 << 48); + r4 = (q4 >> 16) | (q4 << 48); + r5 = (q5 >> 16) | (q5 << 48); + r6 = (q6 >> 16) | (q6 << 48); + r7 = (q7 >> 16) | (q7 << 48); + + q[0] = q7 ^ r7 ^ r0 ^ rotr32(q0 ^ r0); + q[1] = q0 ^ r0 ^ q7 ^ r7 ^ r1 ^ rotr32(q1 ^ r1); + q[2] = q1 ^ r1 ^ r2 ^ rotr32(q2 ^ r2); + q[3] = q2 ^ r2 ^ q7 ^ r7 ^ r3 ^ rotr32(q3 ^ r3); + q[4] = q3 ^ r3 ^ q7 ^ r7 ^ r4 ^ rotr32(q4 ^ r4); + q[5] = q4 ^ r4 ^ r5 ^ rotr32(q5 ^ r5); + q[6] = q5 ^ r5 ^ r6 ^ rotr32(q6 ^ r6); + q[7] = q6 ^ r6 ^ r7 ^ rotr32(q7 ^ r7); } static void inc4_be(uint32_t *x) { - uint32_t t = br_swap32(*x) + 4; - *x = br_swap32(t); + uint32_t t = br_swap32(*x) + 4; + *x = br_swap32(t); } static void aes_ecb4x(unsigned char out[64], const uint32_t ivw[16], const uint64_t *sk_exp, unsigned int nrounds) { - uint32_t w[16]; - uint64_t q[8]; - unsigned int i; + uint32_t w[16]; + uint64_t q[8]; + unsigned int i; - memcpy(w, ivw, sizeof(w)); - for (i = 0; i < 4; i++) { - br_aes_ct64_interleave_in(&q[i], &q[i + 4], w + (i << 2)); - } - br_aes_ct64_ortho(q); + memcpy(w, ivw, sizeof(w)); + for (i = 0; i < 4; i++) { + br_aes_ct64_interleave_in(&q[i], &q[i + 4], w + (i << 2)); + } + br_aes_ct64_ortho(q); - add_round_key(q, sk_exp); - for (i = 1; i < nrounds; i++) { - br_aes_ct64_bitslice_Sbox(q); - shift_rows(q); - mix_columns(q); - add_round_key(q, sk_exp + (i << 3)); - } - br_aes_ct64_bitslice_Sbox(q); - shift_rows(q); - add_round_key(q, sk_exp + 8 * nrounds); + add_round_key(q, sk_exp); + for (i = 1; i < nrounds; i++) { + br_aes_ct64_bitslice_Sbox(q); + shift_rows(q); + mix_columns(q); + add_round_key(q, sk_exp + (i << 3)); + } + br_aes_ct64_bitslice_Sbox(q); + shift_rows(q); + add_round_key(q, sk_exp + 8 * nrounds); - br_aes_ct64_ortho(q); - for (i = 0; i < 4; i ++) { - br_aes_ct64_interleave_out(w + (i << 2), q[i], q[i + 4]); - } - br_range_enc32le(out, w, 16); + br_aes_ct64_ortho(q); + for (i = 0; i < 4; i ++) { + br_aes_ct64_interleave_out(w + (i << 2), q[i], q[i + 4]); + } + br_range_enc32le(out, w, 16); } static void aes_ctr4x(unsigned char out[64], uint32_t ivw[16], const uint64_t *sk_exp, unsigned int nrounds) { - aes_ecb4x(out, ivw, sk_exp, nrounds); + aes_ecb4x(out, ivw, sk_exp, nrounds); - /* Increase counter for next 4 blocks */ - inc4_be(ivw + 3); - inc4_be(ivw + 7); - inc4_be(ivw + 11); - inc4_be(ivw + 15); + /* Increase counter for next 4 blocks */ + inc4_be(ivw + 3); + inc4_be(ivw + 7); + inc4_be(ivw + 11); + inc4_be(ivw + 15); } static void aes_ecb(unsigned char *out, const unsigned char *in, size_t nblocks, const uint64_t *rkeys, unsigned int nrounds) { - uint32_t blocks[16]; - unsigned char t[64]; + uint32_t blocks[16]; + unsigned char t[64]; - while (nblocks >= 4) { - br_range_dec32le(blocks, 16, in); - aes_ecb4x(out, blocks, rkeys, nrounds); - nblocks -= 4; - in += 64; - out += 64; - } + while (nblocks >= 4) { + br_range_dec32le(blocks, 16, in); + aes_ecb4x(out, blocks, rkeys, nrounds); + nblocks -= 4; + in += 64; + out += 64; + } - if (nblocks) { - br_range_dec32le(blocks, nblocks * 4, in); - aes_ecb4x(t, blocks, rkeys, nrounds); - memcpy(out, t, nblocks * 16); - } + if (nblocks) { + br_range_dec32le(blocks, nblocks * 4, in); + aes_ecb4x(t, blocks, rkeys, nrounds); + memcpy(out, t, nblocks * 16); + } } static void aes_ctr(unsigned char *out, size_t outlen, const unsigned char *iv, const uint64_t *rkeys, unsigned int nrounds) { - uint32_t ivw[16]; - size_t i; - uint32_t cc = 0; - - br_range_dec32le(ivw, 3, iv); - memcpy(ivw + 4, ivw, 3 * sizeof(uint32_t)); - memcpy(ivw + 8, ivw, 3 * sizeof(uint32_t)); - memcpy(ivw + 12, ivw, 3 * sizeof(uint32_t)); - ivw[ 3] = br_swap32(cc); - ivw[ 7] = br_swap32(cc + 1); - ivw[11] = br_swap32(cc + 2); - ivw[15] = br_swap32(cc + 3); - - while (outlen > 64) { - aes_ctr4x(out, ivw, rkeys, nrounds); - out += 64; - outlen -= 64; - } - if (outlen > 0) { - unsigned char tmp[64]; - aes_ctr4x(tmp, ivw, rkeys, nrounds); - for (i = 0; i < outlen; i++) { - out[i] = tmp[i]; - } - } + uint32_t ivw[16]; + size_t i; + uint32_t cc = 0; + + br_range_dec32le(ivw, 3, iv); + memcpy(ivw + 4, ivw, 3 * sizeof(uint32_t)); + memcpy(ivw + 8, ivw, 3 * sizeof(uint32_t)); + memcpy(ivw + 12, ivw, 3 * sizeof(uint32_t)); + ivw[ 3] = br_swap32(cc); + ivw[ 7] = br_swap32(cc + 1); + ivw[11] = br_swap32(cc + 2); + ivw[15] = br_swap32(cc + 3); + + while (outlen > 64) { + aes_ctr4x(out, ivw, rkeys, nrounds); + out += 64; + outlen -= 64; + } + if (outlen > 0) { + unsigned char tmp[64]; + aes_ctr4x(tmp, ivw, rkeys, nrounds); + for (i = 0; i < outlen; i++) { + out[i] = tmp[i]; + } + } } void aes128_ecb_keyexp(aes128ctx *r, const unsigned char *key) { - uint64_t skey[22]; + uint64_t skey[22]; - r->sk_exp = malloc(sizeof(uint64_t) * PQC_AES128_STATESIZE); - if (r->sk_exp == NULL) { - exit(111); - } + r->sk_exp = malloc(sizeof(uint64_t) * PQC_AES128_STATESIZE); + if (r->sk_exp == NULL) { + exit(111); + } - br_aes_ct64_keysched(skey, key, 16); - br_aes_ct64_skey_expand(r->sk_exp, skey, 10); + br_aes_ct64_keysched(skey, key, 16); + br_aes_ct64_skey_expand(r->sk_exp, skey, 10); } void aes128_ctr_keyexp(aes128ctx *r, const unsigned char *key) { - aes128_ecb_keyexp(r, key); + aes128_ecb_keyexp(r, key); } void aes192_ecb_keyexp(aes192ctx *r, const unsigned char *key) { - uint64_t skey[26]; - r->sk_exp = malloc(sizeof(uint64_t) * PQC_AES192_STATESIZE); - if (r->sk_exp == NULL) { - exit(111); - } + uint64_t skey[26]; + r->sk_exp = malloc(sizeof(uint64_t) * PQC_AES192_STATESIZE); + if (r->sk_exp == NULL) { + exit(111); + } - br_aes_ct64_keysched(skey, key, 24); - br_aes_ct64_skey_expand(r->sk_exp, skey, 12); + br_aes_ct64_keysched(skey, key, 24); + br_aes_ct64_skey_expand(r->sk_exp, skey, 12); } void aes192_ctr_keyexp(aes192ctx *r, const unsigned char *key) { - aes192_ecb_keyexp(r, key); + aes192_ecb_keyexp(r, key); } void aes256_ecb_keyexp(aes256ctx *r, const unsigned char *key) { - uint64_t skey[30]; - r->sk_exp = malloc(sizeof(uint64_t) * PQC_AES256_STATESIZE); - if (r->sk_exp == NULL) { - exit(111); - } + uint64_t skey[30]; + r->sk_exp = malloc(sizeof(uint64_t) * PQC_AES256_STATESIZE); + if (r->sk_exp == NULL) { + exit(111); + } - br_aes_ct64_keysched(skey, key, 32); - br_aes_ct64_skey_expand(r->sk_exp, skey, 14); + br_aes_ct64_keysched(skey, key, 32); + br_aes_ct64_skey_expand(r->sk_exp, skey, 14); } void aes256_ctr_keyexp(aes256ctx *r, const unsigned char *key) { - aes256_ecb_keyexp(r, key); + aes256_ecb_keyexp(r, key); } void aes128_ecb(unsigned char *out, const unsigned char *in, size_t nblocks, const aes128ctx *ctx) { - aes_ecb(out, in, nblocks, ctx->sk_exp, 10); + aes_ecb(out, in, nblocks, ctx->sk_exp, 10); } void aes128_ctr(unsigned char *out, size_t outlen, const unsigned char *iv, const aes128ctx *ctx) { - aes_ctr(out, outlen, iv, ctx->sk_exp, 10); + aes_ctr(out, outlen, iv, ctx->sk_exp, 10); } void aes192_ecb(unsigned char *out, const unsigned char *in, size_t nblocks, const aes192ctx *ctx) { - aes_ecb(out, in, nblocks, ctx->sk_exp, 12); + aes_ecb(out, in, nblocks, ctx->sk_exp, 12); } void aes192_ctr(unsigned char *out, size_t outlen, const unsigned char *iv, const aes192ctx *ctx) { - aes_ctr(out, outlen, iv, ctx->sk_exp, 12); + aes_ctr(out, outlen, iv, ctx->sk_exp, 12); } void aes256_ecb(unsigned char *out, const unsigned char *in, size_t nblocks, const aes256ctx *ctx) { - aes_ecb(out, in, nblocks, ctx->sk_exp, 14); + aes_ecb(out, in, nblocks, ctx->sk_exp, 14); } void aes256_ctr(unsigned char *out, size_t outlen, const unsigned char *iv, const aes256ctx *ctx) { - aes_ctr(out, outlen, iv, ctx->sk_exp, 14); + aes_ctr(out, outlen, iv, ctx->sk_exp, 14); } void aes128_ctx_release(aes128ctx *r) { - free(r->sk_exp); + free(r->sk_exp); } void aes192_ctx_release(aes192ctx *r) { - free(r->sk_exp); + free(r->sk_exp); } void aes256_ctx_release(aes256ctx *r) { - free(r->sk_exp); + free(r->sk_exp); } int AES_128_CTR(unsigned char *output, size_t outputByteLen, - const unsigned char *input, size_t inputByteLen) { - aes128ctx ctx; - unsigned char iv[16] = { 0 }; + const unsigned char *input, size_t inputByteLen) { + aes128ctx ctx; + unsigned char iv[16] = { 0 }; - aes128_ctr_keyexp(&ctx, input); - aes128_ctr(output, outputByteLen, iv, &ctx); - aes128_ctx_release(&ctx); + aes128_ctr_keyexp(&ctx, input); + aes128_ctr(output, outputByteLen, iv, &ctx); + aes128_ctx_release(&ctx); - return (int)outputByteLen; + return (int)outputByteLen; } void AES_256_ECB(const uint8_t *input, const unsigned char *key, unsigned char *output) { - aes256ctx ctx; + aes256ctx ctx; - aes256_ecb_keyexp(&ctx, key); - aes256_ecb(output, input, 1, &ctx); - aes256_ctx_release(&ctx); + aes256_ecb_keyexp(&ctx, key); + aes256_ecb(output, input, 1, &ctx); + aes256_ctx_release(&ctx); } diff --git a/lib/mayo/aes_ctr.h b/lib/mayo/aes_ctr.h index fdec519ac..a4aea2cbb 100644 --- a/lib/mayo/aes_ctr.h +++ b/lib/mayo/aes_ctr.h @@ -11,20 +11,20 @@ void AES_256_ECB(const uint8_t *input, const uint8_t *key, uint8_t *output); #ifdef ENABLE_AESNI int AES_128_CTR_NI(unsigned char *output, size_t outputByteLen, - const unsigned char *input, size_t inputByteLen); + const unsigned char *input, size_t inputByteLen); int AES_128_CTR_4R_NI(unsigned char *output, size_t outputByteLen, - const unsigned char *input, size_t inputByteLen); + const unsigned char *input, size_t inputByteLen); #define AES_128_CTR AES_128_CTR_NI #else #ifdef ENABLE_AESNEON int AES_128_CTR_NEON(unsigned char *output, size_t outputByteLen, - const unsigned char *input, size_t inputByteLen); + const unsigned char *input, size_t inputByteLen); int AES_128_CTR_4R_NI(unsigned char *output, size_t outputByteLen, - const unsigned char *input, size_t inputByteLen); + const unsigned char *input, size_t inputByteLen); #define AES_128_CTR AES_128_CTR_NEON #else int AES_128_CTR(unsigned char *output, size_t outputByteLen, - const unsigned char *input, size_t inputByteLen); + const unsigned char *input, size_t inputByteLen); #endif #endif diff --git a/lib/mayo/api.c b/lib/mayo/api.c index f2e861e9c..83780d292 100644 --- a/lib/mayo/api.c +++ b/lib/mayo/api.c @@ -11,36 +11,36 @@ int crypto_sign_keypair(unsigned char *pk, unsigned char *sk) { - return mayo_keypair(MAYO_PARAMS, pk, sk); + return mayo_keypair(MAYO_PARAMS, pk, sk); } int crypto_sign(unsigned char *sm, size_t *smlen, - const unsigned char *m, size_t mlen, - const unsigned char *sk) { - return mayo_sign(MAYO_PARAMS, sm, smlen, m, mlen, sk); + const unsigned char *m, size_t mlen, + const unsigned char *sk) { + return mayo_sign(MAYO_PARAMS, sm, smlen, m, mlen, sk); } int crypto_sign_signature(unsigned char *sig, - size_t *siglen, const unsigned char *m, - size_t mlen, const unsigned char *sk) { - return mayo_sign_signature(MAYO_PARAMS, sig, siglen, m, mlen, sk); + size_t *siglen, const unsigned char *m, + size_t mlen, const unsigned char *sk) { + return mayo_sign_signature(MAYO_PARAMS, sig, siglen, m, mlen, sk); } int crypto_sign_open(unsigned char *m, size_t *mlen, - const unsigned char *sm, size_t smlen, - const unsigned char *pk) { - return mayo_open(MAYO_PARAMS, m, mlen, sm, smlen, pk); + const unsigned char *sm, size_t smlen, + const unsigned char *pk) { + return mayo_open(MAYO_PARAMS, m, mlen, sm, smlen, pk); } int crypto_sign_verify(const unsigned char *sig, size_t siglen, - const unsigned char *m, size_t mlen, - const unsigned char *pk) { - if (siglen != CRYPTO_BYTES) - return -1; - return mayo_verify(MAYO_PARAMS, m, mlen, sig, pk); + const unsigned char *m, size_t mlen, + const unsigned char *pk) { + if (siglen != CRYPTO_BYTES) + return -1; + return mayo_verify(MAYO_PARAMS, m, mlen, sig, pk); } diff --git a/lib/mayo/api.h b/lib/mayo/api.h index 44caa7d1f..4bb24e3ba 100644 --- a/lib/mayo/api.h +++ b/lib/mayo/api.h @@ -18,26 +18,26 @@ crypto_sign_keypair(unsigned char *pk, unsigned char *sk); #define crypto_sign MAYO_NAMESPACE(crypto_sign) int crypto_sign(unsigned char *sm, size_t *smlen, - const unsigned char *m, size_t mlen, - const unsigned char *sk); + const unsigned char *m, size_t mlen, + const unsigned char *sk); #define crypto_sign_signature MAYO_NAMESPACE(crypto_sign_signature) int crypto_sign_signature(unsigned char *sig, - size_t *siglen, const unsigned char *m, - size_t mlen, const unsigned char *sk); + size_t *siglen, const unsigned char *m, + size_t mlen, const unsigned char *sk); #define crypto_sign_open MAYO_NAMESPACE(crypto_sign_open) int crypto_sign_open(unsigned char *m, size_t *mlen, - const unsigned char *sm, size_t smlen, - const unsigned char *pk); + const unsigned char *sm, size_t smlen, + const unsigned char *pk); #define crypto_sign_verify MAYO_NAMESPACE(crypto_sign_verify) int crypto_sign_verify(const unsigned char *sig, size_t siglen, - const unsigned char *m, size_t mlen, - const unsigned char *pk); + const unsigned char *m, size_t mlen, + const unsigned char *pk); #endif /* api_h */ diff --git a/lib/mayo/arithmetic.c b/lib/mayo/arithmetic.c index 803d695f3..23eef48dd 100644 --- a/lib/mayo/arithmetic.c +++ b/lib/mayo/arithmetic.c @@ -12,21 +12,21 @@ #endif void m_upper(const mayo_params_t* p, const uint64_t *in, uint64_t *out, int size) { - #ifndef ENABLE_PARAMS_DYNAMIC - (void) p; - #endif - // Look into AVX2'ing this - const int m_vec_limbs = PARAM_m_vec_limbs(p); - int m_vecs_stored = 0; - for (int r = 0; r < size; r++) { - for (int c = r; c < size; c++) { - m_vec_copy(m_vec_limbs, in + m_vec_limbs * (r * size + c), out + m_vec_limbs * m_vecs_stored ); - if (r != c) { - m_vec_add(m_vec_limbs, in + m_vec_limbs * (c * size + r), out + m_vec_limbs * m_vecs_stored ); - } - m_vecs_stored ++; - } - } + #ifndef ENABLE_PARAMS_DYNAMIC + (void) p; + #endif + // Look into AVX2'ing this + const int m_vec_limbs = PARAM_m_vec_limbs(p); + int m_vecs_stored = 0; + for (int r = 0; r < size; r++) { + for (int c = r; c < size; c++) { + m_vec_copy(m_vec_limbs, in + m_vec_limbs * (r * size + c), out + m_vec_limbs * m_vecs_stored ); + if (r != c) { + m_vec_add(m_vec_limbs, in + m_vec_limbs * (c * size + r), out + m_vec_limbs * m_vecs_stored ); + } + m_vecs_stored ++; + } + } } @@ -38,89 +38,89 @@ void m_upper(const mayo_params_t* p, const uint64_t *in, uint64_t *out, int size // - r and x are k*o bytes long // return: 1 on success, 0 on failure int sample_solution(const mayo_params_t *p, unsigned char *A, - const unsigned char *y, const unsigned char *r, - unsigned char *x, int k, int o, int m, int A_cols) { - #ifdef MAYO_VARIANT - (void) p; - #endif - unsigned char finished; - int col_upper_bound; - unsigned char correct_column; - - // x <- r - for (int i = 0; i < k * o; i++) { - x[i] = r[i]; - } - - // compute Ar; - unsigned char Ar[M_MAX]; - for (int i = 0; i < m; i++) { - A[k * o + i * (k * o + 1)] = 0; // clear last col of A - } - mat_mul(A, r, Ar, k * o + 1, m, 1); - - // move y - Ar to last column of matrix A - for (int i = 0; i < m; i++) { - A[k * o + i * (k * o + 1)] = sub_f(y[i], Ar[i]); - } - - EF(A, m, k * o + 1); - - // check if last row of A (excluding the last entry of y) is zero - unsigned char full_rank = 0; - for (int i = 0; i < A_cols - 1; i++) { - full_rank |= A[(m - 1) * A_cols + i]; - } + const unsigned char *y, const unsigned char *r, + unsigned char *x, int k, int o, int m, int A_cols) { + #ifdef MAYO_VARIANT + (void) p; + #endif + unsigned char finished; + int col_upper_bound; + unsigned char correct_column; + + // x <- r + for (int i = 0; i < k * o; i++) { + x[i] = r[i]; + } + + // compute Ar; + unsigned char Ar[M_MAX]; + for (int i = 0; i < m; i++) { + A[k * o + i * (k * o + 1)] = 0; // clear last col of A + } + mat_mul(A, r, Ar, k * o + 1, m, 1); + + // move y - Ar to last column of matrix A + for (int i = 0; i < m; i++) { + A[k * o + i * (k * o + 1)] = sub_f(y[i], Ar[i]); + } + + EF(A, m, k * o + 1); + + // check if last row of A (excluding the last entry of y) is zero + unsigned char full_rank = 0; + for (int i = 0; i < A_cols - 1; i++) { + full_rank |= A[(m - 1) * A_cols + i]; + } // It is okay to leak if we need to restart or not #ifdef ENABLE_CT_TESTING - VALGRIND_MAKE_MEM_DEFINED(&full_rank, 1); + VALGRIND_MAKE_MEM_DEFINED(&full_rank, 1); #endif - if (full_rank == 0) { - return 0; - } - - // back substitution in constant time - // the index of the first nonzero entry in each row is secret, which makes - // things less efficient - - for (int row = m - 1; row >= 0; row--) { - finished = 0; - col_upper_bound = MAYO_MIN(row + (32/(m-row)), k*o); - // the first nonzero entry in row r is between r and col_upper_bound with probability at least ~1-q^{-32} - - for (int col = row; col <= col_upper_bound; col++) { - - // Compare two chars in constant time. - // Returns 0x00 if the byte arrays are equal, 0xff otherwise. - correct_column = ct_compare_8((A[row * A_cols + col]), 0) & ~finished; - - unsigned char u = correct_column & A[row * A_cols + A_cols - 1]; - x[col] ^= u; - - for (int i = 0; i < row; i += 8) { - uint64_t tmp = ( (uint64_t) A[ i * A_cols + col] << 0) ^ ( (uint64_t) A[(i+1) * A_cols + col] << 8) - ^ ( (uint64_t) A[(i+2) * A_cols + col] << 16) ^ ( (uint64_t) A[(i+3) * A_cols + col] << 24) - ^ ( (uint64_t) A[(i+4) * A_cols + col] << 32) ^ ( (uint64_t) A[(i+5) * A_cols + col] << 40) - ^ ( (uint64_t) A[(i+6) * A_cols + col] << 48) ^ ( (uint64_t) A[(i+7) * A_cols + col] << 56); - - tmp = mul_fx8(u, tmp); - - A[ i * A_cols + A_cols - 1] ^= (tmp ) & 0xf; - A[(i+1) * A_cols + A_cols - 1] ^= (tmp >> 8 ) & 0xf; - A[(i+2) * A_cols + A_cols - 1] ^= (tmp >> 16) & 0xf; - A[(i+3) * A_cols + A_cols - 1] ^= (tmp >> 24) & 0xf; - A[(i+4) * A_cols + A_cols - 1] ^= (tmp >> 32) & 0xf; - A[(i+5) * A_cols + A_cols - 1] ^= (tmp >> 40) & 0xf; - A[(i+6) * A_cols + A_cols - 1] ^= (tmp >> 48) & 0xf; - A[(i+7) * A_cols + A_cols - 1] ^= (tmp >> 56) & 0xf; - } - - finished = finished | correct_column; - } - } - return 1; + if (full_rank == 0) { + return 0; + } + + // back substitution in constant time + // the index of the first nonzero entry in each row is secret, which makes + // things less efficient + + for (int row = m - 1; row >= 0; row--) { + finished = 0; + col_upper_bound = MAYO_MIN(row + (32/(m-row)), k*o); + // the first nonzero entry in row r is between r and col_upper_bound with probability at least ~1-q^{-32} + + for (int col = row; col <= col_upper_bound; col++) { + + // Compare two chars in constant time. + // Returns 0x00 if the byte arrays are equal, 0xff otherwise. + correct_column = ct_compare_8((A[row * A_cols + col]), 0) & ~finished; + + unsigned char u = correct_column & A[row * A_cols + A_cols - 1]; + x[col] ^= u; + + for (int i = 0; i < row; i += 8) { + uint64_t tmp = ( (uint64_t) A[ i * A_cols + col] << 0) ^ ( (uint64_t) A[(i+1) * A_cols + col] << 8) + ^ ( (uint64_t) A[(i+2) * A_cols + col] << 16) ^ ( (uint64_t) A[(i+3) * A_cols + col] << 24) + ^ ( (uint64_t) A[(i+4) * A_cols + col] << 32) ^ ( (uint64_t) A[(i+5) * A_cols + col] << 40) + ^ ( (uint64_t) A[(i+6) * A_cols + col] << 48) ^ ( (uint64_t) A[(i+7) * A_cols + col] << 56); + + tmp = mul_fx8(u, tmp); + + A[ i * A_cols + A_cols - 1] ^= (tmp ) & 0xf; + A[(i+1) * A_cols + A_cols - 1] ^= (tmp >> 8 ) & 0xf; + A[(i+2) * A_cols + A_cols - 1] ^= (tmp >> 16) & 0xf; + A[(i+3) * A_cols + A_cols - 1] ^= (tmp >> 24) & 0xf; + A[(i+4) * A_cols + A_cols - 1] ^= (tmp >> 32) & 0xf; + A[(i+5) * A_cols + A_cols - 1] ^= (tmp >> 40) & 0xf; + A[(i+6) * A_cols + A_cols - 1] ^= (tmp >> 48) & 0xf; + A[(i+7) * A_cols + A_cols - 1] ^= (tmp >> 56) & 0xf; + } + + finished = finished | correct_column; + } + } + return 1; } volatile uint32_t uint32_t_blocker = 0; diff --git a/lib/mayo/arithmetic.h b/lib/mayo/arithmetic.h index 0fdd0e367..7e812fa02 100644 --- a/lib/mayo/arithmetic.h +++ b/lib/mayo/arithmetic.h @@ -26,82 +26,82 @@ extern volatile unsigned char unsigned_char_blocker; // a > b -> b - a is negative // returns 0xFFFFFFFF if true, 0x00000000 if false static inline uint32_t ct_is_greater_than(int a, int b) { - int32_t diff = b - a; - return ((uint32_t) (diff >> (8*sizeof(uint32_t)-1)) ^ uint32_t_blocker); + int32_t diff = b - a; + return ((uint32_t) (diff >> (8*sizeof(uint32_t)-1)) ^ uint32_t_blocker); } // a > b -> b - a is negative // returns 0xFFFFFFFF if true, 0x00000000 if false static inline uint64_t ct_64_is_greater_than(int a, int b) { - int64_t diff = ((int64_t) b) - ((int64_t) a); - return ((uint64_t) (diff >> (8*sizeof(uint64_t)-1)) ^ uint64_t_blocker); + int64_t diff = ((int64_t) b) - ((int64_t) a); + return ((uint64_t) (diff >> (8*sizeof(uint64_t)-1)) ^ uint64_t_blocker); } // if a == b -> 0x00000000, else 0xFFFFFFFF static inline uint32_t ct_compare_32(int a, int b) { - return ((uint32_t)((-(int32_t)(a ^ b)) >> (8*sizeof(uint32_t)-1)) ^ uint32_t_blocker); + return ((uint32_t)((-(int32_t)(a ^ b)) >> (8*sizeof(uint32_t)-1)) ^ uint32_t_blocker); } // if a == b -> 0x0000000000000000, else 0xFFFFFFFFFFFFFFFF static inline uint64_t ct_compare_64(int a, int b) { - return ((uint64_t)((-(int64_t)(a ^ b)) >> (8*sizeof(uint64_t)-1)) ^ uint64_t_blocker); + return ((uint64_t)((-(int64_t)(a ^ b)) >> (8*sizeof(uint64_t)-1)) ^ uint64_t_blocker); } // if a == b -> 0x00, else 0xFF static inline unsigned char ct_compare_8(unsigned char a, unsigned char b) { - return ((int8_t)((-(int32_t)(a ^ b)) >> (8*sizeof(uint32_t)-1)) ^ unsigned_char_blocker); + return ((int8_t)((-(int32_t)(a ^ b)) >> (8*sizeof(uint32_t)-1)) ^ unsigned_char_blocker); } #else // a > b -> b - a is negative // returns 0xFFFFFFFF if true, 0x00000000 if false static inline uint32_t ct_is_greater_than(int a, int b) { - int32_t diff = b - a; - return ((uint32_t) (diff >> (8*sizeof(uint32_t)-1))); + int32_t diff = b - a; + return ((uint32_t) (diff >> (8*sizeof(uint32_t)-1))); } // a > b -> b - a is negative // returns 0xFFFFFFFF if true, 0x00000000 if false static inline uint64_t ct_64_is_greater_than(int a, int b) { - int64_t diff = ((int64_t) b) - ((int64_t) a); - return ((uint64_t) (diff >> (8*sizeof(uint64_t)-1))); + int64_t diff = ((int64_t) b) - ((int64_t) a); + return ((uint64_t) (diff >> (8*sizeof(uint64_t)-1))); } // if a == b -> 0x00000000, else 0xFFFFFFFF static inline uint32_t ct_compare_32(int a, int b) { - return ((uint32_t)((-(int32_t)(a ^ b)) >> (8*sizeof(uint32_t)-1))); + return ((uint32_t)((-(int32_t)(a ^ b)) >> (8*sizeof(uint32_t)-1))); } // if a == b -> 0x0000000000000000, else 0xFFFFFFFFFFFFFFFF static inline uint64_t ct_compare_64(int a, int b) { - return ((uint64_t)((-(int64_t)(a ^ b)) >> (8*sizeof(uint64_t)-1))); + return ((uint64_t)((-(int64_t)(a ^ b)) >> (8*sizeof(uint64_t)-1))); } // if a == b -> 0x00, else 0xFF static inline unsigned char ct_compare_8(unsigned char a, unsigned char b) { - return ((int8_t)((-(int32_t)(a ^ b)) >> (8*sizeof(uint32_t)-1))); + return ((int8_t)((-(int32_t)(a ^ b)) >> (8*sizeof(uint32_t)-1))); } #endif #if defined(MAYO_AVX) || defined(MAYO_NEON) - #include + #include #elif defined(MAYO_M4) - #include + #include #else - #include + #include #endif static inline void vec_mul_add_u64(const int legs, const uint64_t *in, unsigned char a, uint64_t *acc) { - uint32_t tab = mul_table(a); + uint32_t tab = mul_table(a); - uint64_t lsb_ask = 0x1111111111111111ULL; + uint64_t lsb_ask = 0x1111111111111111ULL; - for(int i=0; i < legs; i++){ - acc[i] ^= ( in[i] & lsb_ask) * (tab & 0xff) - ^ ((in[i] >> 1) & lsb_ask) * ((tab >> 8) & 0xf) - ^ ((in[i] >> 2) & lsb_ask) * ((tab >> 16) & 0xf) - ^ ((in[i] >> 3) & lsb_ask) * ((tab >> 24) & 0xf); - } + for(int i=0; i < legs; i++){ + acc[i] ^= ( in[i] & lsb_ask) * (tab & 0xff) + ^ ((in[i] >> 1) & lsb_ask) * ((tab >> 8) & 0xf) + ^ ((in[i] >> 2) & lsb_ask) * ((tab >> 16) & 0xf) + ^ ((in[i] >> 3) & lsb_ask) * ((tab >> 24) & 0xf); + } } // Calculate Upper in KeyGen diff --git a/lib/mayo/arithmetic_dynamic.h b/lib/mayo/arithmetic_dynamic.h index d91f6c520..bd95938a1 100644 --- a/lib/mayo/arithmetic_dynamic.h +++ b/lib/mayo/arithmetic_dynamic.h @@ -8,61 +8,61 @@ static inline void m_vec_copy(int m_vec_limbs, const uint64_t *in, uint64_t *out) { - for (int i = 0; i < m_vec_limbs; i++) { - out[i] = in[i]; - } + for (int i = 0; i < m_vec_limbs; i++) { + out[i] = in[i]; + } } static inline void m_vec_add(int m_vec_limbs, const uint64_t *in, uint64_t *acc) { - for (int i = 0; i < m_vec_limbs; i++) { - acc[i] ^= in[i]; - } + for (int i = 0; i < m_vec_limbs; i++) { + acc[i] ^= in[i]; + } } static inline void m_vec_mul_add(int m_vec_limbs, const uint64_t *in, unsigned char a, uint64_t *acc) { - for(int i=0; i < m_vec_limbs; i++){ - acc[i] ^= gf16v_mul_u64(in[i], a); - } + for(int i=0; i < m_vec_limbs; i++){ + acc[i] ^= gf16v_mul_u64(in[i], a); + } } inline static void m_vec_mul_add_x (int m_vec_limbs, const uint64_t *in, uint64_t *acc) { - uint64_t mask_msb = 0x8888888888888888ULL; - for(int i=0; i < m_vec_limbs; i++){ - uint64_t t = in[i] & mask_msb; - acc[i] ^= ((in[i] ^ t) << 1) ^ ((t >> 3) * 3); - } + uint64_t mask_msb = 0x8888888888888888ULL; + for(int i=0; i < m_vec_limbs; i++){ + uint64_t t = in[i] & mask_msb; + acc[i] ^= ((in[i] ^ t) << 1) ^ ((t >> 3) * 3); + } } inline static void m_vec_mul_add_x_inv (int m_vec_limbs, const uint64_t *in, uint64_t *acc) { - uint64_t mask_lsb = 0x1111111111111111ULL; - for(int i=0; i < m_vec_limbs; i++){ - uint64_t t = in[i] & mask_lsb; - acc[i] ^= ((in[i] ^ t) >> 1) ^ (t * 9); - } + uint64_t mask_lsb = 0x1111111111111111ULL; + for(int i=0; i < m_vec_limbs; i++){ + uint64_t t = in[i] & mask_lsb; + acc[i] ^= ((in[i] ^ t) >> 1) ^ (t * 9); + } } static inline void m_vec_multiply_bins (int m_vec_limbs, uint64_t *bins, uint64_t *out) { - m_vec_mul_add_x_inv (m_vec_limbs, bins + 5 * m_vec_limbs, bins + 10 * m_vec_limbs); - m_vec_mul_add_x (m_vec_limbs, bins + 11 * m_vec_limbs, bins + 12 * m_vec_limbs); - m_vec_mul_add_x_inv (m_vec_limbs, bins + 10 * m_vec_limbs, bins + 7 * m_vec_limbs); - m_vec_mul_add_x (m_vec_limbs, bins + 12 * m_vec_limbs, bins + 6 * m_vec_limbs); - m_vec_mul_add_x_inv (m_vec_limbs, bins + 7 * m_vec_limbs, bins + 14 * m_vec_limbs); - m_vec_mul_add_x (m_vec_limbs, bins + 6 * m_vec_limbs, bins + 3 * m_vec_limbs); - m_vec_mul_add_x_inv (m_vec_limbs, bins + 14 * m_vec_limbs, bins + 15 * m_vec_limbs); - m_vec_mul_add_x (m_vec_limbs, bins + 3 * m_vec_limbs, bins + 8 * m_vec_limbs); - m_vec_mul_add_x_inv (m_vec_limbs, bins + 15 * m_vec_limbs, bins + 13 * m_vec_limbs); - m_vec_mul_add_x (m_vec_limbs, bins + 8 * m_vec_limbs, bins + 4 * m_vec_limbs); - m_vec_mul_add_x_inv (m_vec_limbs, bins + 13 * m_vec_limbs, bins + 9 * m_vec_limbs); - m_vec_mul_add_x (m_vec_limbs, bins + 4 * m_vec_limbs, bins + 2 * m_vec_limbs); - m_vec_mul_add_x_inv (m_vec_limbs, bins + 9 * m_vec_limbs, bins + 1 * m_vec_limbs); - m_vec_mul_add_x (m_vec_limbs, bins + 2 * m_vec_limbs, bins + 1 * m_vec_limbs); - m_vec_copy (m_vec_limbs, bins + m_vec_limbs, out); + m_vec_mul_add_x_inv (m_vec_limbs, bins + 5 * m_vec_limbs, bins + 10 * m_vec_limbs); + m_vec_mul_add_x (m_vec_limbs, bins + 11 * m_vec_limbs, bins + 12 * m_vec_limbs); + m_vec_mul_add_x_inv (m_vec_limbs, bins + 10 * m_vec_limbs, bins + 7 * m_vec_limbs); + m_vec_mul_add_x (m_vec_limbs, bins + 12 * m_vec_limbs, bins + 6 * m_vec_limbs); + m_vec_mul_add_x_inv (m_vec_limbs, bins + 7 * m_vec_limbs, bins + 14 * m_vec_limbs); + m_vec_mul_add_x (m_vec_limbs, bins + 6 * m_vec_limbs, bins + 3 * m_vec_limbs); + m_vec_mul_add_x_inv (m_vec_limbs, bins + 14 * m_vec_limbs, bins + 15 * m_vec_limbs); + m_vec_mul_add_x (m_vec_limbs, bins + 3 * m_vec_limbs, bins + 8 * m_vec_limbs); + m_vec_mul_add_x_inv (m_vec_limbs, bins + 15 * m_vec_limbs, bins + 13 * m_vec_limbs); + m_vec_mul_add_x (m_vec_limbs, bins + 8 * m_vec_limbs, bins + 4 * m_vec_limbs); + m_vec_mul_add_x_inv (m_vec_limbs, bins + 13 * m_vec_limbs, bins + 9 * m_vec_limbs); + m_vec_mul_add_x (m_vec_limbs, bins + 4 * m_vec_limbs, bins + 2 * m_vec_limbs); + m_vec_mul_add_x_inv (m_vec_limbs, bins + 9 * m_vec_limbs, bins + 1 * m_vec_limbs); + m_vec_mul_add_x (m_vec_limbs, bins + 2 * m_vec_limbs, bins + 1 * m_vec_limbs); + m_vec_copy (m_vec_limbs, bins + m_vec_limbs, out); } -#endif \ No newline at end of file +#endif diff --git a/lib/mayo/arithmetic_fixed.h b/lib/mayo/arithmetic_fixed.h index bd0ccf27f..2993d36d1 100644 --- a/lib/mayo/arithmetic_fixed.h +++ b/lib/mayo/arithmetic_fixed.h @@ -11,74 +11,74 @@ static inline void m_vec_copy (int m_vec_limbs, const uint64_t *in, uint64_t *out) { - (void) m_vec_limbs; - for (size_t i = 0; i < M_VEC_LIMBS_MAX; i++) - { - out[i] = in[i]; - } + (void) m_vec_limbs; + for (size_t i = 0; i < M_VEC_LIMBS_MAX; i++) + { + out[i] = in[i]; + } } static inline void m_vec_add (int m_vec_limbs, const uint64_t *in, uint64_t *acc) { - (void) m_vec_limbs; - for (size_t i = 0; i < M_VEC_LIMBS_MAX; i++) - { - acc[i] ^= in[i]; - } + (void) m_vec_limbs; + for (size_t i = 0; i < M_VEC_LIMBS_MAX; i++) + { + acc[i] ^= in[i]; + } } static inline void m_vec_mul_add (int m_vec_limbs, const uint64_t *in, unsigned char a, uint64_t *acc) { - (void) m_vec_limbs; - uint32_t tab = mul_table(a); + (void) m_vec_limbs; + uint32_t tab = mul_table(a); - uint64_t lsb_ask = 0x1111111111111111ULL; + uint64_t lsb_ask = 0x1111111111111111ULL; - for(int i=0; i < M_VEC_LIMBS_MAX ;i++){ - acc[i] ^= ( in[i] & lsb_ask) * (tab & 0xff) - ^ ((in[i] >> 1) & lsb_ask) * ((tab >> 8) & 0xf) - ^ ((in[i] >> 2) & lsb_ask) * ((tab >> 16) & 0xf) - ^ ((in[i] >> 3) & lsb_ask) * ((tab >> 24) & 0xf); - } + for(int i=0; i < M_VEC_LIMBS_MAX ;i++){ + acc[i] ^= ( in[i] & lsb_ask) * (tab & 0xff) + ^ ((in[i] >> 1) & lsb_ask) * ((tab >> 8) & 0xf) + ^ ((in[i] >> 2) & lsb_ask) * ((tab >> 16) & 0xf) + ^ ((in[i] >> 3) & lsb_ask) * ((tab >> 24) & 0xf); + } } inline static void m_vec_mul_add_x (int m_vec_limbs, const uint64_t *in, uint64_t *acc) { - (void) m_vec_limbs; - uint64_t mask_msb = 0x8888888888888888ULL; - for(int i=0; i < M_VEC_LIMBS_MAX; i++){ - uint64_t t = in[i] & mask_msb; - acc[i] ^= ((in[i] ^ t) << 1) ^ ((t >> 3) * 3); - } + (void) m_vec_limbs; + uint64_t mask_msb = 0x8888888888888888ULL; + for(int i=0; i < M_VEC_LIMBS_MAX; i++){ + uint64_t t = in[i] & mask_msb; + acc[i] ^= ((in[i] ^ t) << 1) ^ ((t >> 3) * 3); + } } inline static void m_vec_mul_add_x_inv (int m_vec_limbs, const uint64_t *in, uint64_t *acc) { - (void) m_vec_limbs; - uint64_t mask_lsb = 0x1111111111111111ULL; - for(int i=0; i < M_VEC_LIMBS_MAX; i++){ - uint64_t t = in[i] & mask_lsb; - acc[i] ^= ((in[i] ^ t) >> 1) ^ (t * 9); - } + (void) m_vec_limbs; + uint64_t mask_lsb = 0x1111111111111111ULL; + for(int i=0; i < M_VEC_LIMBS_MAX; i++){ + uint64_t t = in[i] & mask_lsb; + acc[i] ^= ((in[i] ^ t) >> 1) ^ (t * 9); + } } static inline void m_vec_multiply_bins (int m_vec_limbs, uint64_t *bins, uint64_t *out) { - m_vec_mul_add_x_inv (m_vec_limbs, bins + 5 * M_VEC_LIMBS_MAX, bins + 10 * M_VEC_LIMBS_MAX); - m_vec_mul_add_x (m_vec_limbs, bins + 11 * M_VEC_LIMBS_MAX, bins + 12 * M_VEC_LIMBS_MAX); - m_vec_mul_add_x_inv (m_vec_limbs, bins + 10 * M_VEC_LIMBS_MAX, bins + 7 * M_VEC_LIMBS_MAX); - m_vec_mul_add_x (m_vec_limbs, bins + 12 * M_VEC_LIMBS_MAX, bins + 6 * M_VEC_LIMBS_MAX); - m_vec_mul_add_x_inv (m_vec_limbs, bins + 7 * M_VEC_LIMBS_MAX, bins + 14 * M_VEC_LIMBS_MAX); - m_vec_mul_add_x (m_vec_limbs, bins + 6 * M_VEC_LIMBS_MAX, bins + 3 * M_VEC_LIMBS_MAX); - m_vec_mul_add_x_inv (m_vec_limbs, bins + 14 * M_VEC_LIMBS_MAX, bins + 15 * M_VEC_LIMBS_MAX); - m_vec_mul_add_x (m_vec_limbs, bins + 3 * M_VEC_LIMBS_MAX, bins + 8 * M_VEC_LIMBS_MAX); - m_vec_mul_add_x_inv (m_vec_limbs, bins + 15 * M_VEC_LIMBS_MAX, bins + 13 * M_VEC_LIMBS_MAX); - m_vec_mul_add_x (m_vec_limbs, bins + 8 * M_VEC_LIMBS_MAX, bins + 4 * M_VEC_LIMBS_MAX); - m_vec_mul_add_x_inv (m_vec_limbs, bins + 13 * M_VEC_LIMBS_MAX, bins + 9 * M_VEC_LIMBS_MAX); - m_vec_mul_add_x (m_vec_limbs, bins + 4 * M_VEC_LIMBS_MAX, bins + 2 * M_VEC_LIMBS_MAX); - m_vec_mul_add_x_inv (m_vec_limbs, bins + 9 * M_VEC_LIMBS_MAX, bins + 1 * M_VEC_LIMBS_MAX); - m_vec_mul_add_x (m_vec_limbs, bins + 2 * M_VEC_LIMBS_MAX, bins + 1 * M_VEC_LIMBS_MAX); - m_vec_copy (m_vec_limbs, bins + M_VEC_LIMBS_MAX, out); + m_vec_mul_add_x_inv (m_vec_limbs, bins + 5 * M_VEC_LIMBS_MAX, bins + 10 * M_VEC_LIMBS_MAX); + m_vec_mul_add_x (m_vec_limbs, bins + 11 * M_VEC_LIMBS_MAX, bins + 12 * M_VEC_LIMBS_MAX); + m_vec_mul_add_x_inv (m_vec_limbs, bins + 10 * M_VEC_LIMBS_MAX, bins + 7 * M_VEC_LIMBS_MAX); + m_vec_mul_add_x (m_vec_limbs, bins + 12 * M_VEC_LIMBS_MAX, bins + 6 * M_VEC_LIMBS_MAX); + m_vec_mul_add_x_inv (m_vec_limbs, bins + 7 * M_VEC_LIMBS_MAX, bins + 14 * M_VEC_LIMBS_MAX); + m_vec_mul_add_x (m_vec_limbs, bins + 6 * M_VEC_LIMBS_MAX, bins + 3 * M_VEC_LIMBS_MAX); + m_vec_mul_add_x_inv (m_vec_limbs, bins + 14 * M_VEC_LIMBS_MAX, bins + 15 * M_VEC_LIMBS_MAX); + m_vec_mul_add_x (m_vec_limbs, bins + 3 * M_VEC_LIMBS_MAX, bins + 8 * M_VEC_LIMBS_MAX); + m_vec_mul_add_x_inv (m_vec_limbs, bins + 15 * M_VEC_LIMBS_MAX, bins + 13 * M_VEC_LIMBS_MAX); + m_vec_mul_add_x (m_vec_limbs, bins + 8 * M_VEC_LIMBS_MAX, bins + 4 * M_VEC_LIMBS_MAX); + m_vec_mul_add_x_inv (m_vec_limbs, bins + 13 * M_VEC_LIMBS_MAX, bins + 9 * M_VEC_LIMBS_MAX); + m_vec_mul_add_x (m_vec_limbs, bins + 4 * M_VEC_LIMBS_MAX, bins + 2 * M_VEC_LIMBS_MAX); + m_vec_mul_add_x_inv (m_vec_limbs, bins + 9 * M_VEC_LIMBS_MAX, bins + 1 * M_VEC_LIMBS_MAX); + m_vec_mul_add_x (m_vec_limbs, bins + 2 * M_VEC_LIMBS_MAX, bins + 1 * M_VEC_LIMBS_MAX); + m_vec_copy (m_vec_limbs, bins + M_VEC_LIMBS_MAX, out); } #endif diff --git a/lib/mayo/debug_bench_tools.h b/lib/mayo/debug_bench_tools.h index 8d1259289..5666e6046 100644 --- a/lib/mayo/debug_bench_tools.h +++ b/lib/mayo/debug_bench_tools.h @@ -8,27 +8,27 @@ static inline int64_t cpucycles(void) { #if (defined(TARGET_AMD64) || defined(TARGET_X86)) - unsigned int hi, lo; + unsigned int hi, lo; - asm volatile ("rdtsc" : "=a" (lo), "=d"(hi)); - return ((int64_t) lo) | (((int64_t) hi) << 32); + asm volatile ("rdtsc" : "=a" (lo), "=d"(hi)); + return ((int64_t) lo) | (((int64_t) hi) << 32); #elif (defined(TARGET_S390X)) - uint64_t tod; - asm volatile("stckf %0\n" : "=Q" (tod) : : "cc"); - return (tod * 1000 / 4096); + uint64_t tod; + asm volatile("stckf %0\n" : "=Q" (tod) : : "cc"); + return (tod * 1000 / 4096); #else - struct timespec time; - clock_gettime(CLOCK_REALTIME, &time); - return (int64_t)(time.tv_sec * 1e9 + time.tv_nsec); + struct timespec time; + clock_gettime(CLOCK_REALTIME, &time); + return (int64_t)(time.tv_sec * 1e9 + time.tv_nsec); #endif } #ifdef TICTOC #define TIC printf("\n"); \ - int64_t tic_toc_cycles = cpucycles(); + int64_t tic_toc_cycles = cpucycles(); #define TOC(name) printf(" %-30s cycles: %lu \n", name, cpucycles() - tic_toc_cycles); \ - tic_toc_cycles = cpucycles(); + tic_toc_cycles = cpucycles(); #else #define TIC #define TOC(name) @@ -39,28 +39,28 @@ static inline int64_t cpucycles(void) { #include static inline void print_avx2(__m256i a){ - unsigned char *temp = (unsigned char*) &a; - for (size_t i = 0; i < 32; i++) - { - printf("%X", temp[i] & 0xf); - printf("%X", temp[i] >> 4); - if(i%4 == 3){ - printf(" "); - } - } - printf("\n"); + unsigned char *temp = (unsigned char*) &a; + for (size_t i = 0; i < 32; i++) + { + printf("%X", temp[i] & 0xf); + printf("%X", temp[i] >> 4); + if(i%4 == 3){ + printf(" "); + } + } + printf("\n"); } static inline void print_avx2_(__m256i a){ - unsigned char *temp = (unsigned char*) &a; - for (size_t i = 0; i < 32; i++) - { - printf("%X", temp[i] & 0xf); - printf("%X", temp[i] >> 4); - if(i%4 == 3){ - printf(" "); - } - } + unsigned char *temp = (unsigned char*) &a; + for (size_t i = 0; i < 32; i++) + { + printf("%X", temp[i] & 0xf); + printf("%X", temp[i] >> 4); + if(i%4 == 3){ + printf(" "); + } + } } #endif diff --git a/lib/mayo/echelon_form.h b/lib/mayo/echelon_form.h index 5a171f5a5..e6eed5669 100644 --- a/lib/mayo/echelon_form.h +++ b/lib/mayo/echelon_form.h @@ -14,44 +14,44 @@ static inline unsigned char m_extract_element(const uint64_t *in, int index) { - const int leg = index / 16; - const int offset = index % 16; + const int leg = index / 16; + const int offset = index % 16; - return (in[leg] >> (offset*4)) & 0xF; + return (in[leg] >> (offset*4)) & 0xF; } static inline void ef_pack_m_vec(const unsigned char *in, uint64_t *out, int ncols) { - int i; - unsigned char *out8 = (unsigned char *)out; - for(i = 0; i+1 < ncols; i += 2){ + int i; + unsigned char *out8 = (unsigned char *)out; + for(i = 0; i+1 < ncols; i += 2){ #ifdef TARGET_BIG_ENDIAN - out8[(((i/2 + 8) / 8) * 8) - 1 - (i/2)%8] = (in[i+0] << 0) | (in[i+1] << 4); + out8[(((i/2 + 8) / 8) * 8) - 1 - (i/2)%8] = (in[i+0] << 0) | (in[i+1] << 4); #else - out8[i/2] = (in[i+0] << 0) | (in[i+1] << 4); + out8[i/2] = (in[i+0] << 0) | (in[i+1] << 4); #endif - } - if (ncols % 2 == 1){ + } + if (ncols % 2 == 1){ #ifdef TARGET_BIG_ENDIAN - out8[(((i/2 + 8) / 8) * 8) - 1 - (i/2)%8] = (in[i+0] << 0); + out8[(((i/2 + 8) / 8) * 8) - 1 - (i/2)%8] = (in[i+0] << 0); #else - out8[i/2] = (in[i+0] << 0); + out8[i/2] = (in[i+0] << 0); #endif - } + } } static inline void ef_unpack_m_vec(int legs, const uint64_t *in, unsigned char *out) { - const unsigned char *in8 = (const unsigned char *)in; - for(int i = 0; i < legs * 16; i += 2){ + const unsigned char *in8 = (const unsigned char *)in; + for(int i = 0; i < legs * 16; i += 2){ #ifdef TARGET_BIG_ENDIAN - out[i] = (in8[(((i/2 + 8) / 8) * 8) - 1 - (i/2)%8]) & 0xF; - out[i+1] = (in8[(((i/2 + 8) / 8) * 8) - 1 - (i/2)%8] >> 4); + out[i] = (in8[(((i/2 + 8) / 8) * 8) - 1 - (i/2)%8]) & 0xF; + out[i+1] = (in8[(((i/2 + 8) / 8) * 8) - 1 - (i/2)%8] >> 4); #else - out[i] = (in8[i/2]) & 0xF; - out[i+1] = (in8[i/2] >> 4); + out[i] = (in8[i/2]) & 0xF; + out[i+1] = (in8[i/2] >> 4); #endif - } + } } @@ -59,93 +59,93 @@ ef_unpack_m_vec(int legs, const uint64_t *in, unsigned char *out) { // constant time* static inline void EF(unsigned char *A, int nrows, int ncols) { - alignas (32) uint64_t _pivot_row[(K_MAX * O_MAX + 1 + 15) / 16]; - alignas (32) uint64_t _pivot_row2[(K_MAX * O_MAX + 1 + 15) / 16]; - alignas (32) uint64_t packed_A[((K_MAX * O_MAX + 1 + 15) / 16) * M_MAX] = {0}; - - int row_len = (ncols + 15) / 16; - - // nibbleslice the matrix A - for (int i = 0; i < nrows; i++) { - ef_pack_m_vec(A + i * ncols, packed_A + i * row_len, ncols); - } - - // pivot row is secret, pivot col is not - - unsigned char inverse; - int pivot_row = 0; - for (int pivot_col = 0; pivot_col < ncols; pivot_col++) { - - int pivot_row_lower_bound = MAYO_MAX(0, pivot_col + nrows - ncols); - int pivot_row_upper_bound = MAYO_MIN(nrows - 1, pivot_col); - // the pivot row is guaranteed to be between these lower and upper bounds if - // A has full rank - - // zero out pivot row - for (int i = 0; i < row_len; i++) { - _pivot_row[i] = 0; - _pivot_row2[i] = 0; - } - - // try to get a pivot row in constant time - unsigned char pivot = 0; - uint64_t pivot_is_zero = -1; - for (int row = pivot_row_lower_bound; - row <= MAYO_MIN(nrows - 1, pivot_row_upper_bound + 32); row++) { - - uint64_t is_pivot_row = ~ct_compare_64(row, pivot_row); - uint64_t below_pivot_row = ct_64_is_greater_than(row, pivot_row); - - for (int j = 0; j < row_len; j++) { - _pivot_row[j] ^= (is_pivot_row | (below_pivot_row & pivot_is_zero)) & - packed_A[row * row_len + j]; - } - pivot = m_extract_element(_pivot_row, pivot_col); - pivot_is_zero = ~ct_compare_64((int) pivot, 0); - } - - // multiply pivot row by inverse of pivot - inverse = inverse_f(pivot); - vec_mul_add_u64(row_len, _pivot_row, inverse, _pivot_row2); - - // conditionally write pivot row to the correct row, if there is a nonzero - // pivot - for (int row = pivot_row_lower_bound; row <= pivot_row_upper_bound; row++) { - uint64_t do_copy = ~ct_compare_64(row, pivot_row) & ~pivot_is_zero; - uint64_t do_not_copy = ~do_copy; - for (int col = 0; col < row_len; col++) { - packed_A[row * row_len + col] = - (do_not_copy & packed_A[row * row_len + col]) + - (do_copy & _pivot_row2[col]); - } - } - - // eliminate entries below pivot - for (int row = pivot_row_lower_bound; row < nrows; row++) { - unsigned char below_pivot = (row > pivot_row); - unsigned char elt_to_elim = m_extract_element(packed_A + row * row_len, pivot_col); - - vec_mul_add_u64(row_len, _pivot_row2, below_pivot * elt_to_elim, - packed_A + row * row_len); - } - - pivot_row += (-(int64_t)(~pivot_is_zero)); - } - - unsigned char temp[(O_MAX * K_MAX + 1 + 15)]; - - // unbitslice the matrix A - for (int i = 0; i < nrows; i++) { - ef_unpack_m_vec(row_len, packed_A + i * row_len, temp); - for (int j = 0; j < ncols; j++) { - A[i * ncols + j] = temp[j]; - } - } - - mayo_secure_clear(temp, K_MAX * O_MAX + 1 + 15); - mayo_secure_clear(_pivot_row, (K_MAX * O_MAX + 1 + 15) / 16 * 8); - mayo_secure_clear(_pivot_row2, (K_MAX * O_MAX + 1 + 15) / 16 * 8); - mayo_secure_clear(packed_A, ((K_MAX * O_MAX + 1 + 15) / 16) * M_MAX * 8); + alignas (32) uint64_t _pivot_row[(K_MAX * O_MAX + 1 + 15) / 16]; + alignas (32) uint64_t _pivot_row2[(K_MAX * O_MAX + 1 + 15) / 16]; + alignas (32) uint64_t packed_A[((K_MAX * O_MAX + 1 + 15) / 16) * M_MAX] = {0}; + + int row_len = (ncols + 15) / 16; + + // nibbleslice the matrix A + for (int i = 0; i < nrows; i++) { + ef_pack_m_vec(A + i * ncols, packed_A + i * row_len, ncols); + } + + // pivot row is secret, pivot col is not + + unsigned char inverse; + int pivot_row = 0; + for (int pivot_col = 0; pivot_col < ncols; pivot_col++) { + + int pivot_row_lower_bound = MAYO_MAX(0, pivot_col + nrows - ncols); + int pivot_row_upper_bound = MAYO_MIN(nrows - 1, pivot_col); + // the pivot row is guaranteed to be between these lower and upper bounds if + // A has full rank + + // zero out pivot row + for (int i = 0; i < row_len; i++) { + _pivot_row[i] = 0; + _pivot_row2[i] = 0; + } + + // try to get a pivot row in constant time + unsigned char pivot = 0; + uint64_t pivot_is_zero = -1; + for (int row = pivot_row_lower_bound; + row <= MAYO_MIN(nrows - 1, pivot_row_upper_bound + 32); row++) { + + uint64_t is_pivot_row = ~ct_compare_64(row, pivot_row); + uint64_t below_pivot_row = ct_64_is_greater_than(row, pivot_row); + + for (int j = 0; j < row_len; j++) { + _pivot_row[j] ^= (is_pivot_row | (below_pivot_row & pivot_is_zero)) & + packed_A[row * row_len + j]; + } + pivot = m_extract_element(_pivot_row, pivot_col); + pivot_is_zero = ~ct_compare_64((int) pivot, 0); + } + + // multiply pivot row by inverse of pivot + inverse = inverse_f(pivot); + vec_mul_add_u64(row_len, _pivot_row, inverse, _pivot_row2); + + // conditionally write pivot row to the correct row, if there is a nonzero + // pivot + for (int row = pivot_row_lower_bound; row <= pivot_row_upper_bound; row++) { + uint64_t do_copy = ~ct_compare_64(row, pivot_row) & ~pivot_is_zero; + uint64_t do_not_copy = ~do_copy; + for (int col = 0; col < row_len; col++) { + packed_A[row * row_len + col] = + (do_not_copy & packed_A[row * row_len + col]) + + (do_copy & _pivot_row2[col]); + } + } + + // eliminate entries below pivot + for (int row = pivot_row_lower_bound; row < nrows; row++) { + unsigned char below_pivot = (row > pivot_row); + unsigned char elt_to_elim = m_extract_element(packed_A + row * row_len, pivot_col); + + vec_mul_add_u64(row_len, _pivot_row2, below_pivot * elt_to_elim, + packed_A + row * row_len); + } + + pivot_row += (-(int64_t)(~pivot_is_zero)); + } + + unsigned char temp[(O_MAX * K_MAX + 1 + 15)]; + + // unbitslice the matrix A + for (int i = 0; i < nrows; i++) { + ef_unpack_m_vec(row_len, packed_A + i * row_len, temp); + for (int j = 0; j < ncols; j++) { + A[i * ncols + j] = temp[j]; + } + } + + mayo_secure_clear(temp, K_MAX * O_MAX + 1 + 15); + mayo_secure_clear(_pivot_row, (K_MAX * O_MAX + 1 + 15) / 16 * 8); + mayo_secure_clear(_pivot_row2, (K_MAX * O_MAX + 1 + 15) / 16 * 8); + mayo_secure_clear(packed_A, ((K_MAX * O_MAX + 1 + 15) / 16) * M_MAX * 8); } #endif diff --git a/lib/mayo/ef_inner_loop.h b/lib/mayo/ef_inner_loop.h index 52b43d913..3725f979e 100644 --- a/lib/mayo/ef_inner_loop.h +++ b/lib/mayo/ef_inner_loop.h @@ -7,25 +7,25 @@ int pivot_row_upper_bound = MAYO_MIN(nrows - 1, pivot_col); // zero out pivot row for (int i = offset; i < row_len; i++) { - _pivot_row[i] = 0; - _pivot_row2[i] = 0; + _pivot_row[i] = 0; + _pivot_row2[i] = 0; } // try to get a pivot row in constant time unsigned char pivot = 0; uint64_t pivot_is_zero = -1; for (int row = pivot_row_lower_bound; - row <= MAYO_MIN(nrows - 1, pivot_row_upper_bound + 32); row++) { + row <= MAYO_MIN(nrows - 1, pivot_row_upper_bound + 32); row++) { - uint64_t is_pivot_row = ~ct_compare_64(row, pivot_row); - uint64_t below_pivot_row = ct_64_is_greater_than(row, pivot_row); + uint64_t is_pivot_row = ~ct_compare_64(row, pivot_row); + uint64_t below_pivot_row = ct_64_is_greater_than(row, pivot_row); - for (int j = offset; j < row_len; j++) { - _pivot_row[j] ^= (is_pivot_row | (below_pivot_row & pivot_is_zero)) & - packed_A[row * row_len + j]; - } - pivot = m_extract_element(_pivot_row, pivot_col); - pivot_is_zero = ~ct_compare_64((int) pivot, 0); + for (int j = offset; j < row_len; j++) { + _pivot_row[j] ^= (is_pivot_row | (below_pivot_row & pivot_is_zero)) & + packed_A[row * row_len + j]; + } + pivot = m_extract_element(_pivot_row, pivot_col); + pivot_is_zero = ~ct_compare_64((int) pivot, 0); } // multiply pivot row by inverse of pivot @@ -35,22 +35,22 @@ vec_mul_add_u64(row_len - offset, _pivot_row + offset, inverse, _pivot_row2 + of // conditionally write pivot row to the correct row, if there is a nonzero // pivot for (int row = pivot_row_lower_bound; row <= pivot_row_upper_bound; row++) { - uint64_t do_copy = ~ct_compare_64(row, pivot_row) & ~pivot_is_zero; - uint64_t do_not_copy = ~do_copy; - for (int col = offset; col < row_len; col++) { - packed_A[row * row_len + col] = - (do_not_copy & packed_A[row * row_len + col]) + - (do_copy & _pivot_row2[col]); - } + uint64_t do_copy = ~ct_compare_64(row, pivot_row) & ~pivot_is_zero; + uint64_t do_not_copy = ~do_copy; + for (int col = offset; col < row_len; col++) { + packed_A[row * row_len + col] = + (do_not_copy & packed_A[row * row_len + col]) + + (do_copy & _pivot_row2[col]); + } } // eliminate entries below pivot for (int row = pivot_row_lower_bound; row < nrows; row++) { - unsigned char below_pivot = (row > pivot_row); - unsigned char elt_to_elim = m_extract_element(packed_A + row * row_len, pivot_col); + unsigned char below_pivot = (row > pivot_row); + unsigned char elt_to_elim = m_extract_element(packed_A + row * row_len, pivot_col); - vec_mul_add_u64(row_len - offset, _pivot_row2 + offset, below_pivot * elt_to_elim, - packed_A + row * row_len + offset); + vec_mul_add_u64(row_len - offset, _pivot_row2 + offset, below_pivot * elt_to_elim, + packed_A + row * row_len + offset); } pivot_row += (-(int32_t)(~pivot_is_zero)); diff --git a/lib/mayo/fips202.c b/lib/mayo/fips202.c index 1a5475a4e..5ad883a21 100644 --- a/lib/mayo/fips202.c +++ b/lib/mayo/fips202.c @@ -27,37 +27,37 @@ // Context for incremental API typedef struct { - uint64_t *ctx; + uint64_t *ctx; } shake128incctx; // Context for non-incremental API typedef struct { - uint64_t *ctx; + uint64_t *ctx; } shake128ctx; // Context for incremental API typedef struct { - uint64_t *ctx; + uint64_t *ctx; } shake256incctx; // Context for non-incremental API typedef struct { - uint64_t *ctx; + uint64_t *ctx; } shake256ctx; // Context for incremental API typedef struct { - uint64_t *ctx; + uint64_t *ctx; } sha3_256incctx; // Context for incremental API typedef struct { - uint64_t *ctx; + uint64_t *ctx; } sha3_384incctx; // Context for incremental API typedef struct { - uint64_t *ctx; + uint64_t *ctx; } sha3_512incctx; /* Initialize the state and absorb the provided input. @@ -128,11 +128,11 @@ void shake256_inc_ctx_release(shake256incctx *state); /* One-stop SHAKE128 call */ void shake128(uint8_t *output, size_t outlen, - const uint8_t *input, size_t inlen); + const uint8_t *input, size_t inlen); /* One-stop SHAKE256 call */ void shake256(uint8_t *output, size_t outlen, - const uint8_t *input, size_t inlen); + const uint8_t *input, size_t inlen); /* Initialize the incremental hashing state */ void sha3_256_inc_init(sha3_256incctx *state); @@ -188,12 +188,12 @@ void sha3_512(uint8_t *output, const uint8_t *input, size_t inlen); * Returns the loaded 64-bit unsigned integer **************************************************/ static uint64_t load64(const uint8_t *x) { - uint64_t r = 0; - for (size_t i = 0; i < 8; ++i) { - r |= (uint64_t)x[i] << 8 * i; - } + uint64_t r = 0; + for (size_t i = 0; i < 8; ++i) { + r |= (uint64_t)x[i] << 8 * i; + } - return r; + return r; } /************************************************* @@ -205,25 +205,25 @@ static uint64_t load64(const uint8_t *x) { * - uint64_t u: input 64-bit unsigned integer **************************************************/ static void store64(uint8_t *x, uint64_t u) { - for (size_t i = 0; i < 8; ++i) { - x[i] = (uint8_t) (u >> 8 * i); - } + for (size_t i = 0; i < 8; ++i) { + x[i] = (uint8_t) (u >> 8 * i); + } } /* Keccak round constants */ static const uint64_t KeccakF_RoundConstants[NROUNDS] = { - 0x0000000000000001ULL, 0x0000000000008082ULL, - 0x800000000000808aULL, 0x8000000080008000ULL, - 0x000000000000808bULL, 0x0000000080000001ULL, - 0x8000000080008081ULL, 0x8000000000008009ULL, - 0x000000000000008aULL, 0x0000000000000088ULL, - 0x0000000080008009ULL, 0x000000008000000aULL, - 0x000000008000808bULL, 0x800000000000008bULL, - 0x8000000000008089ULL, 0x8000000000008003ULL, - 0x8000000000008002ULL, 0x8000000000000080ULL, - 0x000000000000800aULL, 0x800000008000000aULL, - 0x8000000080008081ULL, 0x8000000000008080ULL, - 0x0000000080000001ULL, 0x8000000080008008ULL + 0x0000000000000001ULL, 0x0000000000008082ULL, + 0x800000000000808aULL, 0x8000000080008000ULL, + 0x000000000000808bULL, 0x0000000080000001ULL, + 0x8000000080008081ULL, 0x8000000000008009ULL, + 0x000000000000008aULL, 0x0000000000000088ULL, + 0x0000000080008009ULL, 0x000000008000000aULL, + 0x000000008000808bULL, 0x800000000000008bULL, + 0x8000000000008089ULL, 0x8000000000008003ULL, + 0x8000000000008002ULL, 0x8000000000000080ULL, + 0x000000000000800aULL, 0x800000008000000aULL, + 0x8000000080008081ULL, 0x8000000000008080ULL, + 0x0000000080000001ULL, 0x8000000080008008ULL }; /************************************************* @@ -234,266 +234,266 @@ static const uint64_t KeccakF_RoundConstants[NROUNDS] = { * Arguments: - uint64_t *state: pointer to input/output Keccak state **************************************************/ static void KeccakF1600_StatePermute(uint64_t *state) { - int round; - - uint64_t Aba, Abe, Abi, Abo, Abu; - uint64_t Aga, Age, Agi, Ago, Agu; - uint64_t Aka, Ake, Aki, Ako, Aku; - uint64_t Ama, Ame, Ami, Amo, Amu; - uint64_t Asa, Ase, Asi, Aso, Asu; - uint64_t BCa, BCe, BCi, BCo, BCu; - uint64_t Da, De, Di, Do, Du; - uint64_t Eba, Ebe, Ebi, Ebo, Ebu; - uint64_t Ega, Ege, Egi, Ego, Egu; - uint64_t Eka, Eke, Eki, Eko, Eku; - uint64_t Ema, Eme, Emi, Emo, Emu; - uint64_t Esa, Ese, Esi, Eso, Esu; - - // copyFromState(A, state) - Aba = state[0]; - Abe = state[1]; - Abi = state[2]; - Abo = state[3]; - Abu = state[4]; - Aga = state[5]; - Age = state[6]; - Agi = state[7]; - Ago = state[8]; - Agu = state[9]; - Aka = state[10]; - Ake = state[11]; - Aki = state[12]; - Ako = state[13]; - Aku = state[14]; - Ama = state[15]; - Ame = state[16]; - Ami = state[17]; - Amo = state[18]; - Amu = state[19]; - Asa = state[20]; - Ase = state[21]; - Asi = state[22]; - Aso = state[23]; - Asu = state[24]; - - for (round = 0; round < NROUNDS; round += 2) { - // prepareTheta - BCa = Aba ^ Aga ^ Aka ^ Ama ^ Asa; - BCe = Abe ^ Age ^ Ake ^ Ame ^ Ase; - BCi = Abi ^ Agi ^ Aki ^ Ami ^ Asi; - BCo = Abo ^ Ago ^ Ako ^ Amo ^ Aso; - BCu = Abu ^ Agu ^ Aku ^ Amu ^ Asu; - - // thetaRhoPiChiIotaPrepareTheta(round , A, E) - Da = BCu ^ ROL(BCe, 1); - De = BCa ^ ROL(BCi, 1); - Di = BCe ^ ROL(BCo, 1); - Do = BCi ^ ROL(BCu, 1); - Du = BCo ^ ROL(BCa, 1); - - Aba ^= Da; - BCa = Aba; - Age ^= De; - BCe = ROL(Age, 44); - Aki ^= Di; - BCi = ROL(Aki, 43); - Amo ^= Do; - BCo = ROL(Amo, 21); - Asu ^= Du; - BCu = ROL(Asu, 14); - Eba = BCa ^ ((~BCe) & BCi); - Eba ^= KeccakF_RoundConstants[round]; - Ebe = BCe ^ ((~BCi) & BCo); - Ebi = BCi ^ ((~BCo) & BCu); - Ebo = BCo ^ ((~BCu) & BCa); - Ebu = BCu ^ ((~BCa) & BCe); - - Abo ^= Do; - BCa = ROL(Abo, 28); - Agu ^= Du; - BCe = ROL(Agu, 20); - Aka ^= Da; - BCi = ROL(Aka, 3); - Ame ^= De; - BCo = ROL(Ame, 45); - Asi ^= Di; - BCu = ROL(Asi, 61); - Ega = BCa ^ ((~BCe) & BCi); - Ege = BCe ^ ((~BCi) & BCo); - Egi = BCi ^ ((~BCo) & BCu); - Ego = BCo ^ ((~BCu) & BCa); - Egu = BCu ^ ((~BCa) & BCe); - - Abe ^= De; - BCa = ROL(Abe, 1); - Agi ^= Di; - BCe = ROL(Agi, 6); - Ako ^= Do; - BCi = ROL(Ako, 25); - Amu ^= Du; - BCo = ROL(Amu, 8); - Asa ^= Da; - BCu = ROL(Asa, 18); - Eka = BCa ^ ((~BCe) & BCi); - Eke = BCe ^ ((~BCi) & BCo); - Eki = BCi ^ ((~BCo) & BCu); - Eko = BCo ^ ((~BCu) & BCa); - Eku = BCu ^ ((~BCa) & BCe); - - Abu ^= Du; - BCa = ROL(Abu, 27); - Aga ^= Da; - BCe = ROL(Aga, 36); - Ake ^= De; - BCi = ROL(Ake, 10); - Ami ^= Di; - BCo = ROL(Ami, 15); - Aso ^= Do; - BCu = ROL(Aso, 56); - Ema = BCa ^ ((~BCe) & BCi); - Eme = BCe ^ ((~BCi) & BCo); - Emi = BCi ^ ((~BCo) & BCu); - Emo = BCo ^ ((~BCu) & BCa); - Emu = BCu ^ ((~BCa) & BCe); - - Abi ^= Di; - BCa = ROL(Abi, 62); - Ago ^= Do; - BCe = ROL(Ago, 55); - Aku ^= Du; - BCi = ROL(Aku, 39); - Ama ^= Da; - BCo = ROL(Ama, 41); - Ase ^= De; - BCu = ROL(Ase, 2); - Esa = BCa ^ ((~BCe) & BCi); - Ese = BCe ^ ((~BCi) & BCo); - Esi = BCi ^ ((~BCo) & BCu); - Eso = BCo ^ ((~BCu) & BCa); - Esu = BCu ^ ((~BCa) & BCe); - - // prepareTheta - BCa = Eba ^ Ega ^ Eka ^ Ema ^ Esa; - BCe = Ebe ^ Ege ^ Eke ^ Eme ^ Ese; - BCi = Ebi ^ Egi ^ Eki ^ Emi ^ Esi; - BCo = Ebo ^ Ego ^ Eko ^ Emo ^ Eso; - BCu = Ebu ^ Egu ^ Eku ^ Emu ^ Esu; - - // thetaRhoPiChiIotaPrepareTheta(round+1, E, A) - Da = BCu ^ ROL(BCe, 1); - De = BCa ^ ROL(BCi, 1); - Di = BCe ^ ROL(BCo, 1); - Do = BCi ^ ROL(BCu, 1); - Du = BCo ^ ROL(BCa, 1); - - Eba ^= Da; - BCa = Eba; - Ege ^= De; - BCe = ROL(Ege, 44); - Eki ^= Di; - BCi = ROL(Eki, 43); - Emo ^= Do; - BCo = ROL(Emo, 21); - Esu ^= Du; - BCu = ROL(Esu, 14); - Aba = BCa ^ ((~BCe) & BCi); - Aba ^= KeccakF_RoundConstants[round + 1]; - Abe = BCe ^ ((~BCi) & BCo); - Abi = BCi ^ ((~BCo) & BCu); - Abo = BCo ^ ((~BCu) & BCa); - Abu = BCu ^ ((~BCa) & BCe); - - Ebo ^= Do; - BCa = ROL(Ebo, 28); - Egu ^= Du; - BCe = ROL(Egu, 20); - Eka ^= Da; - BCi = ROL(Eka, 3); - Eme ^= De; - BCo = ROL(Eme, 45); - Esi ^= Di; - BCu = ROL(Esi, 61); - Aga = BCa ^ ((~BCe) & BCi); - Age = BCe ^ ((~BCi) & BCo); - Agi = BCi ^ ((~BCo) & BCu); - Ago = BCo ^ ((~BCu) & BCa); - Agu = BCu ^ ((~BCa) & BCe); - - Ebe ^= De; - BCa = ROL(Ebe, 1); - Egi ^= Di; - BCe = ROL(Egi, 6); - Eko ^= Do; - BCi = ROL(Eko, 25); - Emu ^= Du; - BCo = ROL(Emu, 8); - Esa ^= Da; - BCu = ROL(Esa, 18); - Aka = BCa ^ ((~BCe) & BCi); - Ake = BCe ^ ((~BCi) & BCo); - Aki = BCi ^ ((~BCo) & BCu); - Ako = BCo ^ ((~BCu) & BCa); - Aku = BCu ^ ((~BCa) & BCe); - - Ebu ^= Du; - BCa = ROL(Ebu, 27); - Ega ^= Da; - BCe = ROL(Ega, 36); - Eke ^= De; - BCi = ROL(Eke, 10); - Emi ^= Di; - BCo = ROL(Emi, 15); - Eso ^= Do; - BCu = ROL(Eso, 56); - Ama = BCa ^ ((~BCe) & BCi); - Ame = BCe ^ ((~BCi) & BCo); - Ami = BCi ^ ((~BCo) & BCu); - Amo = BCo ^ ((~BCu) & BCa); - Amu = BCu ^ ((~BCa) & BCe); - - Ebi ^= Di; - BCa = ROL(Ebi, 62); - Ego ^= Do; - BCe = ROL(Ego, 55); - Eku ^= Du; - BCi = ROL(Eku, 39); - Ema ^= Da; - BCo = ROL(Ema, 41); - Ese ^= De; - BCu = ROL(Ese, 2); - Asa = BCa ^ ((~BCe) & BCi); - Ase = BCe ^ ((~BCi) & BCo); - Asi = BCi ^ ((~BCo) & BCu); - Aso = BCo ^ ((~BCu) & BCa); - Asu = BCu ^ ((~BCa) & BCe); - } - - // copyToState(state, A) - state[0] = Aba; - state[1] = Abe; - state[2] = Abi; - state[3] = Abo; - state[4] = Abu; - state[5] = Aga; - state[6] = Age; - state[7] = Agi; - state[8] = Ago; - state[9] = Agu; - state[10] = Aka; - state[11] = Ake; - state[12] = Aki; - state[13] = Ako; - state[14] = Aku; - state[15] = Ama; - state[16] = Ame; - state[17] = Ami; - state[18] = Amo; - state[19] = Amu; - state[20] = Asa; - state[21] = Ase; - state[22] = Asi; - state[23] = Aso; - state[24] = Asu; + int round; + + uint64_t Aba, Abe, Abi, Abo, Abu; + uint64_t Aga, Age, Agi, Ago, Agu; + uint64_t Aka, Ake, Aki, Ako, Aku; + uint64_t Ama, Ame, Ami, Amo, Amu; + uint64_t Asa, Ase, Asi, Aso, Asu; + uint64_t BCa, BCe, BCi, BCo, BCu; + uint64_t Da, De, Di, Do, Du; + uint64_t Eba, Ebe, Ebi, Ebo, Ebu; + uint64_t Ega, Ege, Egi, Ego, Egu; + uint64_t Eka, Eke, Eki, Eko, Eku; + uint64_t Ema, Eme, Emi, Emo, Emu; + uint64_t Esa, Ese, Esi, Eso, Esu; + + // copyFromState(A, state) + Aba = state[0]; + Abe = state[1]; + Abi = state[2]; + Abo = state[3]; + Abu = state[4]; + Aga = state[5]; + Age = state[6]; + Agi = state[7]; + Ago = state[8]; + Agu = state[9]; + Aka = state[10]; + Ake = state[11]; + Aki = state[12]; + Ako = state[13]; + Aku = state[14]; + Ama = state[15]; + Ame = state[16]; + Ami = state[17]; + Amo = state[18]; + Amu = state[19]; + Asa = state[20]; + Ase = state[21]; + Asi = state[22]; + Aso = state[23]; + Asu = state[24]; + + for (round = 0; round < NROUNDS; round += 2) { + // prepareTheta + BCa = Aba ^ Aga ^ Aka ^ Ama ^ Asa; + BCe = Abe ^ Age ^ Ake ^ Ame ^ Ase; + BCi = Abi ^ Agi ^ Aki ^ Ami ^ Asi; + BCo = Abo ^ Ago ^ Ako ^ Amo ^ Aso; + BCu = Abu ^ Agu ^ Aku ^ Amu ^ Asu; + + // thetaRhoPiChiIotaPrepareTheta(round , A, E) + Da = BCu ^ ROL(BCe, 1); + De = BCa ^ ROL(BCi, 1); + Di = BCe ^ ROL(BCo, 1); + Do = BCi ^ ROL(BCu, 1); + Du = BCo ^ ROL(BCa, 1); + + Aba ^= Da; + BCa = Aba; + Age ^= De; + BCe = ROL(Age, 44); + Aki ^= Di; + BCi = ROL(Aki, 43); + Amo ^= Do; + BCo = ROL(Amo, 21); + Asu ^= Du; + BCu = ROL(Asu, 14); + Eba = BCa ^ ((~BCe) & BCi); + Eba ^= KeccakF_RoundConstants[round]; + Ebe = BCe ^ ((~BCi) & BCo); + Ebi = BCi ^ ((~BCo) & BCu); + Ebo = BCo ^ ((~BCu) & BCa); + Ebu = BCu ^ ((~BCa) & BCe); + + Abo ^= Do; + BCa = ROL(Abo, 28); + Agu ^= Du; + BCe = ROL(Agu, 20); + Aka ^= Da; + BCi = ROL(Aka, 3); + Ame ^= De; + BCo = ROL(Ame, 45); + Asi ^= Di; + BCu = ROL(Asi, 61); + Ega = BCa ^ ((~BCe) & BCi); + Ege = BCe ^ ((~BCi) & BCo); + Egi = BCi ^ ((~BCo) & BCu); + Ego = BCo ^ ((~BCu) & BCa); + Egu = BCu ^ ((~BCa) & BCe); + + Abe ^= De; + BCa = ROL(Abe, 1); + Agi ^= Di; + BCe = ROL(Agi, 6); + Ako ^= Do; + BCi = ROL(Ako, 25); + Amu ^= Du; + BCo = ROL(Amu, 8); + Asa ^= Da; + BCu = ROL(Asa, 18); + Eka = BCa ^ ((~BCe) & BCi); + Eke = BCe ^ ((~BCi) & BCo); + Eki = BCi ^ ((~BCo) & BCu); + Eko = BCo ^ ((~BCu) & BCa); + Eku = BCu ^ ((~BCa) & BCe); + + Abu ^= Du; + BCa = ROL(Abu, 27); + Aga ^= Da; + BCe = ROL(Aga, 36); + Ake ^= De; + BCi = ROL(Ake, 10); + Ami ^= Di; + BCo = ROL(Ami, 15); + Aso ^= Do; + BCu = ROL(Aso, 56); + Ema = BCa ^ ((~BCe) & BCi); + Eme = BCe ^ ((~BCi) & BCo); + Emi = BCi ^ ((~BCo) & BCu); + Emo = BCo ^ ((~BCu) & BCa); + Emu = BCu ^ ((~BCa) & BCe); + + Abi ^= Di; + BCa = ROL(Abi, 62); + Ago ^= Do; + BCe = ROL(Ago, 55); + Aku ^= Du; + BCi = ROL(Aku, 39); + Ama ^= Da; + BCo = ROL(Ama, 41); + Ase ^= De; + BCu = ROL(Ase, 2); + Esa = BCa ^ ((~BCe) & BCi); + Ese = BCe ^ ((~BCi) & BCo); + Esi = BCi ^ ((~BCo) & BCu); + Eso = BCo ^ ((~BCu) & BCa); + Esu = BCu ^ ((~BCa) & BCe); + + // prepareTheta + BCa = Eba ^ Ega ^ Eka ^ Ema ^ Esa; + BCe = Ebe ^ Ege ^ Eke ^ Eme ^ Ese; + BCi = Ebi ^ Egi ^ Eki ^ Emi ^ Esi; + BCo = Ebo ^ Ego ^ Eko ^ Emo ^ Eso; + BCu = Ebu ^ Egu ^ Eku ^ Emu ^ Esu; + + // thetaRhoPiChiIotaPrepareTheta(round+1, E, A) + Da = BCu ^ ROL(BCe, 1); + De = BCa ^ ROL(BCi, 1); + Di = BCe ^ ROL(BCo, 1); + Do = BCi ^ ROL(BCu, 1); + Du = BCo ^ ROL(BCa, 1); + + Eba ^= Da; + BCa = Eba; + Ege ^= De; + BCe = ROL(Ege, 44); + Eki ^= Di; + BCi = ROL(Eki, 43); + Emo ^= Do; + BCo = ROL(Emo, 21); + Esu ^= Du; + BCu = ROL(Esu, 14); + Aba = BCa ^ ((~BCe) & BCi); + Aba ^= KeccakF_RoundConstants[round + 1]; + Abe = BCe ^ ((~BCi) & BCo); + Abi = BCi ^ ((~BCo) & BCu); + Abo = BCo ^ ((~BCu) & BCa); + Abu = BCu ^ ((~BCa) & BCe); + + Ebo ^= Do; + BCa = ROL(Ebo, 28); + Egu ^= Du; + BCe = ROL(Egu, 20); + Eka ^= Da; + BCi = ROL(Eka, 3); + Eme ^= De; + BCo = ROL(Eme, 45); + Esi ^= Di; + BCu = ROL(Esi, 61); + Aga = BCa ^ ((~BCe) & BCi); + Age = BCe ^ ((~BCi) & BCo); + Agi = BCi ^ ((~BCo) & BCu); + Ago = BCo ^ ((~BCu) & BCa); + Agu = BCu ^ ((~BCa) & BCe); + + Ebe ^= De; + BCa = ROL(Ebe, 1); + Egi ^= Di; + BCe = ROL(Egi, 6); + Eko ^= Do; + BCi = ROL(Eko, 25); + Emu ^= Du; + BCo = ROL(Emu, 8); + Esa ^= Da; + BCu = ROL(Esa, 18); + Aka = BCa ^ ((~BCe) & BCi); + Ake = BCe ^ ((~BCi) & BCo); + Aki = BCi ^ ((~BCo) & BCu); + Ako = BCo ^ ((~BCu) & BCa); + Aku = BCu ^ ((~BCa) & BCe); + + Ebu ^= Du; + BCa = ROL(Ebu, 27); + Ega ^= Da; + BCe = ROL(Ega, 36); + Eke ^= De; + BCi = ROL(Eke, 10); + Emi ^= Di; + BCo = ROL(Emi, 15); + Eso ^= Do; + BCu = ROL(Eso, 56); + Ama = BCa ^ ((~BCe) & BCi); + Ame = BCe ^ ((~BCi) & BCo); + Ami = BCi ^ ((~BCo) & BCu); + Amo = BCo ^ ((~BCu) & BCa); + Amu = BCu ^ ((~BCa) & BCe); + + Ebi ^= Di; + BCa = ROL(Ebi, 62); + Ego ^= Do; + BCe = ROL(Ego, 55); + Eku ^= Du; + BCi = ROL(Eku, 39); + Ema ^= Da; + BCo = ROL(Ema, 41); + Ese ^= De; + BCu = ROL(Ese, 2); + Asa = BCa ^ ((~BCe) & BCi); + Ase = BCe ^ ((~BCi) & BCo); + Asi = BCi ^ ((~BCo) & BCu); + Aso = BCo ^ ((~BCu) & BCa); + Asu = BCu ^ ((~BCa) & BCe); + } + + // copyToState(state, A) + state[0] = Aba; + state[1] = Abe; + state[2] = Abi; + state[3] = Abo; + state[4] = Abu; + state[5] = Aga; + state[6] = Age; + state[7] = Agi; + state[8] = Ago; + state[9] = Agu; + state[10] = Aka; + state[11] = Ake; + state[12] = Aki; + state[13] = Ako; + state[14] = Aku; + state[15] = Ama; + state[16] = Ame; + state[17] = Ami; + state[18] = Amo; + state[19] = Amu; + state[20] = Asa; + state[21] = Ase; + state[22] = Asi; + state[23] = Aso; + state[24] = Asu; } /************************************************* @@ -510,36 +510,36 @@ static void KeccakF1600_StatePermute(uint64_t *state) { * Keccak-derived functions **************************************************/ static void keccak_absorb(uint64_t *s, uint32_t r, const uint8_t *m, - size_t mlen, uint8_t p) { - size_t i; - uint8_t t[200]; - - /* Zero state */ - for (i = 0; i < 25; ++i) { - s[i] = 0; - } - - while (mlen >= r) { - for (i = 0; i < r / 8; ++i) { - s[i] ^= load64(m + 8 * i); - } - - KeccakF1600_StatePermute(s); - mlen -= r; - m += r; - } - - for (i = 0; i < r; ++i) { - t[i] = 0; - } - for (i = 0; i < mlen; ++i) { - t[i] = m[i]; - } - t[i] = p; - t[r - 1] |= 128; - for (i = 0; i < r / 8; ++i) { - s[i] ^= load64(t + 8 * i); - } + size_t mlen, uint8_t p) { + size_t i; + uint8_t t[200]; + + /* Zero state */ + for (i = 0; i < 25; ++i) { + s[i] = 0; + } + + while (mlen >= r) { + for (i = 0; i < r / 8; ++i) { + s[i] ^= load64(m + 8 * i); + } + + KeccakF1600_StatePermute(s); + mlen -= r; + m += r; + } + + for (i = 0; i < r; ++i) { + t[i] = 0; + } + for (i = 0; i < mlen; ++i) { + t[i] = m[i]; + } + t[i] = p; + t[r - 1] |= 128; + for (i = 0; i < r / 8; ++i) { + s[i] ^= load64(t + 8 * i); + } } /************************************************* @@ -556,15 +556,15 @@ static void keccak_absorb(uint64_t *s, uint32_t r, const uint8_t *m, * - uint32_t r: rate in bytes (e.g., 168 for SHAKE128) **************************************************/ static void keccak_squeezeblocks(uint8_t *h, size_t nblocks, - uint64_t *s, uint32_t r) { - while (nblocks > 0) { - KeccakF1600_StatePermute(s); - for (size_t i = 0; i < (r >> 3); i++) { - store64(h + 8 * i, s[i]); - } - h += r; - nblocks--; - } + uint64_t *s, uint32_t r) { + while (nblocks > 0) { + KeccakF1600_StatePermute(s); + for (size_t i = 0; i < (r >> 3); i++) { + store64(h + 8 * i, s[i]); + } + h += r; + nblocks--; + } } /************************************************* @@ -578,12 +578,12 @@ static void keccak_squeezeblocks(uint8_t *h, size_t nblocks, * that have not been permuted, or not-yet-squeezed bytes. **************************************************/ static void keccak_inc_init(uint64_t *s_inc) { - size_t i; + size_t i; - for (i = 0; i < 25; ++i) { - s_inc[i] = 0; - } - s_inc[25] = 0; + for (i = 0; i < 25; ++i) { + s_inc[i] = 0; + } + s_inc[25] = 0; } /************************************************* @@ -601,27 +601,27 @@ static void keccak_inc_init(uint64_t *s_inc) { * - size_t mlen: length of input in bytes **************************************************/ static void keccak_inc_absorb(uint64_t *s_inc, uint32_t r, const uint8_t *m, - size_t mlen) { - size_t i; - - /* Recall that s_inc[25] is the non-absorbed bytes xored into the state */ - while (mlen + s_inc[25] >= r) { - for (i = 0; i < r - (uint32_t)s_inc[25]; i++) { - /* Take the i'th byte from message - xor with the s_inc[25] + i'th byte of the state; little-endian */ - s_inc[(s_inc[25] + i) >> 3] ^= (uint64_t)m[i] << (8 * ((s_inc[25] + i) & 0x07)); - } - mlen -= (size_t)(r - s_inc[25]); - m += r - s_inc[25]; - s_inc[25] = 0; - - KeccakF1600_StatePermute(s_inc); - } - - for (i = 0; i < mlen; i++) { - s_inc[(s_inc[25] + i) >> 3] ^= (uint64_t)m[i] << (8 * ((s_inc[25] + i) & 0x07)); - } - s_inc[25] += mlen; + size_t mlen) { + size_t i; + + /* Recall that s_inc[25] is the non-absorbed bytes xored into the state */ + while (mlen + s_inc[25] >= r) { + for (i = 0; i < r - (uint32_t)s_inc[25]; i++) { + /* Take the i'th byte from message + xor with the s_inc[25] + i'th byte of the state; little-endian */ + s_inc[(s_inc[25] + i) >> 3] ^= (uint64_t)m[i] << (8 * ((s_inc[25] + i) & 0x07)); + } + mlen -= (size_t)(r - s_inc[25]); + m += r - s_inc[25]; + s_inc[25] = 0; + + KeccakF1600_StatePermute(s_inc); + } + + for (i = 0; i < mlen; i++) { + s_inc[(s_inc[25] + i) >> 3] ^= (uint64_t)m[i] << (8 * ((s_inc[25] + i) & 0x07)); + } + s_inc[25] += mlen; } /************************************************* @@ -638,11 +638,11 @@ static void keccak_inc_absorb(uint64_t *s_inc, uint32_t r, const uint8_t *m, * Keccak-derived functions **************************************************/ static void keccak_inc_finalize(uint64_t *s_inc, uint32_t r, uint8_t p) { - /* After keccak_inc_absorb, we are guaranteed that s_inc[25] < r, - so we can always use one more byte for p in the current state. */ - s_inc[s_inc[25] >> 3] ^= (uint64_t)p << (8 * (s_inc[25] & 0x07)); - s_inc[(r - 1) >> 3] ^= (uint64_t)128 << (8 * ((r - 1) & 0x07)); - s_inc[25] = 0; + /* After keccak_inc_absorb, we are guaranteed that s_inc[25] < r, + so we can always use one more byte for p in the current state. */ + s_inc[s_inc[25] >> 3] ^= (uint64_t)p << (8 * (s_inc[25] & 0x07)); + s_inc[(r - 1) >> 3] ^= (uint64_t)128 << (8 * ((r - 1) & 0x07)); + s_inc[25] = 0; } /************************************************* @@ -659,94 +659,94 @@ static void keccak_inc_finalize(uint64_t *s_inc, uint32_t r, uint8_t p) { * - uint32_t r: rate in bytes (e.g., 168 for SHAKE128) **************************************************/ static void keccak_inc_squeeze(uint8_t *h, size_t outlen, - uint64_t *s_inc, uint32_t r) { - size_t i; - - /* First consume any bytes we still have sitting around */ - for (i = 0; i < outlen && i < s_inc[25]; i++) { - /* There are s_inc[25] bytes left, so r - s_inc[25] is the first - available byte. We consume from there, i.e., up to r. */ - h[i] = (uint8_t)(s_inc[(r - s_inc[25] + i) >> 3] >> (8 * ((r - s_inc[25] + i) & 0x07))); - } - h += i; - outlen -= i; - s_inc[25] -= i; - - /* Then squeeze the remaining necessary blocks */ - while (outlen > 0) { - KeccakF1600_StatePermute(s_inc); - - for (i = 0; i < outlen && i < r; i++) { - h[i] = (uint8_t)(s_inc[i >> 3] >> (8 * (i & 0x07))); - } - h += i; - outlen -= i; - s_inc[25] = r - i; - } + uint64_t *s_inc, uint32_t r) { + size_t i; + + /* First consume any bytes we still have sitting around */ + for (i = 0; i < outlen && i < s_inc[25]; i++) { + /* There are s_inc[25] bytes left, so r - s_inc[25] is the first + available byte. We consume from there, i.e., up to r. */ + h[i] = (uint8_t)(s_inc[(r - s_inc[25] + i) >> 3] >> (8 * ((r - s_inc[25] + i) & 0x07))); + } + h += i; + outlen -= i; + s_inc[25] -= i; + + /* Then squeeze the remaining necessary blocks */ + while (outlen > 0) { + KeccakF1600_StatePermute(s_inc); + + for (i = 0; i < outlen && i < r; i++) { + h[i] = (uint8_t)(s_inc[i >> 3] >> (8 * (i & 0x07))); + } + h += i; + outlen -= i; + s_inc[25] = r - i; + } } void shake128_inc_init(shake128incctx *state) { - state->ctx = malloc(PQC_SHAKEINCCTX_BYTES); - if (state->ctx == NULL) { - exit(111); - } - keccak_inc_init(state->ctx); + state->ctx = malloc(PQC_SHAKEINCCTX_BYTES); + if (state->ctx == NULL) { + exit(111); + } + keccak_inc_init(state->ctx); } void shake128_inc_absorb(shake128incctx *state, const uint8_t *input, size_t inlen) { - keccak_inc_absorb(state->ctx, SHAKE128_RATE, input, inlen); + keccak_inc_absorb(state->ctx, SHAKE128_RATE, input, inlen); } void shake128_inc_finalize(shake128incctx *state) { - keccak_inc_finalize(state->ctx, SHAKE128_RATE, 0x1F); + keccak_inc_finalize(state->ctx, SHAKE128_RATE, 0x1F); } void shake128_inc_squeeze(uint8_t *output, size_t outlen, shake128incctx *state) { - keccak_inc_squeeze(output, outlen, state->ctx, SHAKE128_RATE); + keccak_inc_squeeze(output, outlen, state->ctx, SHAKE128_RATE); } void shake128_inc_ctx_clone(shake128incctx *dest, const shake128incctx *src) { - dest->ctx = malloc(PQC_SHAKEINCCTX_BYTES); - if (dest->ctx == NULL) { - exit(111); - } - memcpy(dest->ctx, src->ctx, PQC_SHAKEINCCTX_BYTES); + dest->ctx = malloc(PQC_SHAKEINCCTX_BYTES); + if (dest->ctx == NULL) { + exit(111); + } + memcpy(dest->ctx, src->ctx, PQC_SHAKEINCCTX_BYTES); } void shake128_inc_ctx_release(shake128incctx *state) { - free(state->ctx); + free(state->ctx); } void shake256_inc_init(shake256incctx *state) { - state->ctx = malloc(PQC_SHAKEINCCTX_BYTES); - if (state->ctx == NULL) { - exit(111); - } - keccak_inc_init(state->ctx); + state->ctx = malloc(PQC_SHAKEINCCTX_BYTES); + if (state->ctx == NULL) { + exit(111); + } + keccak_inc_init(state->ctx); } void shake256_inc_absorb(shake256incctx *state, const uint8_t *input, size_t inlen) { - keccak_inc_absorb(state->ctx, SHAKE256_RATE, input, inlen); + keccak_inc_absorb(state->ctx, SHAKE256_RATE, input, inlen); } void shake256_inc_finalize(shake256incctx *state) { - keccak_inc_finalize(state->ctx, SHAKE256_RATE, 0x1F); + keccak_inc_finalize(state->ctx, SHAKE256_RATE, 0x1F); } void shake256_inc_squeeze(uint8_t *output, size_t outlen, shake256incctx *state) { - keccak_inc_squeeze(output, outlen, state->ctx, SHAKE256_RATE); + keccak_inc_squeeze(output, outlen, state->ctx, SHAKE256_RATE); } void shake256_inc_ctx_clone(shake256incctx *dest, const shake256incctx *src) { - dest->ctx = malloc(PQC_SHAKEINCCTX_BYTES); - if (dest->ctx == NULL) { - exit(111); - } - memcpy(dest->ctx, src->ctx, PQC_SHAKEINCCTX_BYTES); + dest->ctx = malloc(PQC_SHAKEINCCTX_BYTES); + if (dest->ctx == NULL) { + exit(111); + } + memcpy(dest->ctx, src->ctx, PQC_SHAKEINCCTX_BYTES); } void shake256_inc_ctx_release(shake256incctx *state) { - free(state->ctx); + free(state->ctx); } @@ -762,11 +762,11 @@ void shake256_inc_ctx_release(shake256incctx *state) { * - size_t inlen: length of input in bytes **************************************************/ void shake128_absorb(shake128ctx *state, const uint8_t *input, size_t inlen) { - state->ctx = malloc(PQC_SHAKECTX_BYTES); - if (state->ctx == NULL) { - exit(111); - } - keccak_absorb(state->ctx, SHAKE128_RATE, input, inlen, 0x1F); + state->ctx = malloc(PQC_SHAKECTX_BYTES); + if (state->ctx == NULL) { + exit(111); + } + keccak_absorb(state->ctx, SHAKE128_RATE, input, inlen, 0x1F); } /************************************************* @@ -782,20 +782,20 @@ void shake128_absorb(shake128ctx *state, const uint8_t *input, size_t inlen) { * - shake128ctx *state: pointer to input/output Keccak state **************************************************/ void shake128_squeezeblocks(uint8_t *output, size_t nblocks, shake128ctx *state) { - keccak_squeezeblocks(output, nblocks, state->ctx, SHAKE128_RATE); + keccak_squeezeblocks(output, nblocks, state->ctx, SHAKE128_RATE); } void shake128_ctx_clone(shake128ctx *dest, const shake128ctx *src) { - dest->ctx = malloc(PQC_SHAKECTX_BYTES); - if (dest->ctx == NULL) { - exit(111); - } - memcpy(dest->ctx, src->ctx, PQC_SHAKECTX_BYTES); + dest->ctx = malloc(PQC_SHAKECTX_BYTES); + if (dest->ctx == NULL) { + exit(111); + } + memcpy(dest->ctx, src->ctx, PQC_SHAKECTX_BYTES); } /** Release the allocated state. Call only once. */ void shake128_ctx_release(shake128ctx *state) { - free(state->ctx); + free(state->ctx); } /************************************************* @@ -810,11 +810,11 @@ void shake128_ctx_release(shake128ctx *state) { * - size_t inlen: length of input in bytes **************************************************/ void shake256_absorb(shake256ctx *state, const uint8_t *input, size_t inlen) { - state->ctx = malloc(PQC_SHAKECTX_BYTES); - if (state->ctx == NULL) { - exit(111); - } - keccak_absorb(state->ctx, SHAKE256_RATE, input, inlen, 0x1F); + state->ctx = malloc(PQC_SHAKECTX_BYTES); + if (state->ctx == NULL) { + exit(111); + } + keccak_absorb(state->ctx, SHAKE256_RATE, input, inlen, 0x1F); } /************************************************* @@ -830,20 +830,20 @@ void shake256_absorb(shake256ctx *state, const uint8_t *input, size_t inlen) { * - shake256ctx *state: pointer to input/output Keccak state **************************************************/ void shake256_squeezeblocks(uint8_t *output, size_t nblocks, shake256ctx *state) { - keccak_squeezeblocks(output, nblocks, state->ctx, SHAKE256_RATE); + keccak_squeezeblocks(output, nblocks, state->ctx, SHAKE256_RATE); } void shake256_ctx_clone(shake256ctx *dest, const shake256ctx *src) { - dest->ctx = malloc(PQC_SHAKECTX_BYTES); - if (dest->ctx == NULL) { - exit(111); - } - memcpy(dest->ctx, src->ctx, PQC_SHAKECTX_BYTES); + dest->ctx = malloc(PQC_SHAKECTX_BYTES); + if (dest->ctx == NULL) { + exit(111); + } + memcpy(dest->ctx, src->ctx, PQC_SHAKECTX_BYTES); } /** Release the allocated state. Call only once. */ void shake256_ctx_release(shake256ctx *state) { - free(state->ctx); + free(state->ctx); } /************************************************* @@ -857,24 +857,24 @@ void shake256_ctx_release(shake256ctx *state) { * - size_t inlen: length of input in bytes **************************************************/ void shake128(uint8_t *output, size_t outlen, - const uint8_t *input, size_t inlen) { - size_t nblocks = outlen / SHAKE128_RATE; - uint8_t t[SHAKE128_RATE]; - shake128ctx s; - - shake128_absorb(&s, input, inlen); - shake128_squeezeblocks(output, nblocks, &s); - - output += nblocks * SHAKE128_RATE; - outlen -= nblocks * SHAKE128_RATE; - - if (outlen) { - shake128_squeezeblocks(t, 1, &s); - for (size_t i = 0; i < outlen; ++i) { - output[i] = t[i]; - } - } - shake128_ctx_release(&s); + const uint8_t *input, size_t inlen) { + size_t nblocks = outlen / SHAKE128_RATE; + uint8_t t[SHAKE128_RATE]; + shake128ctx s; + + shake128_absorb(&s, input, inlen); + shake128_squeezeblocks(output, nblocks, &s); + + output += nblocks * SHAKE128_RATE; + outlen -= nblocks * SHAKE128_RATE; + + if (outlen) { + shake128_squeezeblocks(t, 1, &s); + for (size_t i = 0; i < outlen; ++i) { + output[i] = t[i]; + } + } + shake128_ctx_release(&s); } /************************************************* @@ -888,61 +888,61 @@ void shake128(uint8_t *output, size_t outlen, * - size_t inlen: length of input in bytes **************************************************/ void shake256(uint8_t *output, size_t outlen, - const uint8_t *input, size_t inlen) { - size_t nblocks = outlen / SHAKE256_RATE; - uint8_t t[SHAKE256_RATE]; - shake256ctx s; - - shake256_absorb(&s, input, inlen); - shake256_squeezeblocks(output, nblocks, &s); - - output += nblocks * SHAKE256_RATE; - outlen -= nblocks * SHAKE256_RATE; - - if (outlen) { - shake256_squeezeblocks(t, 1, &s); - for (size_t i = 0; i < outlen; ++i) { - output[i] = t[i]; - } - } - shake256_ctx_release(&s); + const uint8_t *input, size_t inlen) { + size_t nblocks = outlen / SHAKE256_RATE; + uint8_t t[SHAKE256_RATE]; + shake256ctx s; + + shake256_absorb(&s, input, inlen); + shake256_squeezeblocks(output, nblocks, &s); + + output += nblocks * SHAKE256_RATE; + outlen -= nblocks * SHAKE256_RATE; + + if (outlen) { + shake256_squeezeblocks(t, 1, &s); + for (size_t i = 0; i < outlen; ++i) { + output[i] = t[i]; + } + } + shake256_ctx_release(&s); } void sha3_256_inc_init(sha3_256incctx *state) { - state->ctx = malloc(PQC_SHAKEINCCTX_BYTES); - if (state->ctx == NULL) { - exit(111); - } - keccak_inc_init(state->ctx); + state->ctx = malloc(PQC_SHAKEINCCTX_BYTES); + if (state->ctx == NULL) { + exit(111); + } + keccak_inc_init(state->ctx); } void sha3_256_inc_ctx_clone(sha3_256incctx *dest, const sha3_256incctx *src) { - dest->ctx = malloc(PQC_SHAKEINCCTX_BYTES); - if (dest->ctx == NULL) { - exit(111); - } - memcpy(dest->ctx, src->ctx, PQC_SHAKEINCCTX_BYTES); + dest->ctx = malloc(PQC_SHAKEINCCTX_BYTES); + if (dest->ctx == NULL) { + exit(111); + } + memcpy(dest->ctx, src->ctx, PQC_SHAKEINCCTX_BYTES); } void sha3_256_inc_ctx_release(sha3_256incctx *state) { - free(state->ctx); + free(state->ctx); } void sha3_256_inc_absorb(sha3_256incctx *state, const uint8_t *input, size_t inlen) { - keccak_inc_absorb(state->ctx, SHA3_256_RATE, input, inlen); + keccak_inc_absorb(state->ctx, SHA3_256_RATE, input, inlen); } void sha3_256_inc_finalize(uint8_t *output, sha3_256incctx *state) { - uint8_t t[SHA3_256_RATE]; - keccak_inc_finalize(state->ctx, SHA3_256_RATE, 0x06); + uint8_t t[SHA3_256_RATE]; + keccak_inc_finalize(state->ctx, SHA3_256_RATE, 0x06); - keccak_squeezeblocks(t, 1, state->ctx, SHA3_256_RATE); + keccak_squeezeblocks(t, 1, state->ctx, SHA3_256_RATE); - sha3_256_inc_ctx_release(state); + sha3_256_inc_ctx_release(state); - for (size_t i = 0; i < 32; i++) { - output[i] = t[i]; - } + for (size_t i = 0; i < 32; i++) { + output[i] = t[i]; + } } /************************************************* @@ -955,55 +955,55 @@ void sha3_256_inc_finalize(uint8_t *output, sha3_256incctx *state) { * - size_t inlen: length of input in bytes **************************************************/ void sha3_256(uint8_t *output, const uint8_t *input, size_t inlen) { - uint64_t s[25]; - uint8_t t[SHA3_256_RATE]; + uint64_t s[25]; + uint8_t t[SHA3_256_RATE]; - /* Absorb input */ - keccak_absorb(s, SHA3_256_RATE, input, inlen, 0x06); + /* Absorb input */ + keccak_absorb(s, SHA3_256_RATE, input, inlen, 0x06); - /* Squeeze output */ - keccak_squeezeblocks(t, 1, s, SHA3_256_RATE); + /* Squeeze output */ + keccak_squeezeblocks(t, 1, s, SHA3_256_RATE); - for (size_t i = 0; i < 32; i++) { - output[i] = t[i]; - } + for (size_t i = 0; i < 32; i++) { + output[i] = t[i]; + } } void sha3_384_inc_init(sha3_384incctx *state) { - state->ctx = malloc(PQC_SHAKEINCCTX_BYTES); - if (state->ctx == NULL) { - exit(111); - } - keccak_inc_init(state->ctx); + state->ctx = malloc(PQC_SHAKEINCCTX_BYTES); + if (state->ctx == NULL) { + exit(111); + } + keccak_inc_init(state->ctx); } void sha3_384_inc_ctx_clone(sha3_384incctx *dest, const sha3_384incctx *src) { - dest->ctx = malloc(PQC_SHAKEINCCTX_BYTES); - if (dest->ctx == NULL) { - exit(111); - } - memcpy(dest->ctx, src->ctx, PQC_SHAKEINCCTX_BYTES); + dest->ctx = malloc(PQC_SHAKEINCCTX_BYTES); + if (dest->ctx == NULL) { + exit(111); + } + memcpy(dest->ctx, src->ctx, PQC_SHAKEINCCTX_BYTES); } void sha3_384_inc_absorb(sha3_384incctx *state, const uint8_t *input, size_t inlen) { - keccak_inc_absorb(state->ctx, SHA3_384_RATE, input, inlen); + keccak_inc_absorb(state->ctx, SHA3_384_RATE, input, inlen); } void sha3_384_inc_ctx_release(sha3_384incctx *state) { - free(state->ctx); + free(state->ctx); } void sha3_384_inc_finalize(uint8_t *output, sha3_384incctx *state) { - uint8_t t[SHA3_384_RATE]; - keccak_inc_finalize(state->ctx, SHA3_384_RATE, 0x06); + uint8_t t[SHA3_384_RATE]; + keccak_inc_finalize(state->ctx, SHA3_384_RATE, 0x06); - keccak_squeezeblocks(t, 1, state->ctx, SHA3_384_RATE); + keccak_squeezeblocks(t, 1, state->ctx, SHA3_384_RATE); - sha3_384_inc_ctx_release(state); + sha3_384_inc_ctx_release(state); - for (size_t i = 0; i < 48; i++) { - output[i] = t[i]; - } + for (size_t i = 0; i < 48; i++) { + output[i] = t[i]; + } } /************************************************* @@ -1016,55 +1016,55 @@ void sha3_384_inc_finalize(uint8_t *output, sha3_384incctx *state) { * - size_t inlen: length of input in bytes **************************************************/ void sha3_384(uint8_t *output, const uint8_t *input, size_t inlen) { - uint64_t s[25]; - uint8_t t[SHA3_384_RATE]; + uint64_t s[25]; + uint8_t t[SHA3_384_RATE]; - /* Absorb input */ - keccak_absorb(s, SHA3_384_RATE, input, inlen, 0x06); + /* Absorb input */ + keccak_absorb(s, SHA3_384_RATE, input, inlen, 0x06); - /* Squeeze output */ - keccak_squeezeblocks(t, 1, s, SHA3_384_RATE); + /* Squeeze output */ + keccak_squeezeblocks(t, 1, s, SHA3_384_RATE); - for (size_t i = 0; i < 48; i++) { - output[i] = t[i]; - } + for (size_t i = 0; i < 48; i++) { + output[i] = t[i]; + } } void sha3_512_inc_init(sha3_512incctx *state) { - state->ctx = malloc(PQC_SHAKEINCCTX_BYTES); - if (state->ctx == NULL) { - exit(111); - } - keccak_inc_init(state->ctx); + state->ctx = malloc(PQC_SHAKEINCCTX_BYTES); + if (state->ctx == NULL) { + exit(111); + } + keccak_inc_init(state->ctx); } void sha3_512_inc_ctx_clone(sha3_512incctx *dest, const sha3_512incctx *src) { - dest->ctx = malloc(PQC_SHAKEINCCTX_BYTES); - if (dest->ctx == NULL) { - exit(111); - } - memcpy(dest->ctx, src->ctx, PQC_SHAKEINCCTX_BYTES); + dest->ctx = malloc(PQC_SHAKEINCCTX_BYTES); + if (dest->ctx == NULL) { + exit(111); + } + memcpy(dest->ctx, src->ctx, PQC_SHAKEINCCTX_BYTES); } void sha3_512_inc_absorb(sha3_512incctx *state, const uint8_t *input, size_t inlen) { - keccak_inc_absorb(state->ctx, SHA3_512_RATE, input, inlen); + keccak_inc_absorb(state->ctx, SHA3_512_RATE, input, inlen); } void sha3_512_inc_ctx_release(sha3_512incctx *state) { - free(state->ctx); + free(state->ctx); } void sha3_512_inc_finalize(uint8_t *output, sha3_512incctx *state) { - uint8_t t[SHA3_512_RATE]; - keccak_inc_finalize(state->ctx, SHA3_512_RATE, 0x06); + uint8_t t[SHA3_512_RATE]; + keccak_inc_finalize(state->ctx, SHA3_512_RATE, 0x06); - keccak_squeezeblocks(t, 1, state->ctx, SHA3_512_RATE); + keccak_squeezeblocks(t, 1, state->ctx, SHA3_512_RATE); - sha3_512_inc_ctx_release(state); + sha3_512_inc_ctx_release(state); - for (size_t i = 0; i < 64; i++) { - output[i] = t[i]; - } + for (size_t i = 0; i < 64; i++) { + output[i] = t[i]; + } } /************************************************* @@ -1077,17 +1077,17 @@ void sha3_512_inc_finalize(uint8_t *output, sha3_512incctx *state) { * - size_t inlen: length of input in bytes **************************************************/ void sha3_512(uint8_t *output, const uint8_t *input, size_t inlen) { - uint64_t s[25]; - uint8_t t[SHA3_512_RATE]; + uint64_t s[25]; + uint8_t t[SHA3_512_RATE]; - /* Absorb input */ - keccak_absorb(s, SHA3_512_RATE, input, inlen, 0x06); + /* Absorb input */ + keccak_absorb(s, SHA3_512_RATE, input, inlen, 0x06); - /* Squeeze output */ - keccak_squeezeblocks(t, 1, s, SHA3_512_RATE); + /* Squeeze output */ + keccak_squeezeblocks(t, 1, s, SHA3_512_RATE); - for (size_t i = 0; i < 64; i++) { - output[i] = t[i]; - } + for (size_t i = 0; i < 64; i++) { + output[i] = t[i]; + } } diff --git a/lib/mayo/generic_arithmetic.h b/lib/mayo/generic_arithmetic.h index ab6219c99..f6f4c0578 100644 --- a/lib/mayo/generic_arithmetic.h +++ b/lib/mayo/generic_arithmetic.h @@ -14,76 +14,76 @@ // multiplies m (possibly upper triangular) matrices with a single matrix and adds result to acc static inline void mul_add_m_upper_triangular_mat_x_mat(const int m_vec_limbs, const uint64_t *bs_mat, const unsigned char *mat, uint64_t *acc, - const int bs_mat_rows, const int bs_mat_cols, const int mat_cols, const int triangular) { - - int bs_mat_entries_used = 0; - for (int r = 0; r < bs_mat_rows; r++) { - for (int c = triangular * r; c < bs_mat_cols; c++) { - for (int k = 0; k < mat_cols; k += 1) { - m_vec_mul_add(m_vec_limbs, bs_mat + m_vec_limbs * bs_mat_entries_used, mat[c * mat_cols + k], acc + m_vec_limbs * (r * mat_cols + k)); - } - bs_mat_entries_used += 1; - } - } + const int bs_mat_rows, const int bs_mat_cols, const int mat_cols, const int triangular) { + + int bs_mat_entries_used = 0; + for (int r = 0; r < bs_mat_rows; r++) { + for (int c = triangular * r; c < bs_mat_cols; c++) { + for (int k = 0; k < mat_cols; k += 1) { + m_vec_mul_add(m_vec_limbs, bs_mat + m_vec_limbs * bs_mat_entries_used, mat[c * mat_cols + k], acc + m_vec_limbs * (r * mat_cols + k)); + } + bs_mat_entries_used += 1; + } + } } // multiplies m (possibly upper triangular) matrices with the transpose of a single matrix and adds result to acc static inline void mul_add_m_upper_triangular_mat_x_mat_trans(const int m_vec_limbs, const uint64_t *bs_mat, const unsigned char *mat, uint64_t *acc, - const int bs_mat_rows, const int bs_mat_cols, const int mat_rows, const int triangular) { - int bs_mat_entries_used = 0; - for (int r = 0; r < bs_mat_rows; r++) { - for (int c = triangular * r; c < bs_mat_cols; c++) { - for (int k = 0; k < mat_rows; k += 1) { - m_vec_mul_add(m_vec_limbs, bs_mat + m_vec_limbs * bs_mat_entries_used, mat[k * bs_mat_cols + c], acc + m_vec_limbs * (r * mat_rows + k)); - } - bs_mat_entries_used += 1; - } - } + const int bs_mat_rows, const int bs_mat_cols, const int mat_rows, const int triangular) { + int bs_mat_entries_used = 0; + for (int r = 0; r < bs_mat_rows; r++) { + for (int c = triangular * r; c < bs_mat_cols; c++) { + for (int k = 0; k < mat_rows; k += 1) { + m_vec_mul_add(m_vec_limbs, bs_mat + m_vec_limbs * bs_mat_entries_used, mat[k * bs_mat_cols + c], acc + m_vec_limbs * (r * mat_rows + k)); + } + bs_mat_entries_used += 1; + } + } } // multiplies the transpose of a single matrix with m matrices and adds result to acc static inline void mul_add_mat_trans_x_m_mat(const int m_vec_limbs, const unsigned char *mat, const uint64_t *bs_mat, uint64_t *acc, - const int mat_rows, const int mat_cols, const int bs_mat_cols) { - - for (int r = 0; r < mat_cols; r++) { - for (int c = 0; c < mat_rows; c++) { - for (int k = 0; k < bs_mat_cols; k += 1) { - m_vec_mul_add(m_vec_limbs, bs_mat + m_vec_limbs * (c * bs_mat_cols + k), mat[c * mat_cols + r], acc + m_vec_limbs * (r * bs_mat_cols + k)); - } - } - } + const int mat_rows, const int mat_cols, const int bs_mat_cols) { + + for (int r = 0; r < mat_cols; r++) { + for (int c = 0; c < mat_rows; c++) { + for (int k = 0; k < bs_mat_cols; k += 1) { + m_vec_mul_add(m_vec_limbs, bs_mat + m_vec_limbs * (c * bs_mat_cols + k), mat[c * mat_cols + r], acc + m_vec_limbs * (r * bs_mat_cols + k)); + } + } + } } // multiplies a single matrix with m matrices and adds result to acc static inline void mul_add_mat_x_m_mat(const int m_vec_limbs, const unsigned char *mat, const uint64_t *bs_mat, uint64_t *acc, - const int mat_rows, const int mat_cols, const int bs_mat_cols) { - - for (int r = 0; r < mat_rows; r++) { - for (int c = 0; c < mat_cols; c++) { - for (int k = 0; k < bs_mat_cols; k += 1) { - m_vec_mul_add(m_vec_limbs, bs_mat + m_vec_limbs * (c * bs_mat_cols + k), mat[r * mat_cols + c], acc + m_vec_limbs * (r * bs_mat_cols + k)); - } - } - } + const int mat_rows, const int mat_cols, const int bs_mat_cols) { + + for (int r = 0; r < mat_rows; r++) { + for (int c = 0; c < mat_cols; c++) { + for (int k = 0; k < bs_mat_cols; k += 1) { + m_vec_mul_add(m_vec_limbs, bs_mat + m_vec_limbs * (c * bs_mat_cols + k), mat[r * mat_cols + c], acc + m_vec_limbs * (r * bs_mat_cols + k)); + } + } + } } static inline void P1_times_O(const mayo_params_t* p, const uint64_t* P1, const unsigned char* O, uint64_t* acc){ - #ifndef ENABLE_PARAMS_DYNAMIC - (void) p; - #endif - mul_add_m_upper_triangular_mat_x_mat(PARAM_m_vec_limbs(p), P1, O, acc, PARAM_v(p), PARAM_v(p), PARAM_o(p), 1); + #ifndef ENABLE_PARAMS_DYNAMIC + (void) p; + #endif + mul_add_m_upper_triangular_mat_x_mat(PARAM_m_vec_limbs(p), P1, O, acc, PARAM_v(p), PARAM_v(p), PARAM_o(p), 1); } static inline void P1_times_Vt(const mayo_params_t* p, const uint64_t* P1, const unsigned char* V, uint64_t* acc){ - #ifndef ENABLE_PARAMS_DYNAMIC - (void) p; - #endif - mul_add_m_upper_triangular_mat_x_mat_trans(PARAM_m_vec_limbs(p), P1, V, acc, PARAM_v(p), PARAM_v(p), PARAM_k(p), 1); + #ifndef ENABLE_PARAMS_DYNAMIC + (void) p; + #endif + mul_add_m_upper_triangular_mat_x_mat_trans(PARAM_m_vec_limbs(p), P1, V, acc, PARAM_v(p), PARAM_v(p), PARAM_k(p), 1); } #if defined(HAVE_STACKEFFICIENT) || defined(PQM4) @@ -92,55 +92,55 @@ void P1_times_Vt(const mayo_params_t* p, const uint64_t* P1, const unsigned char // compute S * PS = [ S1 S2 ] * [ P1*S1 + P2*S2 = P1 ] = [ S1*P1 + S2*P2 ] // [ P3*S2 = P2 ] static inline void mayo_generic_m_calculate_PS_SPS(const uint64_t *P1, const uint64_t *P2, const uint64_t *P3, const unsigned char *S, - const int m, const int v, const int o, const int k, uint64_t *SPS) { - - const int n = o + v; - const int m_vec_limbs = (m + 15)/16; - - uint64_t PS[(N_MAX + K_MAX) * M_VEC_LIMBS_MAX] = { 0 }; - uint64_t accumulator[16 * ((M_MAX+15)/16) * N_MAX] = {0}; - int P1_used; - int P3_used; - - for (int col = 0; col < k; col++) { - for(unsigned int i = 0; i < sizeof(accumulator)/8; i++) { - accumulator[i] = 0; - } - P1_used = 0; - for (int row = 0; row < v; row++) { - for (int j = row; j < v; j++) { - m_vec_add(m_vec_limbs, P1 + (P1_used * m_vec_limbs), accumulator + ( row * 16 + S[col * n + j] )*m_vec_limbs); - - P1_used ++; - } - - for (int j = 0; j < o; j++) { - m_vec_add(m_vec_limbs, P2 + (row * o + j)*m_vec_limbs, accumulator + ( row * 16 + S[(col * n) + j + v] )* m_vec_limbs); - } - } - - P3_used = 0; - for (int row = v; row < n; row++) { - for (int j = row; j < n; j++) { - m_vec_add(m_vec_limbs, P3 + P3_used * m_vec_limbs, accumulator + ( row * 16 + S[col * n + j] )* m_vec_limbs ); - P3_used ++; - } - } - - for (int row = 0; row < n; row++) { - m_vec_multiply_bins(m_vec_limbs, accumulator + row * 16 * m_vec_limbs, PS + (row + col) * m_vec_limbs); - } - - for (int row = 0; row < k; row++) { - for (unsigned int i = 0; i < 16*((M_MAX+15)/16); ++i) - accumulator[i] = 0; - for (int j = 0; j < n; j++) { - m_vec_add(m_vec_limbs, PS + (j + col) * m_vec_limbs, accumulator + S[row * n + j]*m_vec_limbs); - } - m_vec_multiply_bins(m_vec_limbs, accumulator, SPS + (row * k + col) * m_vec_limbs); - } - - } + const int m, const int v, const int o, const int k, uint64_t *SPS) { + + const int n = o + v; + const int m_vec_limbs = (m + 15)/16; + + uint64_t PS[(N_MAX + K_MAX) * M_VEC_LIMBS_MAX] = { 0 }; + uint64_t accumulator[16 * ((M_MAX+15)/16) * N_MAX] = {0}; + int P1_used; + int P3_used; + + for (int col = 0; col < k; col++) { + for(unsigned int i = 0; i < sizeof(accumulator)/8; i++) { + accumulator[i] = 0; + } + P1_used = 0; + for (int row = 0; row < v; row++) { + for (int j = row; j < v; j++) { + m_vec_add(m_vec_limbs, P1 + (P1_used * m_vec_limbs), accumulator + ( row * 16 + S[col * n + j] )*m_vec_limbs); + + P1_used ++; + } + + for (int j = 0; j < o; j++) { + m_vec_add(m_vec_limbs, P2 + (row * o + j)*m_vec_limbs, accumulator + ( row * 16 + S[(col * n) + j + v] )* m_vec_limbs); + } + } + + P3_used = 0; + for (int row = v; row < n; row++) { + for (int j = row; j < n; j++) { + m_vec_add(m_vec_limbs, P3 + P3_used * m_vec_limbs, accumulator + ( row * 16 + S[col * n + j] )* m_vec_limbs ); + P3_used ++; + } + } + + for (int row = 0; row < n; row++) { + m_vec_multiply_bins(m_vec_limbs, accumulator + row * 16 * m_vec_limbs, PS + (row + col) * m_vec_limbs); + } + + for (int row = 0; row < k; row++) { + for (unsigned int i = 0; i < 16*((M_MAX+15)/16); ++i) + accumulator[i] = 0; + for (int j = 0; j < n; j++) { + m_vec_add(m_vec_limbs, PS + (j + col) * m_vec_limbs, accumulator + S[row * n + j]*m_vec_limbs); + } + m_vec_multiply_bins(m_vec_limbs, accumulator, SPS + (row * k + col) * m_vec_limbs); + } + + } } @@ -149,66 +149,66 @@ static inline void mayo_generic_m_calculate_PS_SPS(const uint64_t *P1, const uin // compute P * S^t = [ P1 P2 ] * [S1] = [P1*S1 + P2*S2] // [ 0 P3 ] [S2] [ P3*S2] static inline void mayo_generic_m_calculate_PS(const uint64_t *P1, const uint64_t *P2, const uint64_t *P3, const unsigned char *S, - const int m, const int v, const int o, const int k, uint64_t *PS) { - - const int n = o + v; - const int m_vec_limbs = (m + 15)/16; - - uint64_t accumulator[16 * ((M_MAX+15)/16) * K_MAX * N_MAX] = {0}; - int P1_used = 0; - for (int row = 0; row < v; row++) { - for (int j = row; j < v; j++) { - for (int col = 0; col < k; col++) { - m_vec_add(m_vec_limbs, P1 + (P1_used * m_vec_limbs), accumulator + ( (row * k + col) * 16 + S[col * n + j] )*m_vec_limbs); - } - P1_used ++; - } - - for (int j = 0; j < o; j++) { - for (int col = 0; col < k; col++) { - m_vec_add(m_vec_limbs, P2 + (row * o + j)*m_vec_limbs, accumulator + ( (row * k + col) * 16 + S[(col * n) + j + v] )* m_vec_limbs); - } - } - } - - int P3_used = 0; - for (int row = v; row < n; row++) { - for (int j = row; j < n; j++) { - for (int col = 0; col < k; col++) { - m_vec_add(m_vec_limbs, P3 + P3_used * m_vec_limbs, accumulator + ( (row * k + col) * 16 + S[col * n + j] )* m_vec_limbs ); - } - P3_used ++; - } - } - - // multiply stuff according to the bins of the accumulator and add to PS. - int i = 0; - while (i < n * k) { - m_vec_multiply_bins(m_vec_limbs, accumulator + i * 16 * m_vec_limbs, PS + i * m_vec_limbs); - i++; - } + const int m, const int v, const int o, const int k, uint64_t *PS) { + + const int n = o + v; + const int m_vec_limbs = (m + 15)/16; + + uint64_t accumulator[16 * ((M_MAX+15)/16) * K_MAX * N_MAX] = {0}; + int P1_used = 0; + for (int row = 0; row < v; row++) { + for (int j = row; j < v; j++) { + for (int col = 0; col < k; col++) { + m_vec_add(m_vec_limbs, P1 + (P1_used * m_vec_limbs), accumulator + ( (row * k + col) * 16 + S[col * n + j] )*m_vec_limbs); + } + P1_used ++; + } + + for (int j = 0; j < o; j++) { + for (int col = 0; col < k; col++) { + m_vec_add(m_vec_limbs, P2 + (row * o + j)*m_vec_limbs, accumulator + ( (row * k + col) * 16 + S[(col * n) + j + v] )* m_vec_limbs); + } + } + } + + int P3_used = 0; + for (int row = v; row < n; row++) { + for (int j = row; j < n; j++) { + for (int col = 0; col < k; col++) { + m_vec_add(m_vec_limbs, P3 + P3_used * m_vec_limbs, accumulator + ( (row * k + col) * 16 + S[col * n + j] )* m_vec_limbs ); + } + P3_used ++; + } + } + + // multiply stuff according to the bins of the accumulator and add to PS. + int i = 0; + while (i < n * k) { + m_vec_multiply_bins(m_vec_limbs, accumulator + i * 16 * m_vec_limbs, PS + i * m_vec_limbs); + i++; + } } // compute S * PS = [ S1 S2 ] * [ P1*S1 + P2*S2 = P1 ] = [ S1*P1 + S2*P2 ] // [ P3*S2 = P2 ] static inline void mayo_generic_m_calculate_SPS(const uint64_t *PS, const unsigned char *S, int m, int k, int n, uint64_t *SPS){ - uint64_t accumulator[16*((M_MAX+15)/16)*K_MAX*K_MAX] = {0}; - const int m_vec_limbs = (m + 15)/ 16; - for (int row = 0; row < k; row++) { - for (int j = 0; j < n; j++) { - for (int col = 0; col < k; col += 1) { - m_vec_add(m_vec_limbs, PS + (j * k + col) * m_vec_limbs, accumulator + ( (row * k + col) * 16 + S[row * n + j] )*m_vec_limbs); - } - } - } - - // multiply stuff according to the bins of the accumulator and add to PS. - int i = 0; - while (i < k*k) { - m_vec_multiply_bins(m_vec_limbs, accumulator + i * 16 * m_vec_limbs, SPS + i * m_vec_limbs); - i++; - } + uint64_t accumulator[16*((M_MAX+15)/16)*K_MAX*K_MAX] = {0}; + const int m_vec_limbs = (m + 15)/ 16; + for (int row = 0; row < k; row++) { + for (int j = 0; j < n; j++) { + for (int col = 0; col < k; col += 1) { + m_vec_add(m_vec_limbs, PS + (j * k + col) * m_vec_limbs, accumulator + ( (row * k + col) * 16 + S[row * n + j] )*m_vec_limbs); + } + } + } + + // multiply stuff according to the bins of the accumulator and add to PS. + int i = 0; + while (i < k*k) { + m_vec_multiply_bins(m_vec_limbs, accumulator + i * 16 * m_vec_limbs, SPS + i * m_vec_limbs); + i++; + } } #endif @@ -216,58 +216,58 @@ static inline void mayo_generic_m_calculate_SPS(const uint64_t *PS, const unsign static inline void P1P1t_times_O(const mayo_params_t* p, const uint64_t* P1, const unsigned char* O, uint64_t* acc){ - #ifndef ENABLE_PARAMS_DYNAMIC - (void) p; - #endif - const int param_o = PARAM_o(p); - const int param_v = PARAM_v(p); - const int m_vec_limbs = PARAM_m_vec_limbs(p); - - int bs_mat_entries_used = 0; - for (int r = 0; r < param_v; r++) { - for (int c = r; c < param_v; c++) { - if(c==r) { - bs_mat_entries_used += 1; - continue; - } - for (int k = 0; k < param_o; k += 1) { - m_vec_mul_add(m_vec_limbs, P1 + m_vec_limbs * bs_mat_entries_used, O[c * param_o + k], acc + m_vec_limbs * (r * param_o + k)); - m_vec_mul_add(m_vec_limbs, P1 + m_vec_limbs * bs_mat_entries_used, O[r * param_o + k], acc + m_vec_limbs * (c * param_o + k)); - } - bs_mat_entries_used += 1; - } - } + #ifndef ENABLE_PARAMS_DYNAMIC + (void) p; + #endif + const int param_o = PARAM_o(p); + const int param_v = PARAM_v(p); + const int m_vec_limbs = PARAM_m_vec_limbs(p); + + int bs_mat_entries_used = 0; + for (int r = 0; r < param_v; r++) { + for (int c = r; c < param_v; c++) { + if(c==r) { + bs_mat_entries_used += 1; + continue; + } + for (int k = 0; k < param_o; k += 1) { + m_vec_mul_add(m_vec_limbs, P1 + m_vec_limbs * bs_mat_entries_used, O[c * param_o + k], acc + m_vec_limbs * (r * param_o + k)); + m_vec_mul_add(m_vec_limbs, P1 + m_vec_limbs * bs_mat_entries_used, O[r * param_o + k], acc + m_vec_limbs * (c * param_o + k)); + } + bs_mat_entries_used += 1; + } + } } static inline void compute_M_and_VPV(const mayo_params_t* p, const unsigned char* Vdec, const uint64_t *L, const uint64_t *P1, uint64_t *VL, uint64_t *VP1V){ - const int param_k = PARAM_k(p); - const int param_v = PARAM_v(p); - const int param_o = PARAM_o(p); + const int param_k = PARAM_k(p); + const int param_v = PARAM_v(p); + const int param_o = PARAM_o(p); - //VL - mul_add_mat_x_m_mat(PARAM_m_vec_limbs(p), Vdec, L, VL, param_k, param_v, param_o); + //VL + mul_add_mat_x_m_mat(PARAM_m_vec_limbs(p), Vdec, L, VL, param_k, param_v, param_o); - //VP1V - uint64_t Pv[V_MAX * K_MAX * M_VEC_LIMBS_MAX] = {0}; - P1_times_Vt(p, P1, Vdec, Pv); - mul_add_mat_x_m_mat(PARAM_m_vec_limbs(p), Vdec, Pv, VP1V, param_k, param_v, param_k); + //VP1V + uint64_t Pv[V_MAX * K_MAX * M_VEC_LIMBS_MAX] = {0}; + P1_times_Vt(p, P1, Vdec, Pv); + mul_add_mat_x_m_mat(PARAM_m_vec_limbs(p), Vdec, Pv, VP1V, param_k, param_v, param_k); } static inline void compute_P3(const mayo_params_t* p, const uint64_t* P1, uint64_t *P2, const unsigned char *O, uint64_t *P3){ - const int m_vec_limbs = PARAM_m_vec_limbs(p); - const int param_v = PARAM_v(p); - const int param_o = PARAM_o(p); + const int m_vec_limbs = PARAM_m_vec_limbs(p); + const int param_v = PARAM_v(p); + const int param_o = PARAM_o(p); - // compute P1*O + P2 - P1_times_O(p, P1, O, P2); + // compute P1*O + P2 + P1_times_O(p, P1, O, P2); - // compute P3 = O^t * (P1*O + P2) - mul_add_mat_trans_x_m_mat(m_vec_limbs, O, P2, P3, param_v, param_o, param_o); + // compute P3 = O^t * (P1*O + P2) + mul_add_mat_trans_x_m_mat(m_vec_limbs, O, P2, P3, param_v, param_o, param_o); } // compute P * S^t = [ P1 P2 ] * [S1] = [P1*S1 + P2*S2] @@ -275,20 +275,20 @@ void compute_P3(const mayo_params_t* p, const uint64_t* P1, uint64_t *P2, const // compute S * PS = [ S1 S2 ] * [ P1*S1 + P2*S2 = P1 ] = [ S1*P1 + S2*P2 ] // [ P3*S2 = P2 ] static inline void m_calculate_PS_SPS(const mayo_params_t *p, const uint64_t *P1, const uint64_t *P2, const uint64_t *P3, const unsigned char *s, - uint64_t *SPS) { - // compute P * S^t = {(P1, P2), (0, P3)} * S^t = {(P1*S1 + P2*S2), (P3 * S2)} - #ifndef ENABLE_PARAMS_DYNAMIC - (void) p; - #endif - #if defined(HAVE_STACKEFFICIENT) || defined(PQM4) - mayo_generic_m_calculate_PS_SPS(P1, P2, P3, s, PARAM_m(p), PARAM_v(p), PARAM_o(p), PARAM_k(p), SPS); - #else - uint64_t PS[N_MAX * K_MAX * M_VEC_LIMBS_MAX] = { 0 }; - mayo_generic_m_calculate_PS(P1, P2, P3, s, PARAM_m(p), PARAM_v(p), PARAM_o(p), PARAM_k(p), PS); - - // compute S * P * S = S* (P*S) - mayo_generic_m_calculate_SPS(PS, s, PARAM_m(p), PARAM_k(p), PARAM_n(p), SPS); - #endif + uint64_t *SPS) { + // compute P * S^t = {(P1, P2), (0, P3)} * S^t = {(P1*S1 + P2*S2), (P3 * S2)} + #ifndef ENABLE_PARAMS_DYNAMIC + (void) p; + #endif + #if defined(HAVE_STACKEFFICIENT) || defined(PQM4) + mayo_generic_m_calculate_PS_SPS(P1, P2, P3, s, PARAM_m(p), PARAM_v(p), PARAM_o(p), PARAM_k(p), SPS); + #else + uint64_t PS[N_MAX * K_MAX * M_VEC_LIMBS_MAX] = { 0 }; + mayo_generic_m_calculate_PS(P1, P2, P3, s, PARAM_m(p), PARAM_v(p), PARAM_o(p), PARAM_k(p), PS); + + // compute S * P * S = S* (P*S) + mayo_generic_m_calculate_SPS(PS, s, PARAM_m(p), PARAM_k(p), PARAM_n(p), SPS); + #endif } #endif diff --git a/lib/mayo/mayo.c b/lib/mayo/mayo.c index 5ac21d4ef..2699e8bca 100644 --- a/lib/mayo/mayo.c +++ b/lib/mayo/mayo.c @@ -18,720 +18,720 @@ #define PK_PRF AES_128_CTR static void decode(const unsigned char *m, unsigned char *mdec, int mdeclen) { - int i; - for (i = 0; i < mdeclen / 2; ++i) { - *mdec++ = m[i] & 0xf; - *mdec++ = m[i] >> 4; - } - - if (mdeclen % 2 == 1) { - *mdec++ = m[i] & 0x0f; - } + int i; + for (i = 0; i < mdeclen / 2; ++i) { + *mdec++ = m[i] & 0xf; + *mdec++ = m[i] >> 4; + } + + if (mdeclen % 2 == 1) { + *mdec++ = m[i] & 0x0f; + } } static void encode(const unsigned char *m, unsigned char *menc, int mlen) { - int i; - for (i = 0; i < mlen / 2; ++i, m += 2) { - menc[i] = (*m) | (*(m + 1) << 4); - } - - if (mlen % 2 == 1) { - menc[i] = (*m); - } + int i; + for (i = 0; i < mlen / 2; ++i, m += 2) { + menc[i] = (*m) | (*(m + 1) << 4); + } + + if (mlen % 2 == 1) { + menc[i] = (*m); + } } static void compute_rhs(const mayo_params_t *p, uint64_t *vPv, const unsigned char *t, unsigned char *y){ - #ifndef ENABLE_PARAMS_DYNAMIC - (void) p; - #endif - - const size_t top_pos = ((PARAM_m(p) - 1) % 16) * 4; - const size_t m_vec_limbs = PARAM_m_vec_limbs(p); - - // zero out tails of m_vecs if neccesary - if(PARAM_m(p) % 16 != 0){ - uint64_t mask = 1; - mask <<= ((PARAM_m(p) % 16)*4); - mask -= 1; - for (int i = 0; i < PARAM_k(p)*PARAM_k(p); i++) - { - vPv[i*m_vec_limbs + m_vec_limbs - 1] &= mask; - } - } - - uint64_t temp[M_VEC_LIMBS_MAX] = {0}; - unsigned char *temp_bytes = (unsigned char *) temp; - for (int i = PARAM_k(p) - 1; i >= 0 ; i--) { - for (int j = i; j < PARAM_k(p); j++) { - // multiply by X (shift up 4 bits) - unsigned char top = (temp[m_vec_limbs-1] >> top_pos) % 16; - temp[m_vec_limbs-1] <<= 4; - for(int k = m_vec_limbs - 2; k>=0; k--){ - temp[k+1] ^= temp[k] >> 60; - temp[k] <<= 4; - } - // reduce mod f(X) - for (int jj = 0; jj < F_TAIL_LEN; jj++) { - if(jj%2 == 0){ + #ifndef ENABLE_PARAMS_DYNAMIC + (void) p; + #endif + + const size_t top_pos = ((PARAM_m(p) - 1) % 16) * 4; + const size_t m_vec_limbs = PARAM_m_vec_limbs(p); + + // zero out tails of m_vecs if neccesary + if(PARAM_m(p) % 16 != 0){ + uint64_t mask = 1; + mask <<= ((PARAM_m(p) % 16)*4); + mask -= 1; + for (int i = 0; i < PARAM_k(p)*PARAM_k(p); i++) + { + vPv[i*m_vec_limbs + m_vec_limbs - 1] &= mask; + } + } + + uint64_t temp[M_VEC_LIMBS_MAX] = {0}; + unsigned char *temp_bytes = (unsigned char *) temp; + for (int i = PARAM_k(p) - 1; i >= 0 ; i--) { + for (int j = i; j < PARAM_k(p); j++) { + // multiply by X (shift up 4 bits) + unsigned char top = (temp[m_vec_limbs-1] >> top_pos) % 16; + temp[m_vec_limbs-1] <<= 4; + for(int k = m_vec_limbs - 2; k>=0; k--){ + temp[k+1] ^= temp[k] >> 60; + temp[k] <<= 4; + } + // reduce mod f(X) + for (int jj = 0; jj < F_TAIL_LEN; jj++) { + if(jj%2 == 0){ #ifdef TARGET_BIG_ENDIAN - temp_bytes[(((jj/2 + 8) / 8) * 8) - 1 - (jj/2)%8] ^= mul_f(top, PARAM_f_tail(p)[jj]); + temp_bytes[(((jj/2 + 8) / 8) * 8) - 1 - (jj/2)%8] ^= mul_f(top, PARAM_f_tail(p)[jj]); #else - temp_bytes[jj/2] ^= mul_f(top, PARAM_f_tail(p)[jj]); + temp_bytes[jj/2] ^= mul_f(top, PARAM_f_tail(p)[jj]); #endif - } - else { + } + else { #ifdef TARGET_BIG_ENDIAN - temp_bytes[(((jj/2 + 8) / 8) * 8) - 1 - (jj/2)%8] ^= mul_f(top, PARAM_f_tail(p)[jj]) << 4; + temp_bytes[(((jj/2 + 8) / 8) * 8) - 1 - (jj/2)%8] ^= mul_f(top, PARAM_f_tail(p)[jj]) << 4; #else - temp_bytes[jj/2] ^= mul_f(top, PARAM_f_tail(p)[jj]) << 4; + temp_bytes[jj/2] ^= mul_f(top, PARAM_f_tail(p)[jj]) << 4; #endif - } - } - - // extract from vPv and add - for(size_t k=0; k < m_vec_limbs; k ++){ - temp[k] ^= vPv[( i * PARAM_k(p) + j )* m_vec_limbs + k] ^ ((i!=j)*vPv[( j * PARAM_k(p) + i )* m_vec_limbs + k]); - } - } - } - - // compute y - for (int i = 0; i < PARAM_m(p); i+=2) - { + } + } + + // extract from vPv and add + for(size_t k=0; k < m_vec_limbs; k ++){ + temp[k] ^= vPv[( i * PARAM_k(p) + j )* m_vec_limbs + k] ^ ((i!=j)*vPv[( j * PARAM_k(p) + i )* m_vec_limbs + k]); + } + } + } + + // compute y + for (int i = 0; i < PARAM_m(p); i+=2) + { #ifdef TARGET_BIG_ENDIAN - y[i] = t[i] ^ (temp_bytes[(((i/2 + 8) / 8) * 8) - 1 - (i/2)%8] & 0xF); - y[i+1] = t[i+1] ^ (temp_bytes[(((i/2 + 8) / 8) * 8) - 1 - (i/2)%8] >> 4); + y[i] = t[i] ^ (temp_bytes[(((i/2 + 8) / 8) * 8) - 1 - (i/2)%8] & 0xF); + y[i+1] = t[i+1] ^ (temp_bytes[(((i/2 + 8) / 8) * 8) - 1 - (i/2)%8] >> 4); #else - y[i] = t[i] ^ (temp_bytes[i/2] & 0xF); - y[i+1] = t[i+1] ^ (temp_bytes[i/2] >> 4); + y[i] = t[i] ^ (temp_bytes[i/2] & 0xF); + y[i+1] = t[i+1] ^ (temp_bytes[i/2] >> 4); #endif - } + } } static void transpose_16x16_nibbles(uint64_t *M){ - static const uint64_t even_nibbles = 0x0f0f0f0f0f0f0f0f; - static const uint64_t even_bytes = 0x00ff00ff00ff00ff; - static const uint64_t even_2bytes = 0x0000ffff0000ffff; - static const uint64_t even_half = 0x00000000ffffffff; - - for (size_t i = 0; i < 16; i+=2) - { - uint64_t t = ((M[i] >> 4 ) ^ M[i+1]) & even_nibbles; - M[i ] ^= t << 4; - M[i+1] ^= t; - } - - for (size_t i = 0; i < 16; i+=4) - { - uint64_t t0 = ((M[i ] >> 8) ^ M[i+2]) & even_bytes; - uint64_t t1 = ((M[i+1] >> 8) ^ M[i+3]) & even_bytes; - M[i ] ^= (t0 << 8); - M[i+1] ^= (t1 << 8); - M[i+2] ^= t0; - M[i+3] ^= t1; - } - - for (size_t i = 0; i < 4; i++) - { - uint64_t t0 = ((M[i ] >> 16) ^ M[i+ 4]) & even_2bytes; - uint64_t t1 = ((M[i+8] >> 16) ^ M[i+12]) & even_2bytes; - - M[i ] ^= t0 << 16; - M[i+ 8] ^= t1 << 16; - M[i+ 4] ^= t0; - M[i+12] ^= t1; - } - - for (size_t i = 0; i < 8; i++) - { - uint64_t t = ((M[i]>>32) ^ M[i+8]) & even_half; - M[i ] ^= t << 32; - M[i+8] ^= t; - } + static const uint64_t even_nibbles = 0x0f0f0f0f0f0f0f0f; + static const uint64_t even_bytes = 0x00ff00ff00ff00ff; + static const uint64_t even_2bytes = 0x0000ffff0000ffff; + static const uint64_t even_half = 0x00000000ffffffff; + + for (size_t i = 0; i < 16; i+=2) + { + uint64_t t = ((M[i] >> 4 ) ^ M[i+1]) & even_nibbles; + M[i ] ^= t << 4; + M[i+1] ^= t; + } + + for (size_t i = 0; i < 16; i+=4) + { + uint64_t t0 = ((M[i ] >> 8) ^ M[i+2]) & even_bytes; + uint64_t t1 = ((M[i+1] >> 8) ^ M[i+3]) & even_bytes; + M[i ] ^= (t0 << 8); + M[i+1] ^= (t1 << 8); + M[i+2] ^= t0; + M[i+3] ^= t1; + } + + for (size_t i = 0; i < 4; i++) + { + uint64_t t0 = ((M[i ] >> 16) ^ M[i+ 4]) & even_2bytes; + uint64_t t1 = ((M[i+8] >> 16) ^ M[i+12]) & even_2bytes; + + M[i ] ^= t0 << 16; + M[i+ 8] ^= t1 << 16; + M[i+ 4] ^= t0; + M[i+12] ^= t1; + } + + for (size_t i = 0; i < 8; i++) + { + uint64_t t = ((M[i]>>32) ^ M[i+8]) & even_half; + M[i ] ^= t << 32; + M[i+8] ^= t; + } } #define MAYO_M_OVER_8 ((M_MAX + 7) / 8) static void compute_A(const mayo_params_t *p, uint64_t *VtL, unsigned char *A_out) { - #ifndef ENABLE_PARAMS_DYNAMIC - (void) p; - #endif - - int bits_to_shift = 0; - int words_to_shift = 0; - const int m_vec_limbs = PARAM_m_vec_limbs(p); - uint64_t A[(((O_MAX*K_MAX+15)/16)*16)*MAYO_M_OVER_8] = {0}; - size_t A_width = ((PARAM_o(p)*PARAM_k(p) + 15)/16)*16; - const uint64_t *Mi, *Mj; - - // zero out tails of m_vecs if neccesary - if(PARAM_m(p) % 16 != 0){ - uint64_t mask = 1; - mask <<= (PARAM_m(p) % 16)*4; - mask -= 1; - for (int i = 0; i < PARAM_o(p)*PARAM_k(p); i++) - { - VtL[i*m_vec_limbs + m_vec_limbs - 1] &= mask; - } - } - - for (int i = 0; i <= PARAM_k(p) - 1; ++i) { - for (int j = PARAM_k(p) - 1; j >= i; --j) { - // add the M_i and M_j to A, shifted "down" by l positions - Mj = VtL + j * m_vec_limbs * PARAM_o(p); - for (int c = 0; c < PARAM_o(p); c++) { - for (int k = 0; k < m_vec_limbs; k++) - { - A[ PARAM_o(p) * i + c + (k + words_to_shift)*A_width] ^= Mj[k + c*m_vec_limbs] << bits_to_shift; - if(bits_to_shift > 0){ - A[ PARAM_o(p) * i + c + (k + words_to_shift + 1)*A_width] ^= Mj[k + c*m_vec_limbs] >> (64-bits_to_shift); - } - } - } - - if (i != j) { - Mi = VtL + i * m_vec_limbs * PARAM_o(p); - for (int c = 0; c < PARAM_o(p); c++) { - for (int k = 0; k < m_vec_limbs; k++) - { - A[PARAM_o(p) * j + c + (k + words_to_shift)*A_width] ^= Mi[k + c*m_vec_limbs] << bits_to_shift; - if(bits_to_shift > 0){ - A[PARAM_o(p) * j + c + (k + words_to_shift + 1)*A_width] ^= Mi[k + c*m_vec_limbs] >> (64-bits_to_shift); - } - } - } - } - - bits_to_shift += 4; - if(bits_to_shift == 64){ - words_to_shift ++; - bits_to_shift = 0; - } - } - } - - for (size_t c = 0; c < A_width*((PARAM_m(p) + (PARAM_k(p)+1)*PARAM_k(p)/2 +15)/16) ; c+= 16) - { - transpose_16x16_nibbles(A + c); - } - - unsigned char tab[F_TAIL_LEN*4] = {0}; - for (size_t i = 0; i < F_TAIL_LEN; i++) - { - tab[4*i] = mul_f(PARAM_f_tail(p)[i],1); - tab[4*i+1] = mul_f(PARAM_f_tail(p)[i],2); - tab[4*i+2] = mul_f(PARAM_f_tail(p)[i],4); - tab[4*i+3] = mul_f(PARAM_f_tail(p)[i],8); - } - - uint64_t low_bit_in_nibble = 0x1111111111111111; - - for (size_t c = 0; c < A_width; c+= 16) - { - for (int r = PARAM_m(p); r < PARAM_m(p) + (PARAM_k(p)+1)*PARAM_k(p)/2 ; r++) - { - size_t pos = (r/16)*A_width + c + (r%16); - uint64_t t0 = A[pos] & low_bit_in_nibble; - uint64_t t1 = (A[pos] >> 1) & low_bit_in_nibble; - uint64_t t2 = (A[pos] >> 2) & low_bit_in_nibble; - uint64_t t3 = (A[pos] >> 3) & low_bit_in_nibble; - for (size_t t = 0; t < F_TAIL_LEN; t++) - { - A[((r+t-PARAM_m(p))/16)*A_width + c + ((r+t-PARAM_m(p))%16)] ^= t0*tab[4*t+0] ^ t1*tab[4*t+1] ^ t2*tab[4*t+2] ^ t3*tab[4*t+3]; - } - } - } + #ifndef ENABLE_PARAMS_DYNAMIC + (void) p; + #endif + + int bits_to_shift = 0; + int words_to_shift = 0; + const int m_vec_limbs = PARAM_m_vec_limbs(p); + uint64_t A[(((O_MAX*K_MAX+15)/16)*16)*MAYO_M_OVER_8] = {0}; + size_t A_width = ((PARAM_o(p)*PARAM_k(p) + 15)/16)*16; + const uint64_t *Mi, *Mj; + + // zero out tails of m_vecs if neccesary + if(PARAM_m(p) % 16 != 0){ + uint64_t mask = 1; + mask <<= (PARAM_m(p) % 16)*4; + mask -= 1; + for (int i = 0; i < PARAM_o(p)*PARAM_k(p); i++) + { + VtL[i*m_vec_limbs + m_vec_limbs - 1] &= mask; + } + } + + for (int i = 0; i <= PARAM_k(p) - 1; ++i) { + for (int j = PARAM_k(p) - 1; j >= i; --j) { + // add the M_i and M_j to A, shifted "down" by l positions + Mj = VtL + j * m_vec_limbs * PARAM_o(p); + for (int c = 0; c < PARAM_o(p); c++) { + for (int k = 0; k < m_vec_limbs; k++) + { + A[ PARAM_o(p) * i + c + (k + words_to_shift)*A_width] ^= Mj[k + c*m_vec_limbs] << bits_to_shift; + if(bits_to_shift > 0){ + A[ PARAM_o(p) * i + c + (k + words_to_shift + 1)*A_width] ^= Mj[k + c*m_vec_limbs] >> (64-bits_to_shift); + } + } + } + + if (i != j) { + Mi = VtL + i * m_vec_limbs * PARAM_o(p); + for (int c = 0; c < PARAM_o(p); c++) { + for (int k = 0; k < m_vec_limbs; k++) + { + A[PARAM_o(p) * j + c + (k + words_to_shift)*A_width] ^= Mi[k + c*m_vec_limbs] << bits_to_shift; + if(bits_to_shift > 0){ + A[PARAM_o(p) * j + c + (k + words_to_shift + 1)*A_width] ^= Mi[k + c*m_vec_limbs] >> (64-bits_to_shift); + } + } + } + } + + bits_to_shift += 4; + if(bits_to_shift == 64){ + words_to_shift ++; + bits_to_shift = 0; + } + } + } + + for (size_t c = 0; c < A_width*((PARAM_m(p) + (PARAM_k(p)+1)*PARAM_k(p)/2 +15)/16) ; c+= 16) + { + transpose_16x16_nibbles(A + c); + } + + unsigned char tab[F_TAIL_LEN*4] = {0}; + for (size_t i = 0; i < F_TAIL_LEN; i++) + { + tab[4*i] = mul_f(PARAM_f_tail(p)[i],1); + tab[4*i+1] = mul_f(PARAM_f_tail(p)[i],2); + tab[4*i+2] = mul_f(PARAM_f_tail(p)[i],4); + tab[4*i+3] = mul_f(PARAM_f_tail(p)[i],8); + } + + uint64_t low_bit_in_nibble = 0x1111111111111111; + + for (size_t c = 0; c < A_width; c+= 16) + { + for (int r = PARAM_m(p); r < PARAM_m(p) + (PARAM_k(p)+1)*PARAM_k(p)/2 ; r++) + { + size_t pos = (r/16)*A_width + c + (r%16); + uint64_t t0 = A[pos] & low_bit_in_nibble; + uint64_t t1 = (A[pos] >> 1) & low_bit_in_nibble; + uint64_t t2 = (A[pos] >> 2) & low_bit_in_nibble; + uint64_t t3 = (A[pos] >> 3) & low_bit_in_nibble; + for (size_t t = 0; t < F_TAIL_LEN; t++) + { + A[((r+t-PARAM_m(p))/16)*A_width + c + ((r+t-PARAM_m(p))%16)] ^= t0*tab[4*t+0] ^ t1*tab[4*t+1] ^ t2*tab[4*t+2] ^ t3*tab[4*t+3]; + } + } + } #ifdef TARGET_BIG_ENDIAN - for (int i = 0; i < (((PARAM_o(p)*PARAM_k(p)+15)/16)*16)*MAYO_M_OVER_8; ++i) - A[i] = BSWAP64(A[i]); + for (int i = 0; i < (((PARAM_o(p)*PARAM_k(p)+15)/16)*16)*MAYO_M_OVER_8; ++i) + A[i] = BSWAP64(A[i]); #endif - for (int r = 0; r < PARAM_m(p); r+=16) - { - for (int c = 0; c < PARAM_A_cols(p)-1 ; c+=16) - { - for (int i = 0; i + r < PARAM_m(p); i++) - { - decode( (unsigned char *) &A[r*A_width/16 + c + i], A_out + PARAM_A_cols(p)*(r+i) + c, MAYO_MIN(16, PARAM_A_cols(p)-1-c)); - } - } - } + for (int r = 0; r < PARAM_m(p); r+=16) + { + for (int c = 0; c < PARAM_A_cols(p)-1 ; c+=16) + { + for (int i = 0; i + r < PARAM_m(p); i++) + { + decode( (unsigned char *) &A[r*A_width/16 + c + i], A_out + PARAM_A_cols(p)*(r+i) + c, MAYO_MIN(16, PARAM_A_cols(p)-1-c)); + } + } + } } static void unpack_m_vecs(const unsigned char *in, uint64_t *out, int vecs, int m){ - const int m_vec_limbs = (m + 15) / 16; - unsigned char *_out = (unsigned char *) out; - uint64_t tmp[ (M_MAX + 15) / 16] = {0}; - for (int i = vecs-1; i >= 0; i--) - { - memcpy(tmp, in + i*m/2, m/2); - memcpy(_out + i*m_vec_limbs*sizeof(uint64_t), tmp, m_vec_limbs*sizeof(uint64_t)); - } + const int m_vec_limbs = (m + 15) / 16; + unsigned char *_out = (unsigned char *) out; + uint64_t tmp[ (M_MAX + 15) / 16] = {0}; + for (int i = vecs-1; i >= 0; i--) + { + memcpy(tmp, in + i*m/2, m/2); + memcpy(_out + i*m_vec_limbs*sizeof(uint64_t), tmp, m_vec_limbs*sizeof(uint64_t)); + } } static void pack_m_vecs(const uint64_t *in, unsigned char *out, int vecs, int m){ - const int m_vec_limbs = (m + 15) / 16; - unsigned char *_in = (unsigned char *) in; - for (int i = 0; i < vecs; i++) - { - memmove(out + (i*m/2), _in + i*m_vec_limbs*sizeof(uint64_t), m/2); - } + const int m_vec_limbs = (m + 15) / 16; + unsigned char *_in = (unsigned char *) in; + for (int i = 0; i < vecs; i++) + { + memmove(out + (i*m/2), _in + i*m_vec_limbs*sizeof(uint64_t), m/2); + } } static void expand_P1_P2(const mayo_params_t *p, uint64_t *P, const unsigned char *seed_pk) { - #ifndef ENABLE_PARAMS_DYNAMIC - (void) p; - #endif - PK_PRF((unsigned char *)P, PARAM_P1_bytes(p) + PARAM_P2_bytes(p), seed_pk, PARAM_pk_seed_bytes(p)); - unpack_m_vecs((unsigned char *)P, P, (PARAM_P1_limbs(p) + PARAM_P2_limbs(p))/PARAM_m_vec_limbs(p), PARAM_m(p)); + #ifndef ENABLE_PARAMS_DYNAMIC + (void) p; + #endif + PK_PRF((unsigned char *)P, PARAM_P1_bytes(p) + PARAM_P2_bytes(p), seed_pk, PARAM_pk_seed_bytes(p)); + unpack_m_vecs((unsigned char *)P, P, (PARAM_P1_limbs(p) + PARAM_P2_limbs(p))/PARAM_m_vec_limbs(p), PARAM_m(p)); } static void eval_public_map(const mayo_params_t *p, const unsigned char *s, const uint64_t *P1, const uint64_t *P2, const uint64_t *P3, unsigned char *eval){ - uint64_t SPS[K_MAX * K_MAX * M_VEC_LIMBS_MAX] = {0}; - // combine computing PS and SPS in a single step - m_calculate_PS_SPS(p, P1, P2, P3, s, SPS); - unsigned char zero[M_MAX] = {0}; - compute_rhs(p, SPS, zero, eval); + uint64_t SPS[K_MAX * K_MAX * M_VEC_LIMBS_MAX] = {0}; + // combine computing PS and SPS in a single step + m_calculate_PS_SPS(p, P1, P2, P3, s, SPS); + unsigned char zero[M_MAX] = {0}; + compute_rhs(p, SPS, zero, eval); } // Public API int mayo_keypair(const mayo_params_t *p, unsigned char *pk, unsigned char *sk) { - int ret = 0; + int ret = 0; - ret = mayo_keypair_compact(p, pk, sk); - if (ret != MAYO_OK) { - goto err; - } + ret = mayo_keypair_compact(p, pk, sk); + if (ret != MAYO_OK) { + goto err; + } err: - return ret; + return ret; } int mayo_expand_sk(const mayo_params_t *p, const unsigned char *csk, - sk_t *sk) { - int ret = MAYO_OK; - unsigned char S[PK_SEED_BYTES_MAX + O_BYTES_MAX]; - uint64_t *P = sk->p; - unsigned char *O = sk->O; + sk_t *sk) { + int ret = MAYO_OK; + unsigned char S[PK_SEED_BYTES_MAX + O_BYTES_MAX]; + uint64_t *P = sk->p; + unsigned char *O = sk->O; - const int param_o = PARAM_o(p); - const int param_v = PARAM_v(p); - const int param_O_bytes = PARAM_O_bytes(p); - const int param_pk_seed_bytes = PARAM_pk_seed_bytes(p); - const int param_sk_seed_bytes = PARAM_sk_seed_bytes(p); + const int param_o = PARAM_o(p); + const int param_v = PARAM_v(p); + const int param_O_bytes = PARAM_O_bytes(p); + const int param_pk_seed_bytes = PARAM_pk_seed_bytes(p); + const int param_sk_seed_bytes = PARAM_sk_seed_bytes(p); - const unsigned char *seed_sk = csk; - unsigned char *seed_pk = S; + const unsigned char *seed_sk = csk; + unsigned char *seed_pk = S; - shake256(S, param_pk_seed_bytes + param_O_bytes, seed_sk, - param_sk_seed_bytes); - decode(S + param_pk_seed_bytes, O, param_v * param_o); + shake256(S, param_pk_seed_bytes + param_O_bytes, seed_sk, + param_sk_seed_bytes); + decode(S + param_pk_seed_bytes, O, param_v * param_o); #ifdef ENABLE_CT_TESTING - VALGRIND_MAKE_MEM_DEFINED(seed_pk, param_pk_seed_bytes); + VALGRIND_MAKE_MEM_DEFINED(seed_pk, param_pk_seed_bytes); #endif - expand_P1_P2(p, P, seed_pk); + expand_P1_P2(p, P, seed_pk); #ifdef TARGET_BIG_ENDIAN - for (int i = 0; i < PARAM_P1_limbs(p) + PARAM_P2_limbs(p); ++i) { - P[i] = BSWAP64(P[i]); - } + for (int i = 0; i < PARAM_P1_limbs(p) + PARAM_P2_limbs(p); ++i) { + P[i] = BSWAP64(P[i]); + } #endif - uint64_t *P2 = P + PARAM_P1_limbs(p); + uint64_t *P2 = P + PARAM_P1_limbs(p); - uint64_t *P1 = P; + uint64_t *P1 = P; - // compute L_i = (P1 + P1^t)*O + P2 - uint64_t *L = P2; - P1P1t_times_O(p, P1, O, L); + // compute L_i = (P1 + P1^t)*O + P2 + uint64_t *L = P2; + P1P1t_times_O(p, P1, O, L); #ifdef TARGET_BIG_ENDIAN - for (int i = 0; i < PARAM_P1_limbs(p) + PARAM_P2_limbs(p); ++i) { - P[i] = BSWAP64(P[i]); - } + for (int i = 0; i < PARAM_P1_limbs(p) + PARAM_P2_limbs(p); ++i) { + P[i] = BSWAP64(P[i]); + } #endif - mayo_secure_clear(S, PK_SEED_BYTES_MAX + O_BYTES_MAX); - return ret; + mayo_secure_clear(S, PK_SEED_BYTES_MAX + O_BYTES_MAX); + return ret; } int mayo_sign_signature(const mayo_params_t *p, unsigned char *sig, - size_t *siglen, const unsigned char *m, - size_t mlen, const unsigned char *csk) { - int ret = MAYO_OK; - unsigned char tenc[M_BYTES_MAX], t[M_MAX]; // no secret data - unsigned char y[M_MAX]; // secret data - unsigned char salt[SALT_BYTES_MAX]; // not secret data - unsigned char V[K_MAX * V_BYTES_MAX + R_BYTES_MAX], Vdec[V_MAX * K_MAX]; // secret data - unsigned char A[((M_MAX+7)/8*8) * (K_MAX * O_MAX + 1)] = { 0 }; // secret data - unsigned char x[K_MAX * N_MAX]; // not secret data - unsigned char r[K_MAX * O_MAX + 1] = { 0 }; // secret data - unsigned char s[K_MAX * N_MAX]; // not secret data - const unsigned char *seed_sk; - alignas(32) sk_t sk; // secret data - unsigned char Ox[V_MAX]; // secret data - unsigned char tmp[DIGEST_BYTES_MAX + SALT_BYTES_MAX + SK_SEED_BYTES_MAX + 1]; - unsigned char *ctrbyte; - unsigned char *vi; - - const int param_m = PARAM_m(p); - const int param_n = PARAM_n(p); - const int param_o = PARAM_o(p); - const int param_k = PARAM_k(p); - const int param_v = PARAM_v(p); - const int param_m_bytes = PARAM_m_bytes(p); - const int param_v_bytes = PARAM_v_bytes(p); - const int param_r_bytes = PARAM_r_bytes(p); - const int param_sig_bytes = PARAM_sig_bytes(p); - const int param_A_cols = PARAM_A_cols(p); - const int param_digest_bytes = PARAM_digest_bytes(p); - const int param_sk_seed_bytes = PARAM_sk_seed_bytes(p); - const int param_salt_bytes = PARAM_salt_bytes(p); - - ret = mayo_expand_sk(p, csk, &sk); - if (ret != MAYO_OK) { - goto err; - } - - seed_sk = csk; - - - // hash message - shake256(tmp, param_digest_bytes, m, mlen); - - uint64_t *P1 = sk.p; - uint64_t *L = P1 + PARAM_P1_limbs(p); - uint64_t Mtmp[K_MAX * O_MAX * M_VEC_LIMBS_MAX] = {0}; + size_t *siglen, const unsigned char *m, + size_t mlen, const unsigned char *csk) { + int ret = MAYO_OK; + unsigned char tenc[M_BYTES_MAX], t[M_MAX]; // no secret data + unsigned char y[M_MAX]; // secret data + unsigned char salt[SALT_BYTES_MAX]; // not secret data + unsigned char V[K_MAX * V_BYTES_MAX + R_BYTES_MAX], Vdec[V_MAX * K_MAX]; // secret data + unsigned char A[((M_MAX+7)/8*8) * (K_MAX * O_MAX + 1)] = { 0 }; // secret data + unsigned char x[K_MAX * N_MAX]; // not secret data + unsigned char r[K_MAX * O_MAX + 1] = { 0 }; // secret data + unsigned char s[K_MAX * N_MAX]; // not secret data + const unsigned char *seed_sk; + alignas(32) sk_t sk; // secret data + unsigned char Ox[V_MAX]; // secret data + unsigned char tmp[DIGEST_BYTES_MAX + SALT_BYTES_MAX + SK_SEED_BYTES_MAX + 1]; + unsigned char *ctrbyte; + unsigned char *vi; + + const int param_m = PARAM_m(p); + const int param_n = PARAM_n(p); + const int param_o = PARAM_o(p); + const int param_k = PARAM_k(p); + const int param_v = PARAM_v(p); + const int param_m_bytes = PARAM_m_bytes(p); + const int param_v_bytes = PARAM_v_bytes(p); + const int param_r_bytes = PARAM_r_bytes(p); + const int param_sig_bytes = PARAM_sig_bytes(p); + const int param_A_cols = PARAM_A_cols(p); + const int param_digest_bytes = PARAM_digest_bytes(p); + const int param_sk_seed_bytes = PARAM_sk_seed_bytes(p); + const int param_salt_bytes = PARAM_salt_bytes(p); + + ret = mayo_expand_sk(p, csk, &sk); + if (ret != MAYO_OK) { + goto err; + } + + seed_sk = csk; + + + // hash message + shake256(tmp, param_digest_bytes, m, mlen); + + uint64_t *P1 = sk.p; + uint64_t *L = P1 + PARAM_P1_limbs(p); + uint64_t Mtmp[K_MAX * O_MAX * M_VEC_LIMBS_MAX] = {0}; #ifdef TARGET_BIG_ENDIAN - for (int i = 0; i < PARAM_P1_limbs(p); ++i) { - P1[i] = BSWAP64(P1[i]); - } - for (int i = 0; i < PARAM_P2_limbs(p); ++i) { - L[i] = BSWAP64(L[i]); - } + for (int i = 0; i < PARAM_P1_limbs(p); ++i) { + P1[i] = BSWAP64(P1[i]); + } + for (int i = 0; i < PARAM_P2_limbs(p); ++i) { + L[i] = BSWAP64(L[i]); + } #endif - // choose the randomizer - #if defined(PQM4) || defined(HAVE_RANDOMBYTES_NORETVAL) - randombytes(tmp + param_digest_bytes, param_salt_bytes); - #else - if (randombytes(tmp + param_digest_bytes, param_salt_bytes) != MAYO_OK) { - ret = MAYO_ERR; - goto err; - } - #endif - - // hashing to salt - memcpy(tmp + param_digest_bytes + param_salt_bytes, seed_sk, - param_sk_seed_bytes); - shake256(salt, param_salt_bytes, tmp, - param_digest_bytes + param_salt_bytes + param_sk_seed_bytes); + // choose the randomizer + #if defined(PQM4) || defined(HAVE_RANDOMBYTES_NORETVAL) + randombytes(tmp + param_digest_bytes, param_salt_bytes); + #else + if (randombytes(tmp + param_digest_bytes, param_salt_bytes) != MAYO_OK) { + ret = MAYO_ERR; + goto err; + } + #endif + + // hashing to salt + memcpy(tmp + param_digest_bytes + param_salt_bytes, seed_sk, + param_sk_seed_bytes); + shake256(salt, param_salt_bytes, tmp, + param_digest_bytes + param_salt_bytes + param_sk_seed_bytes); #ifdef ENABLE_CT_TESTING - VALGRIND_MAKE_MEM_DEFINED(salt, SALT_BYTES_MAX); // Salt is not secret + VALGRIND_MAKE_MEM_DEFINED(salt, SALT_BYTES_MAX); // Salt is not secret #endif - // hashing to t - memcpy(tmp + param_digest_bytes, salt, param_salt_bytes); - ctrbyte = tmp + param_digest_bytes + param_salt_bytes + param_sk_seed_bytes; + // hashing to t + memcpy(tmp + param_digest_bytes, salt, param_salt_bytes); + ctrbyte = tmp + param_digest_bytes + param_salt_bytes + param_sk_seed_bytes; - shake256(tenc, param_m_bytes, tmp, param_digest_bytes + param_salt_bytes); + shake256(tenc, param_m_bytes, tmp, param_digest_bytes + param_salt_bytes); - decode(tenc, t, param_m); // may not be necessary + decode(tenc, t, param_m); // may not be necessary - for (int ctr = 0; ctr <= 255; ++ctr) { - *ctrbyte = (unsigned char)ctr; + for (int ctr = 0; ctr <= 255; ++ctr) { + *ctrbyte = (unsigned char)ctr; - shake256(V, param_k * param_v_bytes + param_r_bytes, tmp, - param_digest_bytes + param_salt_bytes + param_sk_seed_bytes + 1); + shake256(V, param_k * param_v_bytes + param_r_bytes, tmp, + param_digest_bytes + param_salt_bytes + param_sk_seed_bytes + 1); - // decode the v_i vectors - for (int i = 0; i <= param_k - 1; ++i) { - decode(V + i * param_v_bytes, Vdec + i * param_v, param_v); - } + // decode the v_i vectors + for (int i = 0; i <= param_k - 1; ++i) { + decode(V + i * param_v_bytes, Vdec + i * param_v, param_v); + } - // compute M_i matrices and all v_i*P1*v_j - compute_M_and_VPV(p, Vdec, L, P1, Mtmp, (uint64_t*) A); + // compute M_i matrices and all v_i*P1*v_j + compute_M_and_VPV(p, Vdec, L, P1, Mtmp, (uint64_t*) A); - compute_rhs(p, (uint64_t*) A, t, y); - compute_A(p, Mtmp, A); + compute_rhs(p, (uint64_t*) A, t, y); + compute_A(p, Mtmp, A); - for (int i = 0; i < param_m; i++) - { - A[(1+i)*(param_k*param_o + 1) - 1] = 0; - } + for (int i = 0; i < param_m; i++) + { + A[(1+i)*(param_k*param_o + 1) - 1] = 0; + } - decode(V + param_k * param_v_bytes, r, - param_k * - param_o); + decode(V + param_k * param_v_bytes, r, + param_k * + param_o); - if (sample_solution(p, A, y, r, x, param_k, param_o, param_m, param_A_cols)) { - break; - } else { - memset(Mtmp, 0, sizeof(Mtmp)); - memset(A, 0, sizeof(A)); - } - } + if (sample_solution(p, A, y, r, x, param_k, param_o, param_m, param_A_cols)) { + break; + } else { + memset(Mtmp, 0, sizeof(Mtmp)); + memset(A, 0, sizeof(A)); + } + } - for (int i = 0; i <= param_k - 1; ++i) { - vi = Vdec + i * (param_n - param_o); - mat_mul(sk.O, x + i * param_o, Ox, param_o, param_n - param_o, 1); - mat_add(vi, Ox, s + i * param_n, param_n - param_o, 1); - memcpy(s + i * param_n + (param_n - param_o), x + i * param_o, param_o); - } - encode(s, sig, param_n * param_k); + for (int i = 0; i <= param_k - 1; ++i) { + vi = Vdec + i * (param_n - param_o); + mat_mul(sk.O, x + i * param_o, Ox, param_o, param_n - param_o, 1); + mat_add(vi, Ox, s + i * param_n, param_n - param_o, 1); + memcpy(s + i * param_n + (param_n - param_o), x + i * param_o, param_o); + } + encode(s, sig, param_n * param_k); - memcpy(sig + param_sig_bytes - param_salt_bytes, salt, param_salt_bytes); - *siglen = param_sig_bytes; + memcpy(sig + param_sig_bytes - param_salt_bytes, salt, param_salt_bytes); + *siglen = param_sig_bytes; err: - mayo_secure_clear(V, sizeof(V)); - mayo_secure_clear(Vdec, sizeof(Vdec)); - mayo_secure_clear(A, sizeof(A)); - mayo_secure_clear(r, sizeof(r)); - mayo_secure_clear(sk.O, sizeof(sk.O)); - mayo_secure_clear(&sk, sizeof(sk_t)); - mayo_secure_clear(Ox, sizeof(Ox)); - mayo_secure_clear(tmp, sizeof(tmp)); - mayo_secure_clear(Mtmp, sizeof(Mtmp)); - return ret; + mayo_secure_clear(V, sizeof(V)); + mayo_secure_clear(Vdec, sizeof(Vdec)); + mayo_secure_clear(A, sizeof(A)); + mayo_secure_clear(r, sizeof(r)); + mayo_secure_clear(sk.O, sizeof(sk.O)); + mayo_secure_clear(&sk, sizeof(sk_t)); + mayo_secure_clear(Ox, sizeof(Ox)); + mayo_secure_clear(tmp, sizeof(tmp)); + mayo_secure_clear(Mtmp, sizeof(Mtmp)); + return ret; } int mayo_sign(const mayo_params_t *p, unsigned char *sm, - size_t *smlen, const unsigned char *m, - size_t mlen, const unsigned char *csk) { - int ret = MAYO_OK; - const int param_sig_bytes = PARAM_sig_bytes(p); - size_t siglen; - memmove(sm + param_sig_bytes, m, mlen); - ret = mayo_sign_signature(p, sm, &siglen, sm + param_sig_bytes, mlen, csk); - if (ret != MAYO_OK || siglen != (size_t) param_sig_bytes){ - memset(sm, 0, siglen + mlen); - goto err; - } - - *smlen = siglen + mlen; + size_t *smlen, const unsigned char *m, + size_t mlen, const unsigned char *csk) { + int ret = MAYO_OK; + const int param_sig_bytes = PARAM_sig_bytes(p); + size_t siglen; + memmove(sm + param_sig_bytes, m, mlen); + ret = mayo_sign_signature(p, sm, &siglen, sm + param_sig_bytes, mlen, csk); + if (ret != MAYO_OK || siglen != (size_t) param_sig_bytes){ + memset(sm, 0, siglen + mlen); + goto err; + } + + *smlen = siglen + mlen; err: - return ret; + return ret; } int mayo_open(const mayo_params_t *p, unsigned char *m, - size_t *mlen, const unsigned char *sm, - size_t smlen, const unsigned char *pk) { - const int param_sig_bytes = PARAM_sig_bytes(p); - if (smlen < (size_t)param_sig_bytes) { - return MAYO_ERR; - } - int result = mayo_verify(p, sm + param_sig_bytes, smlen - param_sig_bytes, sm, - pk); - - if (result == MAYO_OK) { - *mlen = smlen - param_sig_bytes; - memmove(m, sm + param_sig_bytes, *mlen); - } - - return result; + size_t *mlen, const unsigned char *sm, + size_t smlen, const unsigned char *pk) { + const int param_sig_bytes = PARAM_sig_bytes(p); + if (smlen < (size_t)param_sig_bytes) { + return MAYO_ERR; + } + int result = mayo_verify(p, sm + param_sig_bytes, smlen - param_sig_bytes, sm, + pk); + + if (result == MAYO_OK) { + *mlen = smlen - param_sig_bytes; + memmove(m, sm + param_sig_bytes, *mlen); + } + + return result; } int mayo_keypair_compact(const mayo_params_t *p, unsigned char *cpk, - unsigned char *csk) { - int ret = MAYO_OK; - unsigned char *seed_sk = csk; - unsigned char S[PK_SEED_BYTES_MAX + O_BYTES_MAX]; - uint64_t P[P1_LIMBS_MAX + P2_LIMBS_MAX]; - uint64_t P3[O_MAX*O_MAX*M_VEC_LIMBS_MAX] = {0}; - - unsigned char *seed_pk; - unsigned char O[(V_MAX)*O_MAX]; - - const int m_vec_limbs = PARAM_m_vec_limbs(p); - const int param_m = PARAM_m(p); - const int param_v = PARAM_v(p); - const int param_o = PARAM_o(p); - const int param_O_bytes = PARAM_O_bytes(p); - const int param_P1_limbs = PARAM_P1_limbs(p); - const int param_P3_limbs = PARAM_P3_limbs(p); - const int param_pk_seed_bytes = PARAM_pk_seed_bytes(p); - const int param_sk_seed_bytes = PARAM_sk_seed_bytes(p); - - uint64_t *P1 = P; - uint64_t *P2 = P + param_P1_limbs; - - // seed_sk $←- B^(sk_seed bytes) - #if defined(PQM4) || defined(HAVE_RANDOMBYTES_NORETVAL) - randombytes(seed_sk, param_sk_seed_bytes); - #else - if (randombytes(seed_sk, param_sk_seed_bytes) != MAYO_OK) { - ret = MAYO_ERR; - goto err; - } - #endif - - // S ← shake256(seedsk, pk seed bytes + O bytes) - shake256(S, param_pk_seed_bytes + param_O_bytes, seed_sk, - param_sk_seed_bytes); - // seed_pk ← s[0 : pk_seed_bytes] - seed_pk = S; - - // o ← Decode_o(s[pk_seed_bytes : pk_seed_bytes + o_bytes]) - decode(S + param_pk_seed_bytes, O, param_v * param_o); + unsigned char *csk) { + int ret = MAYO_OK; + unsigned char *seed_sk = csk; + unsigned char S[PK_SEED_BYTES_MAX + O_BYTES_MAX]; + uint64_t P[P1_LIMBS_MAX + P2_LIMBS_MAX]; + uint64_t P3[O_MAX*O_MAX*M_VEC_LIMBS_MAX] = {0}; + + unsigned char *seed_pk; + unsigned char O[(V_MAX)*O_MAX]; + + const int m_vec_limbs = PARAM_m_vec_limbs(p); + const int param_m = PARAM_m(p); + const int param_v = PARAM_v(p); + const int param_o = PARAM_o(p); + const int param_O_bytes = PARAM_O_bytes(p); + const int param_P1_limbs = PARAM_P1_limbs(p); + const int param_P3_limbs = PARAM_P3_limbs(p); + const int param_pk_seed_bytes = PARAM_pk_seed_bytes(p); + const int param_sk_seed_bytes = PARAM_sk_seed_bytes(p); + + uint64_t *P1 = P; + uint64_t *P2 = P + param_P1_limbs; + + // seed_sk $←- B^(sk_seed bytes) + #if defined(PQM4) || defined(HAVE_RANDOMBYTES_NORETVAL) + randombytes(seed_sk, param_sk_seed_bytes); + #else + if (randombytes(seed_sk, param_sk_seed_bytes) != MAYO_OK) { + ret = MAYO_ERR; + goto err; + } + #endif + + // S ← shake256(seedsk, pk seed bytes + O bytes) + shake256(S, param_pk_seed_bytes + param_O_bytes, seed_sk, + param_sk_seed_bytes); + // seed_pk ← s[0 : pk_seed_bytes] + seed_pk = S; + + // o ← Decode_o(s[pk_seed_bytes : pk_seed_bytes + o_bytes]) + decode(S + param_pk_seed_bytes, O, param_v * param_o); #ifdef ENABLE_CT_TESTING - VALGRIND_MAKE_MEM_DEFINED(seed_pk, param_pk_seed_bytes); + VALGRIND_MAKE_MEM_DEFINED(seed_pk, param_pk_seed_bytes); #endif - expand_P1_P2(p, P, seed_pk); + expand_P1_P2(p, P, seed_pk); - // compute P3 (modifies P2 in the process) - compute_P3(p, P1, P2, O, P3); + // compute P3 (modifies P2 in the process) + compute_P3(p, P1, P2, O, P3); - // store seed_pk in cpk - memcpy(cpk, seed_pk, param_pk_seed_bytes); + // store seed_pk in cpk + memcpy(cpk, seed_pk, param_pk_seed_bytes); - uint64_t P3_upper[P3_LIMBS_MAX]; + uint64_t P3_upper[P3_LIMBS_MAX]; - // compute Upper(P3) and store in cpk - m_upper(p, P3, P3_upper, param_o); - pack_m_vecs(P3_upper, cpk + param_pk_seed_bytes, param_P3_limbs/m_vec_limbs, param_m); + // compute Upper(P3) and store in cpk + m_upper(p, P3, P3_upper, param_o); + pack_m_vecs(P3_upper, cpk + param_pk_seed_bytes, param_P3_limbs/m_vec_limbs, param_m); #if !defined(PQM4) && !defined(HAVE_RANDOMBYTES_NORETVAL) - err: + err: #endif - mayo_secure_clear(O, sizeof(O)); - mayo_secure_clear(P2, PARAM_P2_limbs(p)*sizeof(uint64_t)); - mayo_secure_clear(P3, sizeof(P3)); - return ret; + mayo_secure_clear(O, sizeof(O)); + mayo_secure_clear(P2, PARAM_P2_limbs(p)*sizeof(uint64_t)); + mayo_secure_clear(P3, sizeof(P3)); + return ret; } //// ADDED FOR ZENROOM INTEGRATION // To derive the compact public key from the compact private key int mayo_derive_cpk(const mayo_params_t *p, unsigned char *cpk, - const unsigned char *csk) { - int ret = MAYO_OK; - const unsigned char *seed_sk = csk; - unsigned char S[PK_SEED_BYTES_MAX + O_BYTES_MAX]; - uint64_t P[P1_LIMBS_MAX + P2_LIMBS_MAX]; - uint64_t P3[O_MAX*O_MAX*M_VEC_LIMBS_MAX] = {0}; - - unsigned char *seed_pk; - unsigned char O[(V_MAX)*O_MAX]; - - const int m_vec_limbs = PARAM_m_vec_limbs(p); - const int param_m = PARAM_m(p); - const int param_v = PARAM_v(p); - const int param_o = PARAM_o(p); - const int param_O_bytes = PARAM_O_bytes(p); - const int param_P1_limbs = PARAM_P1_limbs(p); - const int param_P3_limbs = PARAM_P3_limbs(p); - const int param_pk_seed_bytes = PARAM_pk_seed_bytes(p); - const int param_sk_seed_bytes = PARAM_sk_seed_bytes(p); - - uint64_t *P1 = P; - uint64_t *P2 = P + param_P1_limbs; - - // S ← shake256(seedsk, pk seed bytes + O bytes) - shake256(S, param_pk_seed_bytes + param_O_bytes, seed_sk, - param_sk_seed_bytes); - // seed_pk ← s[0 : pk_seed_bytes] - seed_pk = S; - - // o ← Decode_o(s[pk_seed_bytes : pk_seed_bytes + o_bytes]) - decode(S + param_pk_seed_bytes, O, param_v * param_o); + const unsigned char *csk) { + int ret = MAYO_OK; + const unsigned char *seed_sk = csk; + unsigned char S[PK_SEED_BYTES_MAX + O_BYTES_MAX]; + uint64_t P[P1_LIMBS_MAX + P2_LIMBS_MAX]; + uint64_t P3[O_MAX*O_MAX*M_VEC_LIMBS_MAX] = {0}; + + unsigned char *seed_pk; + unsigned char O[(V_MAX)*O_MAX]; + + const int m_vec_limbs = PARAM_m_vec_limbs(p); + const int param_m = PARAM_m(p); + const int param_v = PARAM_v(p); + const int param_o = PARAM_o(p); + const int param_O_bytes = PARAM_O_bytes(p); + const int param_P1_limbs = PARAM_P1_limbs(p); + const int param_P3_limbs = PARAM_P3_limbs(p); + const int param_pk_seed_bytes = PARAM_pk_seed_bytes(p); + const int param_sk_seed_bytes = PARAM_sk_seed_bytes(p); + + uint64_t *P1 = P; + uint64_t *P2 = P + param_P1_limbs; + + // S ← shake256(seedsk, pk seed bytes + O bytes) + shake256(S, param_pk_seed_bytes + param_O_bytes, seed_sk, + param_sk_seed_bytes); + // seed_pk ← s[0 : pk_seed_bytes] + seed_pk = S; + + // o ← Decode_o(s[pk_seed_bytes : pk_seed_bytes + o_bytes]) + decode(S + param_pk_seed_bytes, O, param_v * param_o); #ifdef ENABLE_CT_TESTING - VALGRIND_MAKE_MEM_DEFINED(seed_pk, param_pk_seed_bytes); + VALGRIND_MAKE_MEM_DEFINED(seed_pk, param_pk_seed_bytes); #endif - expand_P1_P2(p, P, seed_pk); + expand_P1_P2(p, P, seed_pk); - // compute P3 (modifies P2 in the process) - compute_P3(p, P1, P2, O, P3); + // compute P3 (modifies P2 in the process) + compute_P3(p, P1, P2, O, P3); - // store seed_pk in cpk - memcpy(cpk, seed_pk, param_pk_seed_bytes); + // store seed_pk in cpk + memcpy(cpk, seed_pk, param_pk_seed_bytes); - uint64_t P3_upper[P3_LIMBS_MAX]; + uint64_t P3_upper[P3_LIMBS_MAX]; - // compute Upper(P3) and store in cpk - m_upper(p, P3, P3_upper, param_o); - pack_m_vecs(P3_upper, cpk + param_pk_seed_bytes, param_P3_limbs/m_vec_limbs, param_m); + // compute Upper(P3) and store in cpk + m_upper(p, P3, P3_upper, param_o); + pack_m_vecs(P3_upper, cpk + param_pk_seed_bytes, param_P3_limbs/m_vec_limbs, param_m); - mayo_secure_clear(O, sizeof(O)); - mayo_secure_clear(P2, PARAM_P2_limbs(p)*sizeof(uint64_t)); - mayo_secure_clear(P3, sizeof(P3)); - return ret; + mayo_secure_clear(O, sizeof(O)); + mayo_secure_clear(P2, PARAM_P2_limbs(p)*sizeof(uint64_t)); + mayo_secure_clear(P3, sizeof(P3)); + return ret; } //// int mayo_expand_pk(const mayo_params_t *p, const unsigned char *cpk, - uint64_t *pk) { - expand_P1_P2(p, pk, cpk); + uint64_t *pk) { + expand_P1_P2(p, pk, cpk); - unpack_m_vecs(cpk + PARAM_pk_seed_bytes(p), pk + PARAM_P1_limbs(p) + PARAM_P2_limbs(p), PARAM_P3_limbs(p)/PARAM_m_vec_limbs(p), PARAM_m(p)); + unpack_m_vecs(cpk + PARAM_pk_seed_bytes(p), pk + PARAM_P1_limbs(p) + PARAM_P2_limbs(p), PARAM_P3_limbs(p)/PARAM_m_vec_limbs(p), PARAM_m(p)); - return MAYO_OK; + return MAYO_OK; } int mayo_verify(const mayo_params_t *p, const unsigned char *m, - size_t mlen, const unsigned char *sig, - const unsigned char *cpk) { - unsigned char tEnc[M_BYTES_MAX]; - unsigned char t[M_MAX]; - unsigned char y[2 * M_MAX] = {0}; // extra space for reduction mod f(X) - unsigned char s[K_MAX * N_MAX]; - uint64_t pk[P1_LIMBS_MAX + P2_LIMBS_MAX + P3_LIMBS_MAX] = {0}; - unsigned char tmp[DIGEST_BYTES_MAX + SALT_BYTES_MAX]; - - const int param_m = PARAM_m(p); - const int param_n = PARAM_n(p); - const int param_k = PARAM_k(p); - const int param_m_bytes = PARAM_m_bytes(p); - const int param_sig_bytes = PARAM_sig_bytes(p); - const int param_digest_bytes = PARAM_digest_bytes(p); - const int param_salt_bytes = PARAM_salt_bytes(p); - - int ret = mayo_expand_pk(p, cpk, pk); - if (ret != MAYO_OK) { - return MAYO_ERR; - } - - uint64_t *P1 = pk; - uint64_t *P2 = P1 + PARAM_P1_limbs(p); - uint64_t *P3 = P2 + PARAM_P2_limbs(p); + size_t mlen, const unsigned char *sig, + const unsigned char *cpk) { + unsigned char tEnc[M_BYTES_MAX]; + unsigned char t[M_MAX]; + unsigned char y[2 * M_MAX] = {0}; // extra space for reduction mod f(X) + unsigned char s[K_MAX * N_MAX]; + uint64_t pk[P1_LIMBS_MAX + P2_LIMBS_MAX + P3_LIMBS_MAX] = {0}; + unsigned char tmp[DIGEST_BYTES_MAX + SALT_BYTES_MAX]; + + const int param_m = PARAM_m(p); + const int param_n = PARAM_n(p); + const int param_k = PARAM_k(p); + const int param_m_bytes = PARAM_m_bytes(p); + const int param_sig_bytes = PARAM_sig_bytes(p); + const int param_digest_bytes = PARAM_digest_bytes(p); + const int param_salt_bytes = PARAM_salt_bytes(p); + + int ret = mayo_expand_pk(p, cpk, pk); + if (ret != MAYO_OK) { + return MAYO_ERR; + } + + uint64_t *P1 = pk; + uint64_t *P2 = P1 + PARAM_P1_limbs(p); + uint64_t *P3 = P2 + PARAM_P2_limbs(p); #ifdef TARGET_BIG_ENDIAN - for (int i = 0; i < PARAM_P1_limbs(p); ++i) { - P1[i] = BSWAP64(P1[i]); - } - for (int i = 0; i < PARAM_P2_limbs(p); ++i) { - P2[i] = BSWAP64(P2[i]); - } - for (int i = 0; i < PARAM_P3_limbs(p); ++i) { - P3[i] = BSWAP64(P3[i]); - } + for (int i = 0; i < PARAM_P1_limbs(p); ++i) { + P1[i] = BSWAP64(P1[i]); + } + for (int i = 0; i < PARAM_P2_limbs(p); ++i) { + P2[i] = BSWAP64(P2[i]); + } + for (int i = 0; i < PARAM_P3_limbs(p); ++i) { + P3[i] = BSWAP64(P3[i]); + } #endif - // hash m - shake256(tmp, param_digest_bytes, m, mlen); + // hash m + shake256(tmp, param_digest_bytes, m, mlen); - // compute t - memcpy(tmp + param_digest_bytes, sig + param_sig_bytes - param_salt_bytes, - param_salt_bytes); - shake256(tEnc, param_m_bytes, tmp, param_digest_bytes + param_salt_bytes); - decode(tEnc, t, param_m); + // compute t + memcpy(tmp + param_digest_bytes, sig + param_sig_bytes - param_salt_bytes, + param_salt_bytes); + shake256(tEnc, param_m_bytes, tmp, param_digest_bytes + param_salt_bytes); + decode(tEnc, t, param_m); - // decode s - decode(sig, s, param_k * param_n); + // decode s + decode(sig, s, param_k * param_n); - eval_public_map(p, s, P1, P2, P3, y); + eval_public_map(p, s, P1, P2, P3, y); - if (memcmp(y, t, param_m) == 0) { - return MAYO_OK; // good signature - } - return MAYO_ERR; // bad signature + if (memcmp(y, t, param_m) == 0) { + return MAYO_OK; // good signature + } + return MAYO_ERR; // bad signature } diff --git a/lib/mayo/mayo.h b/lib/mayo/mayo.h index 8d0f13ca8..7a7e5afda 100644 --- a/lib/mayo/mayo.h +++ b/lib/mayo/mayo.h @@ -263,38 +263,38 @@ static const unsigned char f_tail[] = PARAM_NAME(f_tail); * Struct defining MAYO parameters */ typedef struct { - int m; - int n; - int o; - int k; - int q; - const unsigned char *f_tail; - int m_bytes; - int O_bytes; - int v_bytes; - int r_bytes; - int R_bytes; - int P1_bytes; - int P2_bytes; - int P3_bytes; - int csk_bytes; - int cpk_bytes; - int sig_bytes; - int salt_bytes; - int sk_seed_bytes; - int digest_bytes; - int pk_seed_bytes; - int m_vec_limbs; - const char *name; + int m; + int n; + int o; + int k; + int q; + const unsigned char *f_tail; + int m_bytes; + int O_bytes; + int v_bytes; + int r_bytes; + int R_bytes; + int P1_bytes; + int P2_bytes; + int P3_bytes; + int csk_bytes; + int cpk_bytes; + int sig_bytes; + int salt_bytes; + int sk_seed_bytes; + int digest_bytes; + int pk_seed_bytes; + int m_vec_limbs; + const char *name; } mayo_params_t; typedef struct sk_t { - uint64_t p[P1_LIMBS_MAX + P2_LIMBS_MAX]; - uint8_t O[V_MAX*O_MAX]; + uint64_t p[P1_LIMBS_MAX + P2_LIMBS_MAX]; + uint8_t O[V_MAX*O_MAX]; } sk_t; typedef struct pk_t { - uint64_t p[P1_LIMBS_MAX + P2_LIMBS_MAX + P3_LIMBS_MAX]; + uint64_t p[P1_LIMBS_MAX + P2_LIMBS_MAX + P3_LIMBS_MAX]; } pk_t; /** @@ -329,8 +329,8 @@ int mayo_keypair(const mayo_params_t *p, unsigned char *pk, unsigned char *sk); #define mayo_sign_signature MAYO_NAMESPACE(mayo_sign_signature) int mayo_sign_signature(const mayo_params_t *p, unsigned char *sig, - size_t *siglen, const unsigned char *m, - size_t mlen, const unsigned char *csk); + size_t *siglen, const unsigned char *m, + size_t mlen, const unsigned char *csk); /** * MAYO signature generation. @@ -349,8 +349,8 @@ int mayo_sign_signature(const mayo_params_t *p, unsigned char *sig, */ #define mayo_sign MAYO_NAMESPACE(mayo_sign) int mayo_sign(const mayo_params_t *p, unsigned char *sm, - size_t *smlen, const unsigned char *m, - size_t mlen, const unsigned char *sk); + size_t *smlen, const unsigned char *m, + size_t mlen, const unsigned char *sk); /** * Mayo open signature. @@ -369,8 +369,8 @@ int mayo_sign(const mayo_params_t *p, unsigned char *sm, */ #define mayo_open MAYO_NAMESPACE(mayo_open) int mayo_open(const mayo_params_t *p, unsigned char *m, - size_t *mlen, const unsigned char *sm, - size_t smlen, const unsigned char *pk); + size_t *mlen, const unsigned char *sm, + size_t smlen, const unsigned char *pk); /** * Mayo compact keypair generation. @@ -388,7 +388,7 @@ int mayo_open(const mayo_params_t *p, unsigned char *m, */ #define mayo_keypair_compact MAYO_NAMESPACE(mayo_keypair_compact) int mayo_keypair_compact(const mayo_params_t *p, unsigned char *cpk, - unsigned char *csk); + unsigned char *csk); //// ADDED FOR ZENROOM INTEGRATION @@ -405,7 +405,7 @@ int mayo_keypair_compact(const mayo_params_t *p, unsigned char *cpk, */ #define mayo_derive_cpk MAYO_NAMESPACE(mayo_derive_cpk) int mayo_derive_cpk(const mayo_params_t *p, unsigned char *cpk, - const unsigned char *csk); + const unsigned char *csk); //// @@ -422,7 +422,7 @@ int mayo_derive_cpk(const mayo_params_t *p, unsigned char *cpk, */ #define mayo_expand_pk MAYO_NAMESPACE(mayo_expand_pk) int mayo_expand_pk(const mayo_params_t *p, const unsigned char *cpk, - uint64_t *epk); + uint64_t *epk); /** * Mayo expand secret key. @@ -437,7 +437,7 @@ int mayo_expand_pk(const mayo_params_t *p, const unsigned char *cpk, */ #define mayo_expand_sk MAYO_NAMESPACE(mayo_expand_sk) int mayo_expand_sk(const mayo_params_t *p, const unsigned char *csk, - sk_t *esk); + sk_t *esk); /** * Mayo verify signature. @@ -454,8 +454,8 @@ int mayo_expand_sk(const mayo_params_t *p, const unsigned char *csk, */ #define mayo_verify MAYO_NAMESPACE(mayo_verify) int mayo_verify(const mayo_params_t *p, const unsigned char *m, - size_t mlen, const unsigned char *sig, - const unsigned char *pk); + size_t mlen, const unsigned char *sig, + const unsigned char *pk); #endif diff --git a/lib/mayo/mem.c b/lib/mayo/mem.c index bce37fa3b..7c81475cd 100644 --- a/lib/mayo/mem.c +++ b/lib/mayo/mem.c @@ -5,15 +5,15 @@ #include void mayo_secure_free(void *mem, size_t size) { - if (mem) { - typedef void *(*memset_t)(void *, int, size_t); - static volatile memset_t memset_func = memset; - memset_func(mem, 0, size); - free(mem); - } + if (mem) { + typedef void *(*memset_t)(void *, int, size_t); + static volatile memset_t memset_func = memset; + memset_func(mem, 0, size); + free(mem); + } } void mayo_secure_clear(void *mem, size_t size) { - typedef void *(*memset_t)(void *, int, size_t); - static volatile memset_t memset_func = memset; - memset_func(mem, 0, size); + typedef void *(*memset_t)(void *, int, size_t); + static volatile memset_t memset_func = memset; + memset_func(mem, 0, size); } diff --git a/lib/mayo/params.c b/lib/mayo/params.c index 392d6d946..a4d8bba7b 100644 --- a/lib/mayo/params.c +++ b/lib/mayo/params.c @@ -10,28 +10,28 @@ static const unsigned char f_tail_142[] = F_TAIL_142; #define MAYO_GEN_PARAMS(nm) \ const mayo_params_t nm = { \ - .m = PARAM_JOIN2(nm, m), \ - .n = PARAM_JOIN2(nm, n), \ - .o = PARAM_JOIN2(nm, o), \ - .k = PARAM_JOIN2(nm, k), \ - .q = PARAM_JOIN2(nm, q), \ - .f_tail = PARAM_JOIN2(nm, f_tail_arr), \ - .m_bytes = PARAM_JOIN2(nm, m_bytes), \ - .O_bytes = PARAM_JOIN2(nm, O_bytes), \ - .v_bytes = PARAM_JOIN2(nm, v_bytes), \ - .r_bytes = PARAM_JOIN2(nm, r_bytes), \ - .P1_bytes = PARAM_JOIN2(nm, P1_bytes), \ - .P2_bytes = PARAM_JOIN2(nm, P2_bytes), \ - .P3_bytes = PARAM_JOIN2(nm, P3_bytes), \ - .csk_bytes = PARAM_JOIN2(nm, csk_bytes), \ - .cpk_bytes = PARAM_JOIN2(nm, cpk_bytes), \ - .sig_bytes = PARAM_JOIN2(nm, sig_bytes), \ - .salt_bytes = PARAM_JOIN2(nm, salt_bytes), \ - .sk_seed_bytes = PARAM_JOIN2(nm, sk_seed_bytes), \ - .digest_bytes = PARAM_JOIN2(nm, digest_bytes), \ - .pk_seed_bytes = PARAM_JOIN2(nm, pk_seed_bytes), \ - .m_vec_limbs = PARAM_JOIN2(nm, m_vec_limbs), \ - .name = #nm \ + .m = PARAM_JOIN2(nm, m), \ + .n = PARAM_JOIN2(nm, n), \ + .o = PARAM_JOIN2(nm, o), \ + .k = PARAM_JOIN2(nm, k), \ + .q = PARAM_JOIN2(nm, q), \ + .f_tail = PARAM_JOIN2(nm, f_tail_arr), \ + .m_bytes = PARAM_JOIN2(nm, m_bytes), \ + .O_bytes = PARAM_JOIN2(nm, O_bytes), \ + .v_bytes = PARAM_JOIN2(nm, v_bytes), \ + .r_bytes = PARAM_JOIN2(nm, r_bytes), \ + .P1_bytes = PARAM_JOIN2(nm, P1_bytes), \ + .P2_bytes = PARAM_JOIN2(nm, P2_bytes), \ + .P3_bytes = PARAM_JOIN2(nm, P3_bytes), \ + .csk_bytes = PARAM_JOIN2(nm, csk_bytes), \ + .cpk_bytes = PARAM_JOIN2(nm, cpk_bytes), \ + .sig_bytes = PARAM_JOIN2(nm, sig_bytes), \ + .salt_bytes = PARAM_JOIN2(nm, salt_bytes), \ + .sk_seed_bytes = PARAM_JOIN2(nm, sk_seed_bytes), \ + .digest_bytes = PARAM_JOIN2(nm, digest_bytes), \ + .pk_seed_bytes = PARAM_JOIN2(nm, pk_seed_bytes), \ + .m_vec_limbs = PARAM_JOIN2(nm, m_vec_limbs), \ + .name = #nm \ }; MAYO_GEN_PARAMS(MAYO_1); diff --git a/lib/mayo/simple_arithmetic.h b/lib/mayo/simple_arithmetic.h index cca0e9ba5..b94d55c72 100644 --- a/lib/mayo/simple_arithmetic.h +++ b/lib/mayo/simple_arithmetic.h @@ -6,132 +6,132 @@ // GF(16) multiplication mod x^4 + x + 1 static inline unsigned char mul_f(unsigned char a, unsigned char b) { - // carryless multiply - unsigned char p; + // carryless multiply + unsigned char p; #if !(((defined(__clang__) && __clang_major__ < 15) || (!defined(__clang__) && defined(__GNUC__) && __GNUC__ <= 12)) && (defined(__x86_64__) || defined(_M_X64))) - a ^= unsigned_char_blocker; + a ^= unsigned_char_blocker; #endif - p = (a & 1)*b; - p ^= (a & 2)*b; - p ^= (a & 4)*b; - p ^= (a & 8)*b; + p = (a & 1)*b; + p ^= (a & 2)*b; + p ^= (a & 4)*b; + p ^= (a & 8)*b; - // reduce mod x^4 + x + 1 - unsigned char top_p = p & 0xf0; - unsigned char out = (p ^ (top_p >> 4) ^ (top_p >> 3)) & 0x0f; - return out; + // reduce mod x^4 + x + 1 + unsigned char top_p = p & 0xf0; + unsigned char out = (p ^ (top_p >> 4) ^ (top_p >> 3)) & 0x0f; + return out; } static inline uint64_t mul_fx8(unsigned char a, uint64_t b) { - // carryless multiply - uint64_t p; - p = (a & 1)*b; - p ^= (a & 2)*b; - p ^= (a & 4)*b; - p ^= (a & 8)*b; - - // reduce mod x^4 + x + 1 - uint64_t top_p = p & 0xf0f0f0f0f0f0f0f0; - uint64_t out = (p ^ (top_p >> 4) ^ (top_p >> 3)) & 0x0f0f0f0f0f0f0f0f; - return out; + // carryless multiply + uint64_t p; + p = (a & 1)*b; + p ^= (a & 2)*b; + p ^= (a & 4)*b; + p ^= (a & 8)*b; + + // reduce mod x^4 + x + 1 + uint64_t top_p = p & 0xf0f0f0f0f0f0f0f0; + uint64_t out = (p ^ (top_p >> 4) ^ (top_p >> 3)) & 0x0f0f0f0f0f0f0f0f; + return out; } // GF(16) addition static inline unsigned char add_f(unsigned char a, unsigned char b) { - return a ^ b; + return a ^ b; } // GF(16) subtraction static inline unsigned char sub_f(unsigned char a, unsigned char b) { - return a ^ b; + return a ^ b; } // GF(16) negation static inline unsigned char neg_f(unsigned char a) { - return a; + return a; } static inline unsigned char inverse_f(unsigned char a) { - // static unsigned char table[16] = {0, 1, 9, 14, 13, 11, 7, 6, 15, 2, 12, 5, - // 10, 4, 3, 8}; return table[a & 15]; + // static unsigned char table[16] = {0, 1, 9, 14, 13, 11, 7, 6, 15, 2, 12, 5, + // 10, 4, 3, 8}; return table[a & 15]; - unsigned char a2 = mul_f(a, a); - unsigned char a4 = mul_f(a2, a2); - unsigned char a8 = mul_f(a4, a4); - unsigned char a6 = mul_f(a2, a4); - unsigned char a14 = mul_f(a8, a6); + unsigned char a2 = mul_f(a, a); + unsigned char a4 = mul_f(a2, a2); + unsigned char a8 = mul_f(a4, a4); + unsigned char a6 = mul_f(a2, a4); + unsigned char a14 = mul_f(a8, a6); - return a14; + return a14; } static inline unsigned char lincomb(const unsigned char *a, - const unsigned char *b, int n, int m) { - unsigned char ret = 0; - for (int i = 0; i < n; ++i, b += m) { - ret = add_f(mul_f(a[i], *b), ret); - } - return ret; + const unsigned char *b, int n, int m) { + unsigned char ret = 0; + for (int i = 0; i < n; ++i, b += m) { + ret = add_f(mul_f(a[i], *b), ret); + } + return ret; } static inline void mat_mul(const unsigned char *a, const unsigned char *b, - unsigned char *c, int colrow_ab, int row_a, int col_b) { - for (int i = 0; i < row_a; ++i, a += colrow_ab) { - for (int j = 0; j < col_b; ++j, ++c) { - *c = lincomb(a, b + j, colrow_ab, col_b); - } - } + unsigned char *c, int colrow_ab, int row_a, int col_b) { + for (int i = 0; i < row_a; ++i, a += colrow_ab) { + for (int j = 0; j < col_b; ++j, ++c) { + *c = lincomb(a, b + j, colrow_ab, col_b); + } + } } static inline void mat_add(const unsigned char *a, const unsigned char *b, - unsigned char *c, int m, int n) { - for (int i = 0; i < m; ++i) { - for (int j = 0; j < n; ++j) { - *(c + i * n + j) = add_f(*(a + i * n + j), *(b + i * n + j)); - } - } + unsigned char *c, int m, int n) { + for (int i = 0; i < m; ++i) { + for (int j = 0; j < n; ++j) { + *(c + i * n + j) = add_f(*(a + i * n + j), *(b + i * n + j)); + } + } } static inline uint64_t gf16v_mul_u64( uint64_t a, uint8_t b ) { - uint64_t mask_msb = 0x8888888888888888ULL; - uint64_t a_msb; - uint64_t a64 = a; + uint64_t mask_msb = 0x8888888888888888ULL; + uint64_t a_msb; + uint64_t a64 = a; #if !(((defined(__clang__) && __clang_major__ < 15) || (!defined(__clang__) && defined(__GNUC__) && __GNUC__ <= 12)) && (defined(__x86_64__) || defined(_M_X64))) - uint64_t b32 = b ^ unsigned_char_blocker; + uint64_t b32 = b ^ unsigned_char_blocker; #else - uint64_t b32 = b; + uint64_t b32 = b; #endif - uint64_t r64 = a64 * (b32 & 1); + uint64_t r64 = a64 * (b32 & 1); - a_msb = a64 & mask_msb; // MSB, 3rd bits - a64 ^= a_msb; // clear MSB - a64 = (a64 << 1) ^ ((a_msb >> 3) * 3); - r64 ^= (a64) * ((b32 >> 1) & 1); + a_msb = a64 & mask_msb; // MSB, 3rd bits + a64 ^= a_msb; // clear MSB + a64 = (a64 << 1) ^ ((a_msb >> 3) * 3); + r64 ^= (a64) * ((b32 >> 1) & 1); - a_msb = a64 & mask_msb; // MSB, 3rd bits - a64 ^= a_msb; // clear MSB - a64 = (a64 << 1) ^ ((a_msb >> 3) * 3); - r64 ^= (a64) * ((b32 >> 2) & 1); + a_msb = a64 & mask_msb; // MSB, 3rd bits + a64 ^= a_msb; // clear MSB + a64 = (a64 << 1) ^ ((a_msb >> 3) * 3); + r64 ^= (a64) * ((b32 >> 2) & 1); - a_msb = a64 & mask_msb; // MSB, 3rd bits - a64 ^= a_msb; // clear MSB - a64 = (a64 << 1) ^ ((a_msb >> 3) * 3); - r64 ^= (a64) * ((b32 >> 3) & 1); + a_msb = a64 & mask_msb; // MSB, 3rd bits + a64 ^= a_msb; // clear MSB + a64 = (a64 << 1) ^ ((a_msb >> 3) * 3); + r64 ^= (a64) * ((b32 >> 3) & 1); - return r64; + return r64; } // This implements arithmetic for nibble-packed vectors of m field elements in Z_2[x]/(x^4+x+1) // gf16 := gf2[x]/(x^4+x+1) static inline uint32_t mul_table(uint8_t b){ - uint32_t x = ((uint32_t) b) * 0x08040201; + uint32_t x = ((uint32_t) b) * 0x08040201; - uint32_t high_nibble_mask = 0xf0f0f0f0; + uint32_t high_nibble_mask = 0xf0f0f0f0; - uint32_t high_half = x & high_nibble_mask; - return (x ^ (high_half >> 4) ^ (high_half >> 3)); + uint32_t high_half = x & high_nibble_mask; + return (x ^ (high_half >> 4) ^ (high_half >> 3)); } #endif diff --git a/src/lua/zencode_mayo.lua b/src/lua/zencode_mayo.lua index 3f8844417..d1e2ae938 100644 --- a/src/lua/zencode_mayo.lua +++ b/src/lua/zencode_mayo.lua @@ -1,6 +1,6 @@ local mayo = require 'mayo' -local function mayo_public_key_f(obj) +local function mayo_public_key_f(obj) local res = schema_get(obj, '.') zencode_assert( mayo.pubcheck(res), @@ -49,11 +49,11 @@ local function _pubkey_from_secret(sec) end When("create mayo key with secret key ''", - _pubkey_from_secret + _pubkey_from_secret ) When("create mayo key with secret ''", - _pubkey_from_secret + _pubkey_from_secret ) When("create mayo public key with secret key ''",function(sec) @@ -77,7 +77,7 @@ IfWhen("verify '' has a mayo signature in '' by ''",function(msg, sig, by) local m = have(msg) local s = have(sig) zencode_assert( - mayo.verify(pk, s, zencode_serialize(m)), - 'The mayo signature by '..by..' is not authentic' + mayo.verify(pk, s, zencode_serialize(m)), + 'The mayo signature by '..by..' is not authentic' ) -end) \ No newline at end of file +end) diff --git a/src/zen_mayo.c b/src/zen_mayo.c index 15ee7f625..bfdb6efae 100644 --- a/src/zen_mayo.c +++ b/src/zen_mayo.c @@ -11,28 +11,28 @@ #include "mayo.h" static int zen_mayo_secgen(lua_State *L) { - BEGIN(); - Z(L); - register const size_t sksize = CRYPTO_SECRETKEYBYTES; - octet *sk = o_new(L, sksize); SAFE(sk, "Could not create secret key"); - register size_t i; - for(i=0; i < sksize; i++) - sk->val[i] = RAND_byte(Z->random_generator); - sk->len = sksize; - END(1); + BEGIN(); + Z(L); + register const size_t sksize = CRYPTO_SECRETKEYBYTES; + octet *sk = o_new(L, sksize); SAFE(sk, "Could not create secret key"); + register size_t i; + for(i=0; i < sksize; i++) + sk->val[i] = RAND_byte(Z->random_generator); + sk->len = sksize; + END(1); } static int zen_mayo_pubgen(lua_State *L) { - BEGIN(); - char *failed_msg = NULL; - octet *pk = NULL, *sk = NULL; - sk = o_arg(L, 1); SAFE_GOTO(sk, "Could not allocate secret key"); - SAFE_GOTO(sk->len == CRYPTO_SECRETKEYBYTES, "Invalid size for MAYO_5 secret key"); - pk = o_new(L, CRYPTO_PUBLICKEYBYTES); SAFE_GOTO(pk, "Could not create public key"); + BEGIN(); + char *failed_msg = NULL; + octet *pk = NULL, *sk = NULL; + sk = o_arg(L, 1); SAFE_GOTO(sk, "Could not allocate secret key"); + SAFE_GOTO(sk->len == CRYPTO_SECRETKEYBYTES, "Invalid size for MAYO_5 secret key"); + pk = o_new(L, CRYPTO_PUBLICKEYBYTES); SAFE_GOTO(pk, "Could not create public key"); pk->len = CRYPTO_PUBLICKEYBYTES; - // params = NULL if compiling with ENABLE_PARAMS_DYNAMIC off (static) - mayo_derive_cpk(NULL, (unsigned char*)pk->val, (const unsigned char*)sk->val); + // params = NULL if compiling with ENABLE_PARAMS_DYNAMIC off (static) + mayo_derive_cpk(NULL, (unsigned char*)pk->val, (const unsigned char*)sk->val); end: o_free(L, sk); if(failed_msg) { @@ -46,7 +46,7 @@ static int zen_mayo_pubgen(lua_State *L) { // BEGIN(); // char *failed_msg = NULL; // lua_createtable(L, 0, 2); - + // int sk_len = CRYPTO_SECRETKEYBYTES; // int pk_len = CRYPTO_PUBLICKEYBYTES; @@ -67,127 +67,127 @@ static int zen_mayo_pubgen(lua_State *L) { // } static int zen_mayo_sign(lua_State *L) { - BEGIN(); - char *failed_msg = NULL; - const octet *sk = NULL, *m = NULL; - sk = o_arg(L, 1); SAFE_GOTO(sk, "Could not allocate secret key"); - SAFE_GOTO(sk->len == CRYPTO_SECRETKEYBYTES, "Invalid size for MAYO_5 secret key"); - m = o_arg(L, 2); SAFE_GOTO(m, "Could not allocate message"); - octet *sig = o_new(L, CRYPTO_BYTES); SAFE_GOTO(sig, "Could not create signature"); - SAFE_GOTO( - !crypto_sign_signature( - (unsigned char*)sig->val, - (size_t*)&sig->len, - (unsigned char*)m->val, m->len, - (unsigned char*)sk->val - ) || sig->len <= 0, - "Could not sign the message" - ); + BEGIN(); + char *failed_msg = NULL; + const octet *sk = NULL, *m = NULL; + sk = o_arg(L, 1); SAFE_GOTO(sk, "Could not allocate secret key"); + SAFE_GOTO(sk->len == CRYPTO_SECRETKEYBYTES, "Invalid size for MAYO_5 secret key"); + m = o_arg(L, 2); SAFE_GOTO(m, "Could not allocate message"); + octet *sig = o_new(L, CRYPTO_BYTES); SAFE_GOTO(sig, "Could not create signature"); + SAFE_GOTO( + !crypto_sign_signature( + (unsigned char*)sig->val, + (size_t*)&sig->len, + (unsigned char*)m->val, m->len, + (unsigned char*)sk->val + ) || sig->len <= 0, + "Could not sign the message" + ); end: - o_free(L, m); - o_free(L, sk); - if(failed_msg) { - THROW(failed_msg); - } - END(1); + o_free(L, m); + o_free(L, sk); + if(failed_msg) { + THROW(failed_msg); + } + END(1); } static int zen_mayo_signature_pubcheck(lua_State *L) { - BEGIN(); - const octet *pk = o_arg(L, 1); SAFE(pk, "Could not allocate public key"); - if(pk->len == CRYPTO_PUBLICKEYBYTES) - lua_pushboolean(L, 1); - else - lua_pushboolean(L, 0); - o_free(L, pk); - END(1); + BEGIN(); + const octet *pk = o_arg(L, 1); SAFE(pk, "Could not allocate public key"); + if(pk->len == CRYPTO_PUBLICKEYBYTES) + lua_pushboolean(L, 1); + else + lua_pushboolean(L, 0); + o_free(L, pk); + END(1); } static int zen_mayo_signed_message(lua_State *L) { - BEGIN(); - char *failed_msg = NULL; - const octet *sk = NULL, *m = NULL; - sk = o_arg(L, 1); SAFE_GOTO(sk, "Could not allocate secret key"); - SAFE_GOTO(sk->len == CRYPTO_SECRETKEYBYTES, "Invalid size for MAYO_5 secret key"); - m = o_arg(L, 2); SAFE_GOTO(m, "Could not allocate message"); - octet *sig = o_new(L, CRYPTO_BYTES + m->len); SAFE_GOTO(sig, "Could not create signature"); - SAFE_GOTO( - !crypto_sign( - (unsigned char*)sig->val, - (size_t*)&sig->len, - (unsigned char*)m->val, m->len, - (unsigned char*)sk->val - ) || sig->len <= 0, - "Could not sign the message" - ); + BEGIN(); + char *failed_msg = NULL; + const octet *sk = NULL, *m = NULL; + sk = o_arg(L, 1); SAFE_GOTO(sk, "Could not allocate secret key"); + SAFE_GOTO(sk->len == CRYPTO_SECRETKEYBYTES, "Invalid size for MAYO_5 secret key"); + m = o_arg(L, 2); SAFE_GOTO(m, "Could not allocate message"); + octet *sig = o_new(L, CRYPTO_BYTES + m->len); SAFE_GOTO(sig, "Could not create signature"); + SAFE_GOTO( + !crypto_sign( + (unsigned char*)sig->val, + (size_t*)&sig->len, + (unsigned char*)m->val, m->len, + (unsigned char*)sk->val + ) || sig->len <= 0, + "Could not sign the message" + ); end: - o_free(L, m); - o_free(L, sk); - if(failed_msg) { + o_free(L, m); + o_free(L, sk); + if(failed_msg) { THROW(failed_msg); } END(1); } static int zen_mayo_verified_message(lua_State *L) { - BEGIN(); - char *failed_msg = NULL; - const octet *pk = NULL, *sm = NULL; - pk = o_arg(L, 1); SAFE_GOTO(pk, "Could not allocate public key"); - SAFE_GOTO(pk->len == CRYPTO_PUBLICKEYBYTES, "Invalid size for MAYO_5 public key"); - sm = o_arg(L, 2); SAFE_GOTO(sm, "Could not allocate signed message"); - octet *msg = o_new(L, sm->len); SAFE_GOTO(msg, "Could not create message"); - int result = crypto_sign_open( - (unsigned char*)msg->val, - (size_t*)&msg->len, - (unsigned char*)sm->val, sm->len, - (unsigned char*)pk->val) == 0 - && msg->len > 0; - if(!result) { - lua_pushboolean(L, 0); - } + BEGIN(); + char *failed_msg = NULL; + const octet *pk = NULL, *sm = NULL; + pk = o_arg(L, 1); SAFE_GOTO(pk, "Could not allocate public key"); + SAFE_GOTO(pk->len == CRYPTO_PUBLICKEYBYTES, "Invalid size for MAYO_5 public key"); + sm = o_arg(L, 2); SAFE_GOTO(sm, "Could not allocate signed message"); + octet *msg = o_new(L, sm->len); SAFE_GOTO(msg, "Could not create message"); + int result = crypto_sign_open( + (unsigned char*)msg->val, + (size_t*)&msg->len, + (unsigned char*)sm->val, sm->len, + (unsigned char*)pk->val) == 0 + && msg->len > 0; + if(!result) { + lua_pushboolean(L, 0); + } end: - o_free(L, sm); - o_free(L, pk); - if(failed_msg) { - THROW(failed_msg); - } - END(1); + o_free(L, sm); + o_free(L, pk); + if(failed_msg) { + THROW(failed_msg); + } + END(1); } static int zen_mayo_verify(lua_State *L) { - BEGIN(); - char *failed_msg = NULL; - const octet *pk = NULL, *sig = NULL, *m = NULL; - pk = o_arg(L, 1); SAFE_GOTO(pk, "Could not allocate public key"); - SAFE_GOTO(pk->len == CRYPTO_PUBLICKEYBYTES, "Invalid size for MAYO_5 public key"); - sig = o_arg(L, 2); SAFE_GOTO(sig, "Could not allocate signature"); - m = o_arg(L, 3); SAFE_GOTO(m, "Could not allocate message"); - int result = crypto_sign_verify( - (unsigned char*)sig->val, - (size_t)sig->len, - (unsigned char*)m->val, m->len, - (unsigned char*)pk->val - ); - lua_pushboolean(L, result == 0); + BEGIN(); + char *failed_msg = NULL; + const octet *pk = NULL, *sig = NULL, *m = NULL; + pk = o_arg(L, 1); SAFE_GOTO(pk, "Could not allocate public key"); + SAFE_GOTO(pk->len == CRYPTO_PUBLICKEYBYTES, "Invalid size for MAYO_5 public key"); + sig = o_arg(L, 2); SAFE_GOTO(sig, "Could not allocate signature"); + m = o_arg(L, 3); SAFE_GOTO(m, "Could not allocate message"); + int result = crypto_sign_verify( + (unsigned char*)sig->val, + (size_t)sig->len, + (unsigned char*)m->val, m->len, + (unsigned char*)pk->val + ); + lua_pushboolean(L, result == 0); end: - o_free(L, m); - o_free(L, sig); - o_free(L, pk); - if(failed_msg) { - THROW(failed_msg); - } - END(1); + o_free(L, m); + o_free(L, sig); + o_free(L, pk); + if(failed_msg) { + THROW(failed_msg); + } + END(1); } static int zen_mayo_signature_len(lua_State *L){ - BEGIN(); - lua_pushinteger(L, CRYPTO_BYTES); - END(1); + BEGIN(); + lua_pushinteger(L, CRYPTO_BYTES); + END(1); } static int zen_mayo_signature_check(lua_State *L) { - BEGIN(); + BEGIN(); char *failed_msg = NULL; const octet *sign = o_arg(L, 1); SAFE_GOTO(sign, "Could not allocate signature"); if(sign->len == CRYPTO_BYTES) @@ -203,25 +203,25 @@ static int zen_mayo_signature_check(lua_State *L) { } int luaopen_mayo(lua_State *L) { - const struct luaL_Reg mayo_class[] = { - {"keygen", zen_mayo_secgen}, - {"secgen", zen_mayo_secgen}, - {"pubgen", zen_mayo_pubgen}, - {"pubcheck", zen_mayo_signature_pubcheck}, - {"checkpub", zen_mayo_signature_pubcheck}, - {"sign", zen_mayo_sign}, - {"verify", zen_mayo_verify}, - {"signed_msg", zen_mayo_signed_message}, - {"verified_msg", zen_mayo_verified_message}, - {"signature_len", zen_mayo_signature_len}, - {"signature_check", zen_mayo_signature_check}, - {NULL, NULL} - }; - - const struct luaL_Reg mayo_methods[] = { - {NULL, NULL} - }; - - zen_add_class(L, "mayo", mayo_class, mayo_methods); - return 1; -} \ No newline at end of file + const struct luaL_Reg mayo_class[] = { + {"keygen", zen_mayo_secgen}, + {"secgen", zen_mayo_secgen}, + {"pubgen", zen_mayo_pubgen}, + {"pubcheck", zen_mayo_signature_pubcheck}, + {"checkpub", zen_mayo_signature_pubcheck}, + {"sign", zen_mayo_sign}, + {"verify", zen_mayo_verify}, + {"signed_msg", zen_mayo_signed_message}, + {"verified_msg", zen_mayo_verified_message}, + {"signature_len", zen_mayo_signature_len}, + {"signature_check", zen_mayo_signature_check}, + {NULL, NULL} + }; + + const struct luaL_Reg mayo_methods[] = { + {NULL, NULL} + }; + + zen_add_class(L, "mayo", mayo_class, mayo_methods); + return 1; +} diff --git a/test/vectors/check_mayo.lua b/test/vectors/check_mayo.lua index 24622b5fc..fdd0b52c2 100644 --- a/test/vectors/check_mayo.lua +++ b/test/vectors/check_mayo.lua @@ -4,11 +4,11 @@ -- public domain (and thanks for all the NIST) local function newline_iter(text) - s = trim(text) -- implemented in zen_io.c - if s:sub(-1) ~= '\n' then - s = s .. '\n' - end - return s:gmatch('(.-)\n') -- iterators return functions + s = trim(text) -- implemented in zen_io.c + if s:sub(-1) ~= '\n' then + s = s .. '\n' + end + return s:gmatch('(.-)\n') -- iterators return functions end local mayo = require'mayo' @@ -19,25 +19,25 @@ for line in newline_iter(DATA) do local rule = strtok(line) if #rule > 0 and rule[1] ~= "" and rule[1]:lower() ~= "count" and rule[1]:lower() ~= "mlen" and rule[1]:lower() ~= "smlen" then - curr_fields = curr_fields+1 - - test[rule[1]:lower()] = O.from_hex(rule[3]) + curr_fields = curr_fields+1 + + test[rule[1]:lower()] = O.from_hex(rule[3]) end if curr_fields == 5 then - -- Here starts the test - assert(mayo.pubcheck(test.pk)) - assert(mayo.signature_check(test.sm:sub(1, mayo.signature_len()))) - assert(mayo.verify(test.pk, test.sm:sub(1, mayo.signature_len()), test.msg)) - assert(test.msg == mayo.verified_msg(test.pk, test.sm)) - - -- These test are different from the dilithium ones because of the way the signature is generated (deterministically in dilithium, non-deterministically in mayo) - -- Here we only check verify works - local new_sig = mayo.sign(test.sk, test.msg) - assert(mayo.verify(test.pk, new_sig, test.msg)) + -- Here starts the test + assert(mayo.pubcheck(test.pk)) + assert(mayo.signature_check(test.sm:sub(1, mayo.signature_len()))) + assert(mayo.verify(test.pk, test.sm:sub(1, mayo.signature_len()), test.msg)) + assert(test.msg == mayo.verified_msg(test.pk, test.sm)) + + -- These test are different from the dilithium ones because of the way the signature is generated (deterministically in dilithium, non-deterministically in mayo) + -- Here we only check verify works + local new_sig = mayo.sign(test.sk, test.msg) + assert(mayo.verify(test.pk, new_sig, test.msg)) - curr_fields = 0 - test = { } + curr_fields = 0 + test = { } end end -end \ No newline at end of file +end From 6f1fbf4ead7560b59962b3e5b431ccd7612c1a15 Mon Sep 17 00:00:00 2001 From: ms8421ms Date: Wed, 18 Mar 2026 19:46:39 +0100 Subject: [PATCH 15/19] fix: correctly importing zenroom randombytes in mayo --- lib/mayo/mayo.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/lib/mayo/mayo.c b/lib/mayo/mayo.c index 2699e8bca..712b40260 100644 --- a/lib/mayo/mayo.c +++ b/lib/mayo/mayo.c @@ -2,7 +2,6 @@ #include #include -#include #include #include #include @@ -14,6 +13,9 @@ #include #endif +// Imported from zenroom +extern int randombytes(void *buf, size_t n); + #define MAYO_MIN(x, y) (((x) < (y)) ? (x) : (y)) #define PK_PRF AES_128_CTR From 6d7ed421131a8f5ea88b31cc0ca765492e4de7bc Mon Sep 17 00:00:00 2001 From: ms8421ms Date: Thu, 19 Mar 2026 12:48:32 +0100 Subject: [PATCH 16/19] fix: resolved fips202 conflict --- lib/mayo/Makefile | 2 +- lib/mayo/fips202.c | 1093 -------------------------------------------- lib/mayo/fips202.h | 12 - lib/mayo/mayo.c | 3 +- src/zenroom.h | 2 +- 5 files changed, 4 insertions(+), 1108 deletions(-) delete mode 100644 lib/mayo/fips202.c delete mode 100644 lib/mayo/fips202.h diff --git a/lib/mayo/Makefile b/lib/mayo/Makefile index fa099f955..2fd6674da 100644 --- a/lib/mayo/Makefile +++ b/lib/mayo/Makefile @@ -1,7 +1,7 @@ CFLAGS ?= -O2 -I../../src -I. -fPIC -fstack-protector-all -D_FORTIFY_SOURCE=2 -fno-strict-overflow -DMAYO_BUILD_TYPE_REF=1 -DMAYO_VARIANT=MAYO_5 CC ?= gcc -MAYO=aes_c.o aes128ctr.o fips202.o mem.o api.o mayo.o params.o arithmetic.o +MAYO=aes_c.o aes128ctr.o mem.o api.o mayo.o params.o arithmetic.o all: libmayo.a diff --git a/lib/mayo/fips202.c b/lib/mayo/fips202.c deleted file mode 100644 index 5ad883a21..000000000 --- a/lib/mayo/fips202.c +++ /dev/null @@ -1,1093 +0,0 @@ -// SPDX-License-Identifier: Public Domain and Apache-2.0 - -/* AES implementation based on code from PQClean, - * which is in turn based based on the public domain implementation in - * crypto_hash/keccakc512/simple/ from http://bench.cr.yp.to/supercop.html - * by Ronny Van Keer - * and the public domain "TweetFips202" implementation - * from https://twitter.com/tweetfips202 - * by Gilles Van Assche, Daniel J. Bernstein, and Peter Schwabe */ - -#include -#include -#include -#include - -#include -#include - -#define SHAKE128_RATE 168 -#define SHAKE256_RATE 136 -#define SHA3_256_RATE 136 -#define SHA3_384_RATE 104 -#define SHA3_512_RATE 72 - -#define PQC_SHAKEINCCTX_BYTES (sizeof(uint64_t)*26) -#define PQC_SHAKECTX_BYTES (sizeof(uint64_t)*25) - -// Context for incremental API -typedef struct { - uint64_t *ctx; -} shake128incctx; - -// Context for non-incremental API -typedef struct { - uint64_t *ctx; -} shake128ctx; - -// Context for incremental API -typedef struct { - uint64_t *ctx; -} shake256incctx; - -// Context for non-incremental API -typedef struct { - uint64_t *ctx; -} shake256ctx; - -// Context for incremental API -typedef struct { - uint64_t *ctx; -} sha3_256incctx; - -// Context for incremental API -typedef struct { - uint64_t *ctx; -} sha3_384incctx; - -// Context for incremental API -typedef struct { - uint64_t *ctx; -} sha3_512incctx; - -/* Initialize the state and absorb the provided input. - * - * This function does not support being called multiple times - * with the same state. - */ -void shake128_absorb(shake128ctx *state, const uint8_t *input, size_t inlen); -/* Squeeze output out of the sponge. - * - * Supports being called multiple times - */ -void shake128_squeezeblocks(uint8_t *output, size_t nblocks, shake128ctx *state); -/* Free the state */ -void shake128_ctx_release(shake128ctx *state); -/* Copy the state. */ -void shake128_ctx_clone(shake128ctx *dest, const shake128ctx *src); - -/* Initialize incremental hashing API */ -void shake128_inc_init(shake128incctx *state); -/* Absorb more information into the XOF. - * - * Can be called multiple times. - */ -void shake128_inc_absorb(shake128incctx *state, const uint8_t *input, size_t inlen); -/* Finalize the XOF for squeezing */ -void shake128_inc_finalize(shake128incctx *state); -/* Squeeze output out of the sponge. - * - * Supports being called multiple times - */ -void shake128_inc_squeeze(uint8_t *output, size_t outlen, shake128incctx *state); -/* Copy the context of the SHAKE128 XOF */ -void shake128_inc_ctx_clone(shake128incctx *dest, const shake128incctx *src); -/* Free the context of the SHAKE128 XOF */ -void shake128_inc_ctx_release(shake128incctx *state); - -/* Initialize the state and absorb the provided input. - * - * This function does not support being called multiple times - * with the same state. - */ -void shake256_absorb(shake256ctx *state, const uint8_t *input, size_t inlen); -/* Squeeze output out of the sponge. - * - * Supports being called multiple times - */ -void shake256_squeezeblocks(uint8_t *output, size_t nblocks, shake256ctx *state); -/* Free the context held by this XOF */ -void shake256_ctx_release(shake256ctx *state); -/* Copy the context held by this XOF */ -void shake256_ctx_clone(shake256ctx *dest, const shake256ctx *src); - -/* Initialize incremental hashing API */ -void shake256_inc_init(shake256incctx *state); -void shake256_inc_absorb(shake256incctx *state, const uint8_t *input, size_t inlen); -/* Prepares for squeeze phase */ -void shake256_inc_finalize(shake256incctx *state); -/* Squeeze output out of the sponge. - * - * Supports being called multiple times - */ -void shake256_inc_squeeze(uint8_t *output, size_t outlen, shake256incctx *state); -/* Copy the state */ -void shake256_inc_ctx_clone(shake256incctx *dest, const shake256incctx *src); -/* Free the state */ -void shake256_inc_ctx_release(shake256incctx *state); - -/* One-stop SHAKE128 call */ -void shake128(uint8_t *output, size_t outlen, - const uint8_t *input, size_t inlen); - -/* One-stop SHAKE256 call */ -void shake256(uint8_t *output, size_t outlen, - const uint8_t *input, size_t inlen); - -/* Initialize the incremental hashing state */ -void sha3_256_inc_init(sha3_256incctx *state); -/* Absorb blocks into SHA3 */ -void sha3_256_inc_absorb(sha3_256incctx *state, const uint8_t *input, size_t inlen); -/* Obtain the output of the function and free `state` */ -void sha3_256_inc_finalize(uint8_t *output, sha3_256incctx *state); -/* Copy the context */ -void sha3_256_inc_ctx_clone(sha3_256incctx *dest, const sha3_256incctx *src); -/* Release the state, don't use if `_finalize` has been used */ -void sha3_256_inc_ctx_release(sha3_256incctx *state); - -void sha3_256(uint8_t *output, const uint8_t *input, size_t inlen); - -/* Initialize the incremental hashing state */ -void sha3_384_inc_init(sha3_384incctx *state); -/* Absorb blocks into SHA3 */ -void sha3_384_inc_absorb(sha3_384incctx *state, const uint8_t *input, size_t inlen); -/* Obtain the output of the function and free `state` */ -void sha3_384_inc_finalize(uint8_t *output, sha3_384incctx *state); -/* Copy the context */ -void sha3_384_inc_ctx_clone(sha3_384incctx *dest, const sha3_384incctx *src); -/* Release the state, don't use if `_finalize` has been used */ -void sha3_384_inc_ctx_release(sha3_384incctx *state); - -/* One-stop SHA3-384 shop */ -void sha3_384(uint8_t *output, const uint8_t *input, size_t inlen); - -/* Initialize the incremental hashing state */ -void sha3_512_inc_init(sha3_512incctx *state); -/* Absorb blocks into SHA3 */ -void sha3_512_inc_absorb(sha3_512incctx *state, const uint8_t *input, size_t inlen); -/* Obtain the output of the function and free `state` */ -void sha3_512_inc_finalize(uint8_t *output, sha3_512incctx *state); -/* Copy the context */ -void sha3_512_inc_ctx_clone(sha3_512incctx *dest, const sha3_512incctx *src); -/* Release the state, don't use if `_finalize` has been used */ -void sha3_512_inc_ctx_release(sha3_512incctx *state); - -/* One-stop SHA3-512 shop */ -void sha3_512(uint8_t *output, const uint8_t *input, size_t inlen); - -#define NROUNDS 24 -#define ROL(a, offset) (((a) << (offset)) ^ ((a) >> (64 - (offset)))) - -/************************************************* - * Name: load64 - * - * Description: Load 8 bytes into uint64_t in little-endian order - * - * Arguments: - const uint8_t *x: pointer to input byte array - * - * Returns the loaded 64-bit unsigned integer - **************************************************/ -static uint64_t load64(const uint8_t *x) { - uint64_t r = 0; - for (size_t i = 0; i < 8; ++i) { - r |= (uint64_t)x[i] << 8 * i; - } - - return r; -} - -/************************************************* - * Name: store64 - * - * Description: Store a 64-bit integer to a byte array in little-endian order - * - * Arguments: - uint8_t *x: pointer to the output byte array - * - uint64_t u: input 64-bit unsigned integer - **************************************************/ -static void store64(uint8_t *x, uint64_t u) { - for (size_t i = 0; i < 8; ++i) { - x[i] = (uint8_t) (u >> 8 * i); - } -} - -/* Keccak round constants */ -static const uint64_t KeccakF_RoundConstants[NROUNDS] = { - 0x0000000000000001ULL, 0x0000000000008082ULL, - 0x800000000000808aULL, 0x8000000080008000ULL, - 0x000000000000808bULL, 0x0000000080000001ULL, - 0x8000000080008081ULL, 0x8000000000008009ULL, - 0x000000000000008aULL, 0x0000000000000088ULL, - 0x0000000080008009ULL, 0x000000008000000aULL, - 0x000000008000808bULL, 0x800000000000008bULL, - 0x8000000000008089ULL, 0x8000000000008003ULL, - 0x8000000000008002ULL, 0x8000000000000080ULL, - 0x000000000000800aULL, 0x800000008000000aULL, - 0x8000000080008081ULL, 0x8000000000008080ULL, - 0x0000000080000001ULL, 0x8000000080008008ULL -}; - -/************************************************* - * Name: KeccakF1600_StatePermute - * - * Description: The Keccak F1600 Permutation - * - * Arguments: - uint64_t *state: pointer to input/output Keccak state - **************************************************/ -static void KeccakF1600_StatePermute(uint64_t *state) { - int round; - - uint64_t Aba, Abe, Abi, Abo, Abu; - uint64_t Aga, Age, Agi, Ago, Agu; - uint64_t Aka, Ake, Aki, Ako, Aku; - uint64_t Ama, Ame, Ami, Amo, Amu; - uint64_t Asa, Ase, Asi, Aso, Asu; - uint64_t BCa, BCe, BCi, BCo, BCu; - uint64_t Da, De, Di, Do, Du; - uint64_t Eba, Ebe, Ebi, Ebo, Ebu; - uint64_t Ega, Ege, Egi, Ego, Egu; - uint64_t Eka, Eke, Eki, Eko, Eku; - uint64_t Ema, Eme, Emi, Emo, Emu; - uint64_t Esa, Ese, Esi, Eso, Esu; - - // copyFromState(A, state) - Aba = state[0]; - Abe = state[1]; - Abi = state[2]; - Abo = state[3]; - Abu = state[4]; - Aga = state[5]; - Age = state[6]; - Agi = state[7]; - Ago = state[8]; - Agu = state[9]; - Aka = state[10]; - Ake = state[11]; - Aki = state[12]; - Ako = state[13]; - Aku = state[14]; - Ama = state[15]; - Ame = state[16]; - Ami = state[17]; - Amo = state[18]; - Amu = state[19]; - Asa = state[20]; - Ase = state[21]; - Asi = state[22]; - Aso = state[23]; - Asu = state[24]; - - for (round = 0; round < NROUNDS; round += 2) { - // prepareTheta - BCa = Aba ^ Aga ^ Aka ^ Ama ^ Asa; - BCe = Abe ^ Age ^ Ake ^ Ame ^ Ase; - BCi = Abi ^ Agi ^ Aki ^ Ami ^ Asi; - BCo = Abo ^ Ago ^ Ako ^ Amo ^ Aso; - BCu = Abu ^ Agu ^ Aku ^ Amu ^ Asu; - - // thetaRhoPiChiIotaPrepareTheta(round , A, E) - Da = BCu ^ ROL(BCe, 1); - De = BCa ^ ROL(BCi, 1); - Di = BCe ^ ROL(BCo, 1); - Do = BCi ^ ROL(BCu, 1); - Du = BCo ^ ROL(BCa, 1); - - Aba ^= Da; - BCa = Aba; - Age ^= De; - BCe = ROL(Age, 44); - Aki ^= Di; - BCi = ROL(Aki, 43); - Amo ^= Do; - BCo = ROL(Amo, 21); - Asu ^= Du; - BCu = ROL(Asu, 14); - Eba = BCa ^ ((~BCe) & BCi); - Eba ^= KeccakF_RoundConstants[round]; - Ebe = BCe ^ ((~BCi) & BCo); - Ebi = BCi ^ ((~BCo) & BCu); - Ebo = BCo ^ ((~BCu) & BCa); - Ebu = BCu ^ ((~BCa) & BCe); - - Abo ^= Do; - BCa = ROL(Abo, 28); - Agu ^= Du; - BCe = ROL(Agu, 20); - Aka ^= Da; - BCi = ROL(Aka, 3); - Ame ^= De; - BCo = ROL(Ame, 45); - Asi ^= Di; - BCu = ROL(Asi, 61); - Ega = BCa ^ ((~BCe) & BCi); - Ege = BCe ^ ((~BCi) & BCo); - Egi = BCi ^ ((~BCo) & BCu); - Ego = BCo ^ ((~BCu) & BCa); - Egu = BCu ^ ((~BCa) & BCe); - - Abe ^= De; - BCa = ROL(Abe, 1); - Agi ^= Di; - BCe = ROL(Agi, 6); - Ako ^= Do; - BCi = ROL(Ako, 25); - Amu ^= Du; - BCo = ROL(Amu, 8); - Asa ^= Da; - BCu = ROL(Asa, 18); - Eka = BCa ^ ((~BCe) & BCi); - Eke = BCe ^ ((~BCi) & BCo); - Eki = BCi ^ ((~BCo) & BCu); - Eko = BCo ^ ((~BCu) & BCa); - Eku = BCu ^ ((~BCa) & BCe); - - Abu ^= Du; - BCa = ROL(Abu, 27); - Aga ^= Da; - BCe = ROL(Aga, 36); - Ake ^= De; - BCi = ROL(Ake, 10); - Ami ^= Di; - BCo = ROL(Ami, 15); - Aso ^= Do; - BCu = ROL(Aso, 56); - Ema = BCa ^ ((~BCe) & BCi); - Eme = BCe ^ ((~BCi) & BCo); - Emi = BCi ^ ((~BCo) & BCu); - Emo = BCo ^ ((~BCu) & BCa); - Emu = BCu ^ ((~BCa) & BCe); - - Abi ^= Di; - BCa = ROL(Abi, 62); - Ago ^= Do; - BCe = ROL(Ago, 55); - Aku ^= Du; - BCi = ROL(Aku, 39); - Ama ^= Da; - BCo = ROL(Ama, 41); - Ase ^= De; - BCu = ROL(Ase, 2); - Esa = BCa ^ ((~BCe) & BCi); - Ese = BCe ^ ((~BCi) & BCo); - Esi = BCi ^ ((~BCo) & BCu); - Eso = BCo ^ ((~BCu) & BCa); - Esu = BCu ^ ((~BCa) & BCe); - - // prepareTheta - BCa = Eba ^ Ega ^ Eka ^ Ema ^ Esa; - BCe = Ebe ^ Ege ^ Eke ^ Eme ^ Ese; - BCi = Ebi ^ Egi ^ Eki ^ Emi ^ Esi; - BCo = Ebo ^ Ego ^ Eko ^ Emo ^ Eso; - BCu = Ebu ^ Egu ^ Eku ^ Emu ^ Esu; - - // thetaRhoPiChiIotaPrepareTheta(round+1, E, A) - Da = BCu ^ ROL(BCe, 1); - De = BCa ^ ROL(BCi, 1); - Di = BCe ^ ROL(BCo, 1); - Do = BCi ^ ROL(BCu, 1); - Du = BCo ^ ROL(BCa, 1); - - Eba ^= Da; - BCa = Eba; - Ege ^= De; - BCe = ROL(Ege, 44); - Eki ^= Di; - BCi = ROL(Eki, 43); - Emo ^= Do; - BCo = ROL(Emo, 21); - Esu ^= Du; - BCu = ROL(Esu, 14); - Aba = BCa ^ ((~BCe) & BCi); - Aba ^= KeccakF_RoundConstants[round + 1]; - Abe = BCe ^ ((~BCi) & BCo); - Abi = BCi ^ ((~BCo) & BCu); - Abo = BCo ^ ((~BCu) & BCa); - Abu = BCu ^ ((~BCa) & BCe); - - Ebo ^= Do; - BCa = ROL(Ebo, 28); - Egu ^= Du; - BCe = ROL(Egu, 20); - Eka ^= Da; - BCi = ROL(Eka, 3); - Eme ^= De; - BCo = ROL(Eme, 45); - Esi ^= Di; - BCu = ROL(Esi, 61); - Aga = BCa ^ ((~BCe) & BCi); - Age = BCe ^ ((~BCi) & BCo); - Agi = BCi ^ ((~BCo) & BCu); - Ago = BCo ^ ((~BCu) & BCa); - Agu = BCu ^ ((~BCa) & BCe); - - Ebe ^= De; - BCa = ROL(Ebe, 1); - Egi ^= Di; - BCe = ROL(Egi, 6); - Eko ^= Do; - BCi = ROL(Eko, 25); - Emu ^= Du; - BCo = ROL(Emu, 8); - Esa ^= Da; - BCu = ROL(Esa, 18); - Aka = BCa ^ ((~BCe) & BCi); - Ake = BCe ^ ((~BCi) & BCo); - Aki = BCi ^ ((~BCo) & BCu); - Ako = BCo ^ ((~BCu) & BCa); - Aku = BCu ^ ((~BCa) & BCe); - - Ebu ^= Du; - BCa = ROL(Ebu, 27); - Ega ^= Da; - BCe = ROL(Ega, 36); - Eke ^= De; - BCi = ROL(Eke, 10); - Emi ^= Di; - BCo = ROL(Emi, 15); - Eso ^= Do; - BCu = ROL(Eso, 56); - Ama = BCa ^ ((~BCe) & BCi); - Ame = BCe ^ ((~BCi) & BCo); - Ami = BCi ^ ((~BCo) & BCu); - Amo = BCo ^ ((~BCu) & BCa); - Amu = BCu ^ ((~BCa) & BCe); - - Ebi ^= Di; - BCa = ROL(Ebi, 62); - Ego ^= Do; - BCe = ROL(Ego, 55); - Eku ^= Du; - BCi = ROL(Eku, 39); - Ema ^= Da; - BCo = ROL(Ema, 41); - Ese ^= De; - BCu = ROL(Ese, 2); - Asa = BCa ^ ((~BCe) & BCi); - Ase = BCe ^ ((~BCi) & BCo); - Asi = BCi ^ ((~BCo) & BCu); - Aso = BCo ^ ((~BCu) & BCa); - Asu = BCu ^ ((~BCa) & BCe); - } - - // copyToState(state, A) - state[0] = Aba; - state[1] = Abe; - state[2] = Abi; - state[3] = Abo; - state[4] = Abu; - state[5] = Aga; - state[6] = Age; - state[7] = Agi; - state[8] = Ago; - state[9] = Agu; - state[10] = Aka; - state[11] = Ake; - state[12] = Aki; - state[13] = Ako; - state[14] = Aku; - state[15] = Ama; - state[16] = Ame; - state[17] = Ami; - state[18] = Amo; - state[19] = Amu; - state[20] = Asa; - state[21] = Ase; - state[22] = Asi; - state[23] = Aso; - state[24] = Asu; -} - -/************************************************* - * Name: keccak_absorb - * - * Description: Absorb step of Keccak; - * non-incremental, starts by zeroeing the state. - * - * Arguments: - uint64_t *s: pointer to (uninitialized) output Keccak state - * - uint32_t r: rate in bytes (e.g., 168 for SHAKE128) - * - const uint8_t *m: pointer to input to be absorbed into s - * - size_t mlen: length of input in bytes - * - uint8_t p: domain-separation byte for different - * Keccak-derived functions - **************************************************/ -static void keccak_absorb(uint64_t *s, uint32_t r, const uint8_t *m, - size_t mlen, uint8_t p) { - size_t i; - uint8_t t[200]; - - /* Zero state */ - for (i = 0; i < 25; ++i) { - s[i] = 0; - } - - while (mlen >= r) { - for (i = 0; i < r / 8; ++i) { - s[i] ^= load64(m + 8 * i); - } - - KeccakF1600_StatePermute(s); - mlen -= r; - m += r; - } - - for (i = 0; i < r; ++i) { - t[i] = 0; - } - for (i = 0; i < mlen; ++i) { - t[i] = m[i]; - } - t[i] = p; - t[r - 1] |= 128; - for (i = 0; i < r / 8; ++i) { - s[i] ^= load64(t + 8 * i); - } -} - -/************************************************* - * Name: keccak_squeezeblocks - * - * Description: Squeeze step of Keccak. Squeezes full blocks of r bytes each. - * Modifies the state. Can be called multiple times to keep - * squeezing, i.e., is incremental. - * - * Arguments: - uint8_t *h: pointer to output blocks - * - size_t nblocks: number of blocks to be - * squeezed (written to h) - * - uint64_t *s: pointer to input/output Keccak state - * - uint32_t r: rate in bytes (e.g., 168 for SHAKE128) - **************************************************/ -static void keccak_squeezeblocks(uint8_t *h, size_t nblocks, - uint64_t *s, uint32_t r) { - while (nblocks > 0) { - KeccakF1600_StatePermute(s); - for (size_t i = 0; i < (r >> 3); i++) { - store64(h + 8 * i, s[i]); - } - h += r; - nblocks--; - } -} - -/************************************************* - * Name: keccak_inc_init - * - * Description: Initializes the incremental Keccak state to zero. - * - * Arguments: - uint64_t *s_inc: pointer to input/output incremental state - * First 25 values represent Keccak state. - * 26th value represents either the number of absorbed bytes - * that have not been permuted, or not-yet-squeezed bytes. - **************************************************/ -static void keccak_inc_init(uint64_t *s_inc) { - size_t i; - - for (i = 0; i < 25; ++i) { - s_inc[i] = 0; - } - s_inc[25] = 0; -} - -/************************************************* - * Name: keccak_inc_absorb - * - * Description: Incremental keccak absorb - * Preceded by keccak_inc_init, succeeded by keccak_inc_finalize - * - * Arguments: - uint64_t *s_inc: pointer to input/output incremental state - * First 25 values represent Keccak state. - * 26th value represents either the number of absorbed bytes - * that have not been permuted, or not-yet-squeezed bytes. - * - uint32_t r: rate in bytes (e.g., 168 for SHAKE128) - * - const uint8_t *m: pointer to input to be absorbed into s - * - size_t mlen: length of input in bytes - **************************************************/ -static void keccak_inc_absorb(uint64_t *s_inc, uint32_t r, const uint8_t *m, - size_t mlen) { - size_t i; - - /* Recall that s_inc[25] is the non-absorbed bytes xored into the state */ - while (mlen + s_inc[25] >= r) { - for (i = 0; i < r - (uint32_t)s_inc[25]; i++) { - /* Take the i'th byte from message - xor with the s_inc[25] + i'th byte of the state; little-endian */ - s_inc[(s_inc[25] + i) >> 3] ^= (uint64_t)m[i] << (8 * ((s_inc[25] + i) & 0x07)); - } - mlen -= (size_t)(r - s_inc[25]); - m += r - s_inc[25]; - s_inc[25] = 0; - - KeccakF1600_StatePermute(s_inc); - } - - for (i = 0; i < mlen; i++) { - s_inc[(s_inc[25] + i) >> 3] ^= (uint64_t)m[i] << (8 * ((s_inc[25] + i) & 0x07)); - } - s_inc[25] += mlen; -} - -/************************************************* - * Name: keccak_inc_finalize - * - * Description: Finalizes Keccak absorb phase, prepares for squeezing - * - * Arguments: - uint64_t *s_inc: pointer to input/output incremental state - * First 25 values represent Keccak state. - * 26th value represents either the number of absorbed bytes - * that have not been permuted, or not-yet-squeezed bytes. - * - uint32_t r: rate in bytes (e.g., 168 for SHAKE128) - * - uint8_t p: domain-separation byte for different - * Keccak-derived functions - **************************************************/ -static void keccak_inc_finalize(uint64_t *s_inc, uint32_t r, uint8_t p) { - /* After keccak_inc_absorb, we are guaranteed that s_inc[25] < r, - so we can always use one more byte for p in the current state. */ - s_inc[s_inc[25] >> 3] ^= (uint64_t)p << (8 * (s_inc[25] & 0x07)); - s_inc[(r - 1) >> 3] ^= (uint64_t)128 << (8 * ((r - 1) & 0x07)); - s_inc[25] = 0; -} - -/************************************************* - * Name: keccak_inc_squeeze - * - * Description: Incremental Keccak squeeze; can be called on byte-level - * - * Arguments: - uint8_t *h: pointer to output bytes - * - size_t outlen: number of bytes to be squeezed - * - uint64_t *s_inc: pointer to input/output incremental state - * First 25 values represent Keccak state. - * 26th value represents either the number of absorbed bytes - * that have not been permuted, or not-yet-squeezed bytes. - * - uint32_t r: rate in bytes (e.g., 168 for SHAKE128) - **************************************************/ -static void keccak_inc_squeeze(uint8_t *h, size_t outlen, - uint64_t *s_inc, uint32_t r) { - size_t i; - - /* First consume any bytes we still have sitting around */ - for (i = 0; i < outlen && i < s_inc[25]; i++) { - /* There are s_inc[25] bytes left, so r - s_inc[25] is the first - available byte. We consume from there, i.e., up to r. */ - h[i] = (uint8_t)(s_inc[(r - s_inc[25] + i) >> 3] >> (8 * ((r - s_inc[25] + i) & 0x07))); - } - h += i; - outlen -= i; - s_inc[25] -= i; - - /* Then squeeze the remaining necessary blocks */ - while (outlen > 0) { - KeccakF1600_StatePermute(s_inc); - - for (i = 0; i < outlen && i < r; i++) { - h[i] = (uint8_t)(s_inc[i >> 3] >> (8 * (i & 0x07))); - } - h += i; - outlen -= i; - s_inc[25] = r - i; - } -} - -void shake128_inc_init(shake128incctx *state) { - state->ctx = malloc(PQC_SHAKEINCCTX_BYTES); - if (state->ctx == NULL) { - exit(111); - } - keccak_inc_init(state->ctx); -} - -void shake128_inc_absorb(shake128incctx *state, const uint8_t *input, size_t inlen) { - keccak_inc_absorb(state->ctx, SHAKE128_RATE, input, inlen); -} - -void shake128_inc_finalize(shake128incctx *state) { - keccak_inc_finalize(state->ctx, SHAKE128_RATE, 0x1F); -} - -void shake128_inc_squeeze(uint8_t *output, size_t outlen, shake128incctx *state) { - keccak_inc_squeeze(output, outlen, state->ctx, SHAKE128_RATE); -} - -void shake128_inc_ctx_clone(shake128incctx *dest, const shake128incctx *src) { - dest->ctx = malloc(PQC_SHAKEINCCTX_BYTES); - if (dest->ctx == NULL) { - exit(111); - } - memcpy(dest->ctx, src->ctx, PQC_SHAKEINCCTX_BYTES); -} - -void shake128_inc_ctx_release(shake128incctx *state) { - free(state->ctx); -} - -void shake256_inc_init(shake256incctx *state) { - state->ctx = malloc(PQC_SHAKEINCCTX_BYTES); - if (state->ctx == NULL) { - exit(111); - } - keccak_inc_init(state->ctx); -} - -void shake256_inc_absorb(shake256incctx *state, const uint8_t *input, size_t inlen) { - keccak_inc_absorb(state->ctx, SHAKE256_RATE, input, inlen); -} - -void shake256_inc_finalize(shake256incctx *state) { - keccak_inc_finalize(state->ctx, SHAKE256_RATE, 0x1F); -} - -void shake256_inc_squeeze(uint8_t *output, size_t outlen, shake256incctx *state) { - keccak_inc_squeeze(output, outlen, state->ctx, SHAKE256_RATE); -} - -void shake256_inc_ctx_clone(shake256incctx *dest, const shake256incctx *src) { - dest->ctx = malloc(PQC_SHAKEINCCTX_BYTES); - if (dest->ctx == NULL) { - exit(111); - } - memcpy(dest->ctx, src->ctx, PQC_SHAKEINCCTX_BYTES); -} - -void shake256_inc_ctx_release(shake256incctx *state) { - free(state->ctx); -} - - -/************************************************* - * Name: shake128_absorb - * - * Description: Absorb step of the SHAKE128 XOF. - * non-incremental, starts by zeroeing the state. - * - * Arguments: - uint64_t *s: pointer to (uninitialized) output Keccak state - * - const uint8_t *input: pointer to input to be absorbed - * into s - * - size_t inlen: length of input in bytes - **************************************************/ -void shake128_absorb(shake128ctx *state, const uint8_t *input, size_t inlen) { - state->ctx = malloc(PQC_SHAKECTX_BYTES); - if (state->ctx == NULL) { - exit(111); - } - keccak_absorb(state->ctx, SHAKE128_RATE, input, inlen, 0x1F); -} - -/************************************************* - * Name: shake128_squeezeblocks - * - * Description: Squeeze step of SHAKE128 XOF. Squeezes full blocks of - * SHAKE128_RATE bytes each. Modifies the state. Can be called - * multiple times to keep squeezing, i.e., is incremental. - * - * Arguments: - uint8_t *output: pointer to output blocks - * - size_t nblocks: number of blocks to be squeezed - * (written to output) - * - shake128ctx *state: pointer to input/output Keccak state - **************************************************/ -void shake128_squeezeblocks(uint8_t *output, size_t nblocks, shake128ctx *state) { - keccak_squeezeblocks(output, nblocks, state->ctx, SHAKE128_RATE); -} - -void shake128_ctx_clone(shake128ctx *dest, const shake128ctx *src) { - dest->ctx = malloc(PQC_SHAKECTX_BYTES); - if (dest->ctx == NULL) { - exit(111); - } - memcpy(dest->ctx, src->ctx, PQC_SHAKECTX_BYTES); -} - -/** Release the allocated state. Call only once. */ -void shake128_ctx_release(shake128ctx *state) { - free(state->ctx); -} - -/************************************************* - * Name: shake256_absorb - * - * Description: Absorb step of the SHAKE256 XOF. - * non-incremental, starts by zeroeing the state. - * - * Arguments: - shake256ctx *state: pointer to (uninitialized) output Keccak state - * - const uint8_t *input: pointer to input to be absorbed - * into s - * - size_t inlen: length of input in bytes - **************************************************/ -void shake256_absorb(shake256ctx *state, const uint8_t *input, size_t inlen) { - state->ctx = malloc(PQC_SHAKECTX_BYTES); - if (state->ctx == NULL) { - exit(111); - } - keccak_absorb(state->ctx, SHAKE256_RATE, input, inlen, 0x1F); -} - -/************************************************* - * Name: shake256_squeezeblocks - * - * Description: Squeeze step of SHAKE256 XOF. Squeezes full blocks of - * SHAKE256_RATE bytes each. Modifies the state. Can be called - * multiple times to keep squeezing, i.e., is incremental. - * - * Arguments: - uint8_t *output: pointer to output blocks - * - size_t nblocks: number of blocks to be squeezed - * (written to output) - * - shake256ctx *state: pointer to input/output Keccak state - **************************************************/ -void shake256_squeezeblocks(uint8_t *output, size_t nblocks, shake256ctx *state) { - keccak_squeezeblocks(output, nblocks, state->ctx, SHAKE256_RATE); -} - -void shake256_ctx_clone(shake256ctx *dest, const shake256ctx *src) { - dest->ctx = malloc(PQC_SHAKECTX_BYTES); - if (dest->ctx == NULL) { - exit(111); - } - memcpy(dest->ctx, src->ctx, PQC_SHAKECTX_BYTES); -} - -/** Release the allocated state. Call only once. */ -void shake256_ctx_release(shake256ctx *state) { - free(state->ctx); -} - -/************************************************* - * Name: shake128 - * - * Description: SHAKE128 XOF with non-incremental API - * - * Arguments: - uint8_t *output: pointer to output - * - size_t outlen: requested output length in bytes - * - const uint8_t *input: pointer to input - * - size_t inlen: length of input in bytes - **************************************************/ -void shake128(uint8_t *output, size_t outlen, - const uint8_t *input, size_t inlen) { - size_t nblocks = outlen / SHAKE128_RATE; - uint8_t t[SHAKE128_RATE]; - shake128ctx s; - - shake128_absorb(&s, input, inlen); - shake128_squeezeblocks(output, nblocks, &s); - - output += nblocks * SHAKE128_RATE; - outlen -= nblocks * SHAKE128_RATE; - - if (outlen) { - shake128_squeezeblocks(t, 1, &s); - for (size_t i = 0; i < outlen; ++i) { - output[i] = t[i]; - } - } - shake128_ctx_release(&s); -} - -/************************************************* - * Name: shake256 - * - * Description: SHAKE256 XOF with non-incremental API - * - * Arguments: - uint8_t *output: pointer to output - * - size_t outlen: requested output length in bytes - * - const uint8_t *input: pointer to input - * - size_t inlen: length of input in bytes - **************************************************/ -void shake256(uint8_t *output, size_t outlen, - const uint8_t *input, size_t inlen) { - size_t nblocks = outlen / SHAKE256_RATE; - uint8_t t[SHAKE256_RATE]; - shake256ctx s; - - shake256_absorb(&s, input, inlen); - shake256_squeezeblocks(output, nblocks, &s); - - output += nblocks * SHAKE256_RATE; - outlen -= nblocks * SHAKE256_RATE; - - if (outlen) { - shake256_squeezeblocks(t, 1, &s); - for (size_t i = 0; i < outlen; ++i) { - output[i] = t[i]; - } - } - shake256_ctx_release(&s); -} - -void sha3_256_inc_init(sha3_256incctx *state) { - state->ctx = malloc(PQC_SHAKEINCCTX_BYTES); - if (state->ctx == NULL) { - exit(111); - } - keccak_inc_init(state->ctx); -} - -void sha3_256_inc_ctx_clone(sha3_256incctx *dest, const sha3_256incctx *src) { - dest->ctx = malloc(PQC_SHAKEINCCTX_BYTES); - if (dest->ctx == NULL) { - exit(111); - } - memcpy(dest->ctx, src->ctx, PQC_SHAKEINCCTX_BYTES); -} - -void sha3_256_inc_ctx_release(sha3_256incctx *state) { - free(state->ctx); -} - -void sha3_256_inc_absorb(sha3_256incctx *state, const uint8_t *input, size_t inlen) { - keccak_inc_absorb(state->ctx, SHA3_256_RATE, input, inlen); -} - -void sha3_256_inc_finalize(uint8_t *output, sha3_256incctx *state) { - uint8_t t[SHA3_256_RATE]; - keccak_inc_finalize(state->ctx, SHA3_256_RATE, 0x06); - - keccak_squeezeblocks(t, 1, state->ctx, SHA3_256_RATE); - - sha3_256_inc_ctx_release(state); - - for (size_t i = 0; i < 32; i++) { - output[i] = t[i]; - } -} - -/************************************************* - * Name: sha3_256 - * - * Description: SHA3-256 with non-incremental API - * - * Arguments: - uint8_t *output: pointer to output - * - const uint8_t *input: pointer to input - * - size_t inlen: length of input in bytes - **************************************************/ -void sha3_256(uint8_t *output, const uint8_t *input, size_t inlen) { - uint64_t s[25]; - uint8_t t[SHA3_256_RATE]; - - /* Absorb input */ - keccak_absorb(s, SHA3_256_RATE, input, inlen, 0x06); - - /* Squeeze output */ - keccak_squeezeblocks(t, 1, s, SHA3_256_RATE); - - for (size_t i = 0; i < 32; i++) { - output[i] = t[i]; - } -} - -void sha3_384_inc_init(sha3_384incctx *state) { - state->ctx = malloc(PQC_SHAKEINCCTX_BYTES); - if (state->ctx == NULL) { - exit(111); - } - keccak_inc_init(state->ctx); -} - -void sha3_384_inc_ctx_clone(sha3_384incctx *dest, const sha3_384incctx *src) { - dest->ctx = malloc(PQC_SHAKEINCCTX_BYTES); - if (dest->ctx == NULL) { - exit(111); - } - memcpy(dest->ctx, src->ctx, PQC_SHAKEINCCTX_BYTES); -} - -void sha3_384_inc_absorb(sha3_384incctx *state, const uint8_t *input, size_t inlen) { - keccak_inc_absorb(state->ctx, SHA3_384_RATE, input, inlen); -} - -void sha3_384_inc_ctx_release(sha3_384incctx *state) { - free(state->ctx); -} - -void sha3_384_inc_finalize(uint8_t *output, sha3_384incctx *state) { - uint8_t t[SHA3_384_RATE]; - keccak_inc_finalize(state->ctx, SHA3_384_RATE, 0x06); - - keccak_squeezeblocks(t, 1, state->ctx, SHA3_384_RATE); - - sha3_384_inc_ctx_release(state); - - for (size_t i = 0; i < 48; i++) { - output[i] = t[i]; - } -} - -/************************************************* - * Name: sha3_384 - * - * Description: SHA3-256 with non-incremental API - * - * Arguments: - uint8_t *output: pointer to output - * - const uint8_t *input: pointer to input - * - size_t inlen: length of input in bytes - **************************************************/ -void sha3_384(uint8_t *output, const uint8_t *input, size_t inlen) { - uint64_t s[25]; - uint8_t t[SHA3_384_RATE]; - - /* Absorb input */ - keccak_absorb(s, SHA3_384_RATE, input, inlen, 0x06); - - /* Squeeze output */ - keccak_squeezeblocks(t, 1, s, SHA3_384_RATE); - - for (size_t i = 0; i < 48; i++) { - output[i] = t[i]; - } -} - -void sha3_512_inc_init(sha3_512incctx *state) { - state->ctx = malloc(PQC_SHAKEINCCTX_BYTES); - if (state->ctx == NULL) { - exit(111); - } - keccak_inc_init(state->ctx); -} - -void sha3_512_inc_ctx_clone(sha3_512incctx *dest, const sha3_512incctx *src) { - dest->ctx = malloc(PQC_SHAKEINCCTX_BYTES); - if (dest->ctx == NULL) { - exit(111); - } - memcpy(dest->ctx, src->ctx, PQC_SHAKEINCCTX_BYTES); -} - -void sha3_512_inc_absorb(sha3_512incctx *state, const uint8_t *input, size_t inlen) { - keccak_inc_absorb(state->ctx, SHA3_512_RATE, input, inlen); -} - -void sha3_512_inc_ctx_release(sha3_512incctx *state) { - free(state->ctx); -} - -void sha3_512_inc_finalize(uint8_t *output, sha3_512incctx *state) { - uint8_t t[SHA3_512_RATE]; - keccak_inc_finalize(state->ctx, SHA3_512_RATE, 0x06); - - keccak_squeezeblocks(t, 1, state->ctx, SHA3_512_RATE); - - sha3_512_inc_ctx_release(state); - - for (size_t i = 0; i < 64; i++) { - output[i] = t[i]; - } -} - -/************************************************* - * Name: sha3_512 - * - * Description: SHA3-512 with non-incremental API - * - * Arguments: - uint8_t *output: pointer to output - * - const uint8_t *input: pointer to input - * - size_t inlen: length of input in bytes - **************************************************/ -void sha3_512(uint8_t *output, const uint8_t *input, size_t inlen) { - uint64_t s[25]; - uint8_t t[SHA3_512_RATE]; - - /* Absorb input */ - keccak_absorb(s, SHA3_512_RATE, input, inlen, 0x06); - - /* Squeeze output */ - keccak_squeezeblocks(t, 1, s, SHA3_512_RATE); - - for (size_t i = 0; i < 64; i++) { - output[i] = t[i]; - } -} - diff --git a/lib/mayo/fips202.h b/lib/mayo/fips202.h deleted file mode 100644 index ed39e1270..000000000 --- a/lib/mayo/fips202.h +++ /dev/null @@ -1,12 +0,0 @@ -// SPDX-License-Identifier: Apache-2.0 - -#ifndef FIPS202_H -#define FIPS202_H - -#include - -int shake128(unsigned char *output, size_t outputByteLen, const unsigned char *input, size_t inputByteLen); -int shake256(unsigned char *output, size_t outputByteLen, const unsigned char *input, size_t inputByteLen); - -#endif - diff --git a/lib/mayo/mayo.c b/lib/mayo/mayo.c index 712b40260..719dcbf9b 100644 --- a/lib/mayo/mayo.c +++ b/lib/mayo/mayo.c @@ -5,7 +5,8 @@ #include #include #include -#include +// FIPS202 implementation from PQClean +#include "../pqclean/fips202.h" #include #include #include diff --git a/src/zenroom.h b/src/zenroom.h index 83892a627..077eb0ae2 100644 --- a/src/zenroom.h +++ b/src/zenroom.h @@ -166,7 +166,7 @@ void zen_teardown(zenroom_t *zenroom); #endif #ifndef MAX_STRING // mostly for cli.c -#define MAX_STRING 20480 // max 20KiB strings +#define MAX_STRING 21504 // max 21KiB strings #endif #ifndef MAX_OCTET From 435c12e946ba1c7cdc940eb72eedd877235109cf Mon Sep 17 00:00:00 2001 From: ms8421ms Date: Fri, 20 Mar 2026 14:12:43 +0100 Subject: [PATCH 17/19] fix: correct cflags for mayo --- build/deps.mk | 1 + build/init.mk | 1 + 2 files changed, 2 insertions(+) diff --git a/build/deps.mk b/build/deps.mk index f2445fba0..19985233e 100644 --- a/build/deps.mk +++ b/build/deps.mk @@ -142,6 +142,7 @@ mayo: CC="${mayo_cc}" \ LD=${ld} \ AR=${ar} \ + CFLAGS="${mayo_cflags} ${cflags}" \ RANLIB=${ranlib} \ LDFLAGS="${ldflags}" \ ${MAKE} -C ${pwd}/lib/mayo diff --git a/build/init.mk b/build/init.mk index 62debd83f..ce8e6b252 100644 --- a/build/init.mk +++ b/build/init.mk @@ -152,5 +152,6 @@ zstd_cc ?= ${cc} #----------------- # mayo settings mayo_cc ?= ${cc} +mayo_cflags ?= -I ${pwd}/src -I. -fPIC -DMAYO_BUILD_TYPE_REF=1 -DMAYO_VARIANT=MAYO_5 # }} From 1ecc75ed775e77085473b79ec415405638e4e827 Mon Sep 17 00:00:00 2001 From: Jaromil Date: Thu, 2 Apr 2026 16:12:02 +0200 Subject: [PATCH 18/19] fix: use current context access in mayo module --- src/zen_mayo.c | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/src/zen_mayo.c b/src/zen_mayo.c index bfdb6efae..c4a1a82cb 100644 --- a/src/zen_mayo.c +++ b/src/zen_mayo.c @@ -12,7 +12,7 @@ static int zen_mayo_secgen(lua_State *L) { BEGIN(); - Z(L); + zenroom_t *Z = zen_get_context(L); register const size_t sksize = CRYPTO_SECRETKEYBYTES; octet *sk = o_new(L, sksize); SAFE(sk, "Could not create secret key"); register size_t i; @@ -25,7 +25,8 @@ static int zen_mayo_secgen(lua_State *L) { static int zen_mayo_pubgen(lua_State *L) { BEGIN(); char *failed_msg = NULL; - octet *pk = NULL, *sk = NULL; + octet *pk = NULL; + const octet *sk = NULL; sk = o_arg(L, 1); SAFE_GOTO(sk, "Could not allocate secret key"); SAFE_GOTO(sk->len == CRYPTO_SECRETKEYBYTES, "Invalid size for MAYO_5 secret key"); pk = o_new(L, CRYPTO_PUBLICKEYBYTES); SAFE_GOTO(pk, "Could not create public key"); From 8a4cfb2cd8f0f7f5490d024b414ec8727c1a99e9 Mon Sep 17 00:00:00 2001 From: ms8421ms Date: Tue, 28 Apr 2026 09:47:52 +0200 Subject: [PATCH 19/19] feat: integrating mayo threshold --- src/lua/crypto_mayo_threshold.lua | 444 ++++++++++++++++++++++++++++++ 1 file changed, 444 insertions(+) create mode 100644 src/lua/crypto_mayo_threshold.lua diff --git a/src/lua/crypto_mayo_threshold.lua b/src/lua/crypto_mayo_threshold.lua new file mode 100644 index 000000000..8ddef3a44 --- /dev/null +++ b/src/lua/crypto_mayo_threshold.lua @@ -0,0 +1,444 @@ +--[[ +--This file is part of zenroom +-- +--Copyright (C) 2025-2026 Dyne.org foundation +--designed, written and maintained by Denis Roio +-- +--This program is free software: you can redistribute it and/or modify +--it under the terms of the GNU Affero General Public License as +--published by the Free Software Foundation, either version 3 of the +--License, or (at your option) any later version. +-- +--This program is distributed in the hope that it will be useful, +--but WITHOUT ANY WARRANTY; without even the implied warranty of +--MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +--GNU Affero General Public License for more details. +-- +--You should have received a copy of the GNU Affero General Public License +--along with this program. If not, see . +-- +-- Last modified by Matteo Sangalli +-- on Monday, 20th April 2026 +--]] + +-- Threshold Mayo (vinaigrette) +-- See https://eprint.iacr.org/2026/710.pdf for reference + +TRM = {} + +TRM.f16 = {} +TRM.rand = {} +TRM.shamir = {} +TRM.additive = {} + +local f16_log = { + [0] = 0, 0, 1, 4, 2, 8, 5, 10, 3, 14, 9, 7, 6, 13, 11, 12 +} + +local f16_exp = { + [0] = 1, 2, 4, 8, 3, 6, 12, 11, 5, 10, 7, 14, 15, 13, 9, 1 +} + +local function add_matrices(A, B) + local C = {} + for r = 1, #A do + C[r] = OCTET.xor(A[r], B[r]) + end + return C +end + +local function multiply_matrix_with_constant(A, b) + local rows = #A + local cols = #A[1] + local C = {} + for r = 1, rows do + local row = {} + local row_array = A[r]:to_array() + for c = 1, cols do + local a_rc = row_array[c] + local c_rc = TRM.f16.mul(a_rc, b) + row[c] = string.format("%02x", c_rc) + end + C[r] = OCTET.from_hex(table.concat(row)) + end + return C +end + +local function generate_zero_matrix(rows, cols) + local matrix = {} + for r = 1, rows do + local row = {} + for c = 1, cols do + row[c] = "00" + end + matrix[r] = OCTET.from_hex(table.concat(row)) + end + return matrix +end + +local function matrix_equal(A, B) + if #A ~= #B then + return false + end + for r = 1, #A do + if A[r] ~= B[r] then + return false + end + end + return true +end + +local function generate_coefficients(secret, t) + local coeffs = {secret} + for i = 1, t-1 do + coeffs[i+1] = TRM.f16.random() + end + return coeffs +end + +function TRM.f16.random() + local rand_hex = OCTET.random(1):hex() + return tonumber(rand_hex, 16) % 16 +end + +function TRM.f16.add(a, b) + return a ~ b +end + +function TRM.f16.mul(a, b) + if a == 0 or b == 0 then + return 0 + end + local log_a = f16_log[a] + local log_b = f16_log[b] + local log_result = (log_a + log_b) % 15 + return f16_exp[log_result] +end + +function TRM.f16.inv(a) + if a == 0 then + return 0 + end + local log_a = f16_log[a] + local log_inv = (15 - log_a) % 15 + return f16_exp[log_inv] +end + +function TRM.f16.sub(a, b) + return a ~ b +end + +function TRM.f16.div(a, b) + if b == 0 then + error("Division by zero in F16") + end + if a == 0 then + return 0 + end + return TRM.f16.mul(a, TRM.f16.inv(b)) +end + +function TRM.rand.coin(amount_of_parties, lambda) + local result = {} + local size = lambda + 64 + + for i = 1, size do + local current = 0 + for p = 1, amount_of_parties do + current = current ~ TRM.f16.random() + end + result[i] = string.format("%02x", current) + end + + return OCTET.from_hex(table.concat(result)) +end + +function TRM.rand.coin_matrix(amount_of_parties, rows, cols) + local matrix = {} + for r = 1, rows do + local row = {} + for c = 1, cols do + local current = 0 + for p = 1, amount_of_parties do + current = current ~ TRM.f16.random() + end + row[c] = string.format("%02x", current) + end + matrix[r] = OCTET.from_hex(table.concat(row)) + end + return matrix +end + +function TRM.rand.matrix(rows, cols) + local matrix = {} + for r = 1, rows do + local row = {} + for c = 1, cols do + row[c] = string.format("%02x", TRM.f16.random()) + end + matrix[r] = OCTET.from_hex(table.concat(row)) + end + return matrix +end + +function TRM.rand.vector(cols) + local vector = {} + for c = 1, cols do + vector[c] = string.format("%02x", TRM.f16.random()) + end + return OCTET.from_hex(table.concat(vector)) +end + +function TRM.shamir.create_shares(secret, n, t, global_alphas) + local mac_amount = #global_alphas + local share_coeffs = generate_coefficients(secret, t) + local shares = {} + + for x = 1, n do + local y = share_coeffs[t] + for j = t-1, 1, -1 do + y = TRM.f16.add(TRM.f16.mul(y, x), share_coeffs[j]) + end + shares[x] = y + end + + local gamma_shares = {} + for p = 1, n do + gamma_shares[p] = {} + end + + for k = 1, mac_amount do + local gamma_secret = TRM.f16.mul(secret, global_alphas[k]) + local gamma_coeffs = generate_coefficients(gamma_secret, t) + for x = 1, n do + local y = gamma_coeffs[t] + for j = t-1, 1, -1 do + y = TRM.f16.add(TRM.f16.mul(y, x), gamma_coeffs[j]) + end + gamma_shares[x][k] = y + end + end + + local result = {} + for p = 1, n do + result[p] = {share = shares[p], gamma = gamma_shares[p]} + end + return result +end + +function TRM.shamir.reconstruct_secret(shares, t) + local secret = 0 + for j = 1, t do + local xj = j + local lj = 1 + for m = 1, t do + if m ~= j then + local xm = m + lj = TRM.f16.mul(lj, TRM.f16.div(xm, TRM.f16.sub(xm, xj))) + end + end + secret = TRM.f16.add(secret, TRM.f16.mul(shares[j], lj)) + end + return secret +end + +function TRM.shamir.create_shares_for_matrix(secret_matrix, n, t, global_alphas) + local rows = #secret_matrix + local cols = #secret_matrix[1] + local mac_amount = #global_alphas + + local party_shares = {} + for p = 1, n do + party_shares[p] = { + shares = {}, + gamma = {} + } + for k = 1, mac_amount do + party_shares[p].gamma[k] = {} + end + end + + for r = 1, rows do + local row_array = secret_matrix[r]:to_array() + local row = {} + local gamma = {} + for p = 1, n do + row[p] = {} + gamma[p] = {} + for k = 1, mac_amount do + gamma[p][k] = {} + end + end + + for c = 1, cols do + local secret = row_array[c] + local shares = TRM.shamir.create_shares(secret, n, t, global_alphas) + + for p = 1, n do + row[p][c] = string.format("%02x", shares[p].share) + for k = 1, mac_amount do + gamma[p][k][c] = string.format("%02x", shares[p].gamma[k]) + end + end + end + + for p = 1, n do + party_shares[p].shares[r] = OCTET.from_hex(table.concat(row[p])) + for k = 1, mac_amount do + party_shares[p].gamma[k][r] = OCTET.from_hex(table.concat(gamma[p][k])) + end + end + end + + return party_shares +end + +function TRM.shamir.open_matrix(shares_all_parties, t) + local rows = #shares_all_parties[1] + local cols = #shares_all_parties[1][1] + local secret_matrix = {} + + for r = 1, rows do + local row = {} + local party_rows = {} + for p = 1, t do + party_rows[p] = shares_all_parties[p][r]:to_array() + end + + for c = 1, cols do + local shares = {} + for p = 1, t do + shares[p] = party_rows[p][c] + end + + local reconstructed_val = TRM.shamir.reconstruct_secret(shares, t) + row[c] = string.format("%02x", reconstructed_val) + end + secret_matrix[r] = OCTET.from_hex(table.concat(row)) + end + return secret_matrix +end + +function TRM.shamir.add_public_left(A, B_share, party_id, alpha_shares) + local mac_amount = #alpha_shares[1] + local result = {shares = add_matrices(A, B_share.shares), gamma = {}} + for k = 1, mac_amount do + result.gamma[k] = add_matrices(multiply_matrix_with_constant(A, alpha_shares[party_id][k]), B_share.gamma[k]) + end + return result +end + +function TRM.shamir.authenticated_open_matrix(shares, t, alpha_shares) + local parties = #shares + local rows = #shares[1].shares + local cols = #shares[1].shares[1] + local mac_amount = #alpha_shares[1] + + local zero = generate_zero_matrix(rows, cols) + + local s_prime_shares = {} + for p = 1, t do + s_prime_shares[p] = shares[p].shares + end + + local s_prime = TRM.shamir.open_matrix(s_prime_shares, t) + + for k = 1, mac_amount do + local mu_shares = {} + for p = 1, t do + local s_prime_times_alpha = multiply_matrix_with_constant(s_prime, alpha_shares[p][k]) + mu_shares[p] = add_matrices(s_prime_times_alpha, shares[p].gamma[k]) + end + + local mu_open = TRM.shamir.open_matrix(mu_shares, t) + if not matrix_equal(mu_open, zero) then + error("MAC verification failed during authenticated opening") + end + end + + return s_prime +end + +function TRM.shamir.create_shares_for_random_matrix(n, t, rows, cols, global_alphas) + local random_matrix = TRM.rand.matrix(rows, cols) + return TRM.shamir.create_shares_for_matrix(random_matrix, n, t, global_alphas) +end + +function TRM.additive.create_shares_for_matrix(M, n, mac_amount, global_alphas) + local rows = #M + local cols = #M[1]:to_array() + local result = {} + + for p = 1, n do + result[p] = {shares = {}, gamma = {}} + for k = 1, mac_amount do + result[p].gamma[k] = {} + end + end + + for r = 1, rows do + local row_array = M[r]:to_array() + local row_shares_hex = {} + local row_gammas_hex = {} + for p = 1, n do + row_shares_hex[p] = {} + row_gammas_hex[p] = {} + for k = 1, mac_amount do + row_gammas_hex[p][k] = {} + end + end + + for c = 1, cols do + local secret = row_array[c] + local shares_sum = 0 + for p = 1, n-1 do + local rnd = TRM.f16.random() + row_shares_hex[p][c] = string.format("%02x", rnd) + shares_sum = TRM.f16.add(shares_sum, rnd) + end + local last_share = TRM.f16.sub(secret, shares_sum) + row_shares_hex[n][c] = string.format("%02x", last_share) + + for k = 1, mac_amount do + local gamma_sum = 0 + for p = 1, n-1 do + local rnd_gamma = TRM.f16.random() + row_gammas_hex[p][k][c] = string.format("%02x", rnd_gamma) + gamma_sum = TRM.f16.add(gamma_sum, rnd_gamma) + end + local alpha_times_secret = TRM.f16.mul(secret, global_alphas[k]) + local last_gamma = TRM.f16.sub(alpha_times_secret, gamma_sum) + row_gammas_hex[n][k][c] = string.format("%02x", last_gamma) + end + end + + for p = 1, n do + result[p].shares[r] = OCTET.from_hex(table.concat(row_shares_hex[p])) + for k = 1, mac_amount do + result[p].gamma[k][r] = OCTET.from_hex(table.concat(row_gammas_hex[p][k])) + end + end + end + + return result +end + +function TRM.additive.open_matrix(shares) + local rows = #shares[1] + local cols = #shares[1][1] + local result = generate_zero_matrix(rows, cols) + + for p = 1, #shares do + result = add_matrices(result, shares[p]) + end + + return result +end + +function TRM.additive.create_shares_for_random_matrix(n, rows, cols, mac_amount, global_alphas) + local random_matrix = TRM.rand.matrix(rows, cols) + return TRM.additive.create_shares_for_matrix(random_matrix, n, mac_amount, global_alphas) +end + +return TRM +