kpqc 0.1.0

data/vendor/SMAUG-T/src/poly.c

@@ -0,0 +1,200 @@
+// SPDX-License-Identifier: MIT
+
+#include "poly.h"
+#include "toomcook.h"
+#include <string.h>
+
+#if SMAUGT_MODE == SMAUGT_MODET
+/*************************************************
+ * Name:        flipabs
+ *
+ * Description: Computes |(x mod q) - Q/2|
+ *
+ * Arguments:   - uint16_t x: input coefficient
+ *
+ * Return: |(x mod q) - Q/2|
+ **************************************************/
+uint16_t flipabs(uint16_t x) {
+    int16_t r, m;
+    r = x - (SMAUGT_MODULUS_SCALED_Q_HALF);
+    m = r >> 15;
+    return (r + m) ^ m;
+}
+
+/*************************************************
+ * Name:        d2_ecd
+ *
+ * Description: Convert 16-byte message to polynomial
+ *
+ * Arguments:   - poly *r: pointer to output polynomial
+ *              - const uint8_t msg[SMAUGT_MSG_BYTES]: pointer to input message
+ **************************************************/
+void d2_ecd(poly *r, const uint8_t msg[SMAUGT_MSG_BYTES]) {
+    unsigned int mask;
+    for (size_t i = 0; i < SMAUGT_MSG_BYTES; i++) {
+        for (size_t j = 0; j < 8; j++) {
+            mask = (msg[i] >> j) & 1;
+            mask = (mask * SMAUGT_MODULUS_SCALED_Q_HALF) &
+                   SMAUGT_MODULUS_SCALED_Q_HALF;
+            r->coeffs[8 * i + j] = mask;
+            r->coeffs[8 * i + j + 128] = mask;
+        }
+    }
+}
+
+/*************************************************
+ * Name:        d2_dcd
+ *
+ * Description: Convert polynomial to 16-byte message
+ *
+ * Arguments:   - uint8_t msg[SMAUGT_MSG_BYTES]: pointer to output message
+ *              - const poly *x: pointer to input polynomial
+ **************************************************/
+void d2_dcd(uint8_t msg[SMAUGT_MSG_BYTES], const poly *x) {
+    uint16_t t;
+    for (size_t i = 0; i < SMAUGT_MSG_BYTES; i++)
+        msg[i] = 0;
+
+    for (size_t i = 0; i < SMAUGT_N / 2; i++) {
+        t = flipabs(x->coeffs[i]);
+        t += flipabs(x->coeffs[i + 128]);
+        t = t - SMAUGT_MODULUS_SCALED_Q_HALF;
+        t >>= 15;
+        msg[i >> 3] |= t << (i & 7);
+    }
+}
+#endif
+/*************************************************
+ * Name:        poly_add
+ *
+ * Description: Add two polynomials. no modular reduction is performed
+ *
+ * Arguments: - poly *r: pointer to output polynomial
+ *            - const poly *a: pointer to first input polynomial
+ *            - const poly *b: pointer to second input polynomial
+ **************************************************/
+static inline void poly_add(poly *r, const poly *a, const poly *b) {
+    unsigned int i;
+    for (i = 0; i < SMAUGT_N; i++)
+        r->coeffs[i] = a->coeffs[i] + b->coeffs[i];
+}
+
+/*************************************************
+ * Name:        poly_sub
+ *
+ * Description: Subtract two polynomials. no modular reduction is performed
+ *
+ * Arguments: - poly *r: pointer to output polynomial
+ *            - const poly *a: pointer to first input polynomial
+ *            - const poly *b: pointer to second input polynomial
+ **************************************************/
+static inline void poly_sub(poly *r, const poly *a, const poly *b) {
+    unsigned int i;
+    for (i = 0; i < SMAUGT_N; i++)
+        r->coeffs[i] = a->coeffs[i] - b->coeffs[i];
+}
+
+#define vec_vec_mult SMAUGT_NAMESPACE(vec_vec_mult)
+/*************************************************
+ * Name:        vec_vec_mult
+ *
+ * Description: Multiply two vector of polynomials.
+ *
+ * Arguments:   - poly *r: pointer to output polynomial
+ *              - const polyvec *a: pointer to input vector of polynomials
+ *              - const polyvec *b: pointer to input vector of polynomials
+ **************************************************/
+void vec_vec_mult(poly *r, const polyvec *a, const polyvec *b) {
+    unsigned int i;
+    for (i = 0; i < SMAUGT_K; i++)
+        poly_mul_acc(a->vec[i].coeffs, b->vec[i].coeffs, r->coeffs);
+}
+
+/*************************************************
+ * Name:        vec_vec_mult_add
+ *
+ * Description: Multiply two vectors of polynomials and add the result to output
+ *              polynomial
+ *
+ * Arguments:   - poly *r: pointer to output polynomial
+ *              - const polyvec *a: pointer to input vector of polynomials
+ *              - const polyvec *b: pointer to input vector of polynomials
+ *              - uint8_t mod: modulus (16-SMAUGT_LOG_P) or (16-SMAUGT_LOG_Q)
+ **************************************************/
+void vec_vec_mult_add(poly *r, const polyvec *a, const polyvec *b,
+                      uint8_t mod) {
+    unsigned int i, j;
+    polyvec al;
+    poly res;
+
+    for (i = 0; i < SMAUGT_K; ++i)
+        for (j = 0; j < SMAUGT_N; ++j)
+            al.vec[i].coeffs[j] = a->vec[i].coeffs[j] >> mod;
+
+    memset(&res, 0, sizeof(poly));
+    vec_vec_mult(&res, &al, b);
+    for (j = 0; j < SMAUGT_N; ++j)
+        res.coeffs[j] <<= mod;
+
+    poly_add(r, r, &res);
+}
+
+/*************************************************
+ * Name:        matrix_vec_mult_add
+ *
+ * Description: Transpose the matrix of polynomial and multiply it with the
+ *              vector of polynomials.
+ *
+ * Arguments:   - polyvec *r: pointer to output vector of polynomials
+ *              - const polyvec a[SMAUGT_K]: pointer to input matrix of
+ *              polynomials
+ *              - const polyvec *b: pointer to input vector of polynomials
+ **************************************************/
+void matrix_vec_mult_add(polyvec *r, const polyvec a[SMAUGT_K],
+                         const polyvec *b) {
+    unsigned int i, j, k;
+    polyvec at;
+
+    for (i = 0; i < SMAUGT_K; ++i) {
+        for (j = 0; j < SMAUGT_K; ++j)
+            for (k = 0; k < SMAUGT_N; ++k)
+                at.vec[j].coeffs[k] =
+                    a[j].vec[i].coeffs[k] >> SMAUGT_MODULUS_16_LOG_Q;
+
+        vec_vec_mult(&r->vec[i], &at, b);
+        for (j = 0; j < SMAUGT_N; ++j)
+            r->vec[i].coeffs[j] <<= SMAUGT_MODULUS_16_LOG_Q;
+    }
+}
+
+/*************************************************
+ * Name:        matrix_vec_mult_sub
+ *
+ * Description: Multiply the matrix of polynomial with the vector of polynomial
+ *              and subtract the result to output vector of polynomials.
+ *
+ * Arguments:   - polyvec *r: pointer to input/output vector of polynomials
+ *              - const polyvec a[SMAUGT_K]: pointer to input matrix of
+ *              polynomials
+ *              - const polyvec *b: pointer to input vector of polynomials
+ **************************************************/
+void matrix_vec_mult_sub(polyvec *r, const polyvec a[SMAUGT_K],
+                         const polyvec *b) {
+    unsigned int i, j, k;
+    polyvec al;
+    poly res;
+
+    for (i = 0; i < SMAUGT_K; ++i) {
+        for (j = 0; j < SMAUGT_K; ++j)
+            for (k = 0; k < SMAUGT_N; ++k)
+                al.vec[j].coeffs[k] =
+                    a[i].vec[j].coeffs[k] >> SMAUGT_MODULUS_16_LOG_Q;
+
+        memset(&res, 0, sizeof(poly));
+        vec_vec_mult(&res, &al, b);
+        for (j = 0; j < SMAUGT_N; ++j)
+            res.coeffs[j] <<= SMAUGT_MODULUS_16_LOG_Q;
+
+        poly_sub(&r->vec[i], &r->vec[i], &res);
+    }
+}

data/vendor/SMAUG-T/src/toomcook.c

@@ -0,0 +1,256 @@
+// SPDX-License-Identifier: MIT
+
+#include "toomcook.h"
+#include <stdint.h>
+#include <string.h>
+
+#define SCHB_N 16
+
+#define N_RES (SMAUGT_N << 1)
+#define N_SB (SMAUGT_N >> 2)
+#define N_SB_RES (2 * N_SB - 1)
+
+#define OVERFLOWING_MUL(X, Y) ((uint16_t)((uint32_t)(X) * (uint32_t)(Y)))
+
+#define KARATSUBA_N 64
+#define karatsuba_simple SMAUGT_NAMESPACE(karatsuba_simple)
+static void karatsuba_simple(const uint16_t *a_1, const uint16_t *b_1,
+                             uint16_t *result_final) {
+    uint16_t d01[KARATSUBA_N / 2 - 1];
+    uint16_t d0123[KARATSUBA_N / 2 - 1];
+    uint16_t d23[KARATSUBA_N / 2 - 1];
+    uint16_t result_d01[KARATSUBA_N - 1];
+
+    int32_t i, j;
+
+    memset(result_d01, 0, (KARATSUBA_N - 1) * sizeof(uint16_t));
+    memset(d01, 0, (KARATSUBA_N / 2 - 1) * sizeof(uint16_t));
+    memset(d0123, 0, (KARATSUBA_N / 2 - 1) * sizeof(uint16_t));
+    memset(d23, 0, (KARATSUBA_N / 2 - 1) * sizeof(uint16_t));
+    memset(result_final, 0, (2 * KARATSUBA_N - 1) * sizeof(uint16_t));
+
+    uint16_t acc1, acc2, acc3, acc4, acc5, acc6, acc7, acc8, acc9, acc10;
+
+    for (i = 0; i < KARATSUBA_N / 4; i++) {
+        acc1 = a_1[i];                       // a0
+        acc2 = a_1[i + KARATSUBA_N / 4];     // a1
+        acc3 = a_1[i + 2 * KARATSUBA_N / 4]; // a2
+        acc4 = a_1[i + 3 * KARATSUBA_N / 4]; // a3
+        for (j = 0; j < KARATSUBA_N / 4; j++) {
+
+            acc5 = b_1[j];                   // b0
+            acc6 = b_1[j + KARATSUBA_N / 4]; // b1
+
+            result_final[i + j + 0 * KARATSUBA_N / 4] =
+                result_final[i + j + 0 * KARATSUBA_N / 4] +
+                OVERFLOWING_MUL(acc1, acc5);
+            result_final[i + j + 2 * KARATSUBA_N / 4] =
+                result_final[i + j + 2 * KARATSUBA_N / 4] +
+                OVERFLOWING_MUL(acc2, acc6);
+
+            acc7 = acc5 + acc6; // b01
+            acc8 = acc1 + acc2; // a01
+            d01[i + j] = d01[i + j] + (uint16_t)(acc7 * (uint64_t)acc8);
+            //--------------------------------------------------------
+
+            acc7 = b_1[j + 2 * KARATSUBA_N / 4]; // b2
+            acc8 = b_1[j + 3 * KARATSUBA_N / 4]; // b3
+            result_final[i + j + 4 * KARATSUBA_N / 4] =
+                result_final[i + j + 4 * KARATSUBA_N / 4] +
+                OVERFLOWING_MUL(acc7, acc3);
+
+            result_final[i + j + 6 * KARATSUBA_N / 4] =
+                result_final[i + j + 6 * KARATSUBA_N / 4] +
+                OVERFLOWING_MUL(acc8, acc4);
+
+            acc9 = acc3 + acc4;
+            acc10 = acc7 + acc8;
+            d23[i + j] = d23[i + j] + OVERFLOWING_MUL(acc9, acc10);
+            //--------------------------------------------------------
+
+            acc5 = acc5 + acc7; // b02
+            acc7 = acc1 + acc3; // a02
+            result_d01[i + j + 0 * KARATSUBA_N / 4] =
+                result_d01[i + j + 0 * KARATSUBA_N / 4] +
+                OVERFLOWING_MUL(acc5, acc7);
+
+            acc6 = acc6 + acc8; // b13
+            acc8 = acc2 + acc4;
+            result_d01[i + j + 2 * KARATSUBA_N / 4] =
+                result_d01[i + j + 2 * KARATSUBA_N / 4] +
+                OVERFLOWING_MUL(acc6, acc8);
+
+            acc5 = acc5 + acc6;
+            acc7 = acc7 + acc8;
+            d0123[i + j] = d0123[i + j] + OVERFLOWING_MUL(acc5, acc7);
+        }
+    }
+
+    // 2nd last stage
+
+    for (i = 0; i < KARATSUBA_N / 2 - 1; i++) {
+        d0123[i] = d0123[i] - result_d01[i + 0 * KARATSUBA_N / 4] -
+                   result_d01[i + 2 * KARATSUBA_N / 4];
+        d01[i] = d01[i] - result_final[i + 0 * KARATSUBA_N / 4] -
+                 result_final[i + 2 * KARATSUBA_N / 4];
+        d23[i] = d23[i] - result_final[i + 4 * KARATSUBA_N / 4] -
+                 result_final[i + 6 * KARATSUBA_N / 4];
+    }
+
+    for (i = 0; i < KARATSUBA_N / 2 - 1; i++) {
+        result_d01[i + 1 * KARATSUBA_N / 4] =
+            result_d01[i + 1 * KARATSUBA_N / 4] + d0123[i];
+        result_final[i + 1 * KARATSUBA_N / 4] =
+            result_final[i + 1 * KARATSUBA_N / 4] + d01[i];
+        result_final[i + 5 * KARATSUBA_N / 4] =
+            result_final[i + 5 * KARATSUBA_N / 4] + d23[i];
+    }
+
+    // Last stage
+    for (i = 0; i < KARATSUBA_N - 1; i++) {
+        result_d01[i] =
+            result_d01[i] - result_final[i] - result_final[i + KARATSUBA_N];
+    }
+
+    for (i = 0; i < KARATSUBA_N - 1; i++) {
+        result_final[i + 1 * KARATSUBA_N / 2] =
+            result_final[i + 1 * KARATSUBA_N / 2] + result_d01[i];
+    }
+}
+
+#define toom_cook_4way SMAUGT_NAMESPACE(toom_cook_4way)
+static void toom_cook_4way(const uint16_t *a1, const uint16_t *b1,
+                           uint16_t *result) {
+    uint16_t inv3 = 43691, inv9 = 36409, inv15 = 61167;
+
+    uint16_t aw1[N_SB], aw2[N_SB], aw3[N_SB], aw4[N_SB], aw5[N_SB], aw6[N_SB],
+        aw7[N_SB];
+    uint16_t bw1[N_SB], bw2[N_SB], bw3[N_SB], bw4[N_SB], bw5[N_SB], bw6[N_SB],
+        bw7[N_SB];
+    uint16_t w1[N_SB_RES] = {0}, w2[N_SB_RES] = {0}, w3[N_SB_RES] = {0},
+             w4[N_SB_RES] = {0}, w5[N_SB_RES] = {0}, w6[N_SB_RES] = {0},
+             w7[N_SB_RES] = {0};
+    uint16_t r0, r1, r2, r3, r4, r5, r6, r7;
+    uint16_t *A0, *A1, *A2, *A3, *B0, *B1, *B2, *B3;
+    A0 = (uint16_t *)a1;
+    A1 = (uint16_t *)&a1[N_SB];
+    A2 = (uint16_t *)&a1[2 * N_SB];
+    A3 = (uint16_t *)&a1[3 * N_SB];
+    B0 = (uint16_t *)b1;
+    B1 = (uint16_t *)&b1[N_SB];
+    B2 = (uint16_t *)&b1[2 * N_SB];
+    B3 = (uint16_t *)&b1[3 * N_SB];
+
+    uint16_t *C;
+    C = result;
+
+    int i, j;
+
+    // EVALUATION
+    for (j = 0; j < N_SB; ++j) {
+        r0 = A0[j];
+        r1 = A1[j];
+        r2 = A2[j];
+        r3 = A3[j];
+        r4 = r0 + r2;
+        r5 = r1 + r3;
+        r6 = r4 + r5;
+        r7 = r4 - r5;
+        aw3[j] = r6;
+        aw4[j] = r7;
+        r4 = ((r0 << 2) + r2) << 1;
+        r5 = (r1 << 2) + r3;
+        r6 = r4 + r5;
+        r7 = r4 - r5;
+        aw5[j] = r6;
+        aw6[j] = r7;
+        r4 = (r3 << 3) + (r2 << 2) + (r1 << 1) + r0;
+        aw2[j] = r4;
+        aw7[j] = r0;
+        aw1[j] = r3;
+    }
+    for (j = 0; j < N_SB; ++j) {
+        r0 = B0[j];
+        r1 = B1[j];
+        r2 = B2[j];
+        r3 = B3[j];
+        r4 = r0 + r2;
+        r5 = r1 + r3;
+        r6 = r4 + r5;
+        r7 = r4 - r5;
+        bw3[j] = r6;
+        bw4[j] = r7;
+        r4 = ((r0 << 2) + r2) << 1;
+        r5 = (r1 << 2) + r3;
+        r6 = r4 + r5;
+        r7 = r4 - r5;
+        bw5[j] = r6;
+        bw6[j] = r7;
+        r4 = (r3 << 3) + (r2 << 2) + (r1 << 1) + r0;
+        bw2[j] = r4;
+        bw7[j] = r0;
+        bw1[j] = r3;
+    }
+
+    // MULTIPLICATION
+
+    karatsuba_simple(aw1, bw1, w1);
+    karatsuba_simple(aw2, bw2, w2);
+    karatsuba_simple(aw3, bw3, w3);
+    karatsuba_simple(aw4, bw4, w4);
+    karatsuba_simple(aw5, bw5, w5);
+    karatsuba_simple(aw6, bw6, w6);
+    karatsuba_simple(aw7, bw7, w7);
+
+    // INTERPOLATION
+    for (i = 0; i < N_SB_RES; ++i) {
+        r0 = w1[i];
+        r1 = w2[i];
+        r2 = w3[i];
+        r3 = w4[i];
+        r4 = w5[i];
+        r5 = w6[i];
+        r6 = w7[i];
+
+        r1 = r1 + r4;
+        r5 = r5 - r4;
+        r3 = ((r3 - r2) >> 1);
+        r4 = r4 - r0;
+        r4 = r4 - (r6 << 6);
+        r4 = (r4 << 1) + r5;
+        r2 = r2 + r3;
+        r1 = r1 - (r2 << 6) - r2;
+        r2 = r2 - r6;
+        r2 = r2 - r0;
+        r1 = r1 + 45 * r2;
+        r4 = (uint16_t)(((r4 - (r2 << 3)) * (uint32_t)inv3) >> 3);
+        r5 = r5 + r1;
+        r1 = (uint16_t)(((r1 + (r3 << 4)) * (uint32_t)inv9) >> 1);
+        r3 = -(r3 + r1);
+        r5 = (uint16_t)(((30 * r1 - r5) * (uint32_t)inv15) >> 2);
+        r2 = r2 - r4;
+        r1 = r1 - r5;
+
+        C[i] += r6;
+        C[i + 64] += r5;
+        C[i + 128] += r4;
+        C[i + 192] += r3;
+        C[i + 256] += r2;
+        C[i + 320] += r1;
+        C[i + 384] += r0;
+    }
+}
+
+/* res += a*b */
+void poly_mul_acc(const int16_t a[SMAUGT_N], const int16_t b[SMAUGT_N],
+                  int16_t res[SMAUGT_N]) {
+    uint16_t c[2 * SMAUGT_N] = {0};
+    int i;
+
+    toom_cook_4way((uint16_t *)a, (uint16_t *)b, c);
+
+    /* reduction */
+    for (i = SMAUGT_N; i < 2 * SMAUGT_N; i++) {
+        res[i - SMAUGT_N] += (c[i - SMAUGT_N] - c[i]);
+    }
+}

data/vendor/SMAUG-T/src/verify.c

@@ -0,0 +1,48 @@
+// SPDX-License-Identifier: MIT
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include "verify.h"
+
+/*************************************************
+ * Name:        verify
+ *
+ * Description: Compare two arrays for equality in constant time.
+ *
+ * Arguments:   - const uint8_t *a: pointer to first byte array
+ *              - const uint8_t *b: pointer to second byte array
+ *              - size_t len: length of the byte arrays
+ *
+ * Return: 0 if the byte arrays are equal, 1 otherwise
+ **************************************************/
+int verify(const uint8_t *a, const uint8_t *b, size_t len) {
+    size_t i;
+    uint8_t r = 0;
+
+    for (i = 0; i < len; i++)
+        r |= a[i] ^ b[i];
+
+    return (-(uint64_t)r) >> 63;
+}
+
+/*************************************************
+ * Name:        cmov
+ *
+ * Description: Copy len bytes from x to r if b is 1;
+ *              don't modify x if b is 0. Requires b to be in {0,1};
+ *              assumes two's complement representation of negative integers.
+ *              Runs in constant time.
+ *
+ * Arguments:   - uint8_t *r: pointer to output byte array
+ *              - const uint8_t *x: pointer to input byte array
+ *              - size_t len: amount of bytes to be copied
+ *              - uint8_t b: condition bit; has to be in {0,1}
+ **************************************************/
+void cmov(uint8_t *r, const uint8_t *x, size_t len, uint8_t b) {
+    size_t i;
+
+    b = -b;
+    for (i = 0; i < len; i++)
+        r[i] ^= b & (r[i] ^ x[i]);
+}

data/vendor/SOURCES.json

@@ -0,0 +1,130 @@
+{
+  "vendor/AIMer/aim2.c": "58892d4b14f346a2e1ad34cb090091c8b3de76e59d75d3eccb008a2dff444612",
+  "vendor/AIMer/aim2.h": "312f0fdf0d3fcbcb081ac7a7e883ae3253a708ac702caac6f3d338056e5cddd5",
+  "vendor/AIMer/aim2_constant.h": "63238e60c59944b18066d22788f91eeb8891f0805273e5c8c5a5279ad84de97b",
+  "vendor/AIMer/api.h": "b73308e7e8610d9403903cf124a460d979c45e03630699ffa3e23eaac029a418",
+  "vendor/AIMer/common/crypto_declassify.h": "191ae6c633e9de222b370a0efa48dd95abfeb7c5b357078b17d18898950903bb",
+  "vendor/AIMer/common/fips202.c": "4871baddebf2d4771d86b5088719123e2e43addce1a3c0eca75b4d18970ffc1f",
+  "vendor/AIMer/common/fips202.h": "bf99a54bc1988380418054a18bd5a14d059770e70c1aac23b6d9c914539168e0",
+  "vendor/AIMer/common/rng.h": "81209b4388f6171e71b2885fbdaf239435342d2621be3c3cfd34a50374bbc959",
+  "vendor/AIMer/field.h": "c5352c1e004e995e4b7a824ee8f2bcf48b2d3aa57fe9b46264558727fe0f5b6a",
+  "vendor/AIMer/field128.c": "b742225325a020ca778a564114ca86592d5cd0c4e042562677ee187dca2d7ae8",
+  "vendor/AIMer/field192.c": "1f21af8d218d8ee89408b153bfc3fdf6fa71c432fff7a3f9b54ee1f20d606a3d",
+  "vendor/AIMer/field256.c": "36865cf0c0538bb2364067b269a165257515fd4c07556a79c59296f3720d7e5b",
+  "vendor/AIMer/hash.c": "850f1304af20d732d5ce6524a9dd52d873aa386815e692215e850a44f9bd66f9",
+  "vendor/AIMer/hash.h": "d102028355f4f6581a93d3612332a75600ad3677a1c1bbe40bad86898bb4602e",
+  "vendor/AIMer/params/params-aimer-128f.h": "4faf07f3e506f8c052b5c4b482354bc3beef6ad108471030c006ef5a5694cd4a",
+  "vendor/AIMer/params/params-aimer-128s.h": "fba25c728a548c01673f99edaf98aac592a35d07d241483815357f3eb2f6f270",
+  "vendor/AIMer/params/params-aimer-192f.h": "95605422d913e1a5a5d24a756f316cb34eb35decfbc6f60155167022dca5b3fd",
+  "vendor/AIMer/params/params-aimer-192s.h": "4731c3d1118a9b5899e95566881da19b2b4c696b9106bfc608550c841655c1c1",
+  "vendor/AIMer/params/params-aimer-256f.h": "227b93396216e5c2ae7c88a85386c03635afa45dd0e4ecf88f86146285bf204a",
+  "vendor/AIMer/params/params-aimer-256s.h": "182d9ec1c5439359c136030e4afaa900d026f20d8aa52ac0026d40b79e5cd3db",
+  "vendor/AIMer/params.h": "c795218db56b490f66cef2074527e97f155aea0d32226f13b7fae5ead2f0bd1f",
+  "vendor/AIMer/sign.c": "811d55d41c3fc980ae20f0dcec09feaef0d14857edd06fe906fe64e51ed82ebb",
+  "vendor/AIMer/sign.h": "f6d588846998e5e49dea4f7e3258c8eaf103413f2300b9d8124f896ed088a884",
+  "vendor/AIMer/tree.c": "d47369c7875222349c13f6337d286979bce6ba128512e2ab985deddecc932d04",
+  "vendor/AIMer/tree.h": "fa9f007a052aa6e83ea1cde04ce4d194baec721218fc49abd53ee994c1187451",
+  "vendor/HAETAE/include/api.h": "a1b7b25a53efffdfaf404942164282677a3c568c927dc502e73824eee1ee50fb",
+  "vendor/HAETAE/include/common.h": "72c062d86e4c6b900fb1df18cfc892526d3ebec17dc2b417db4a76a2531fe5e1",
+  "vendor/HAETAE/include/config.h": "4a9c0d19d428ff0fa2e4163fa5641a966d3a1fa992f57e2a8c71fe5e2866110b",
+  "vendor/HAETAE/include/decompose.h": "363d32f5172eac507b652fda495236c11376a01d62cc45b163053b2b209251f9",
+  "vendor/HAETAE/include/encoding.h": "a6b45d7f5d6e09c7befa736abe834df44a72f1e0cddb67aff0cf1b3615461b76",
+  "vendor/HAETAE/include/fft.h": "9472c620a6c4883860803a2e879fed21a4b00af862ac11b5b2f236cc1974c5db",
+  "vendor/HAETAE/include/fips202.h": "c67414df97bba53295e3f5131507e295a2b729ca43c092e8309d419739ce00c1",
+  "vendor/HAETAE/include/fixpoint.h": "4f3542f526b6c356b1ae467d4ce44bc8468d8585a25f5325fca6926b156b33f9",
+  "vendor/HAETAE/include/ntt.h": "0b2b59261bf3579d5eb63d7e07f2ea48d336a71e26c5b818ee480e55117a4544",
+  "vendor/HAETAE/include/packing.h": "b533193fb3f8590adc257b77b04aa2ed6a11c161d09805affa99af75455c6b7a",
+  "vendor/HAETAE/include/params.h": "cba72f62fab3f53b4165510afecd1e3d9ebee63cd5e875d2a3e51437db3a5726",
+  "vendor/HAETAE/include/poly.h": "2fe642667d2fbbd871931d622d916dfe840dac71fbd0e1f4bdbbf57cbb0940e0",
+  "vendor/HAETAE/include/polyfix.h": "ba5b3b326f82de64667062788f0809a545cf285c07167cfb0286438485cb34da",
+  "vendor/HAETAE/include/polymat.h": "63ff13454523f9749dede09c258072552239d922e202f147aa86bb8832e083a2",
+  "vendor/HAETAE/include/polyvec.h": "a2a64cb0f89018a3fd01012401e9fd285f265c4721255cd9abe8028d4f3e4a60",
+  "vendor/HAETAE/include/randombytes.h": "9a4b4bda5951c3aa0c8af29b5e319dc8f93bf65f038ac0c0044df22039dc6ced",
+  "vendor/HAETAE/include/rans_byte.h": "54b1760d9c4b67d3ecbcbb4254f41210970541fdd899031163cdfb09dca88a9f",
+  "vendor/HAETAE/include/reduce.h": "e7238538fee0a6ab986aff9403651c652592980f1ad6e10453ebdbf5afea5a84",
+  "vendor/HAETAE/include/sampler.h": "208f24a6d34351036239eb4a35b4d0c4d24dbe8f73fb54b3e5bcc6c8a27dd5fd",
+  "vendor/HAETAE/include/symmetric.h": "0f5db9e019cb2dfb34a96986b8adcfd3f2ecafd6ba2955ca6ee8c5dd21001cc7",
+  "vendor/HAETAE/src/decompose.c": "16057e4232a74e3f1be035041cc4324dfa260a07a1a276c895afa3b2870fa574",
+  "vendor/HAETAE/src/encoding.c": "ad14676fd5a91959abc963334123cc7343b1415a236d6ffc9ae7e225a8270a0d",
+  "vendor/HAETAE/src/fft.c": "cdb2a8599234c754da5eccc25aca2f761793e7e97a317b5f18ef33698b3c44ad",
+  "vendor/HAETAE/src/fips202.c": "17e72eee44f8c4a47a39ac4804ce15236b30f2c3ec767c99f92a7838aa79ccab",
+  "vendor/HAETAE/src/fixpoint.c": "341cbaf1ecad123218e85dae19ccbbff0dde2df2cc3e5f90c9cdcbdf94246a05",
+  "vendor/HAETAE/src/ntt.c": "034e984a72a521aa9b7c9c92bb36dcf133b80f78b1ef85b1e8e556c02ebe6d36",
+  "vendor/HAETAE/src/packing.c": "1b4bb8775425cfa5c7c5f516bb00904c3dc5dfb3014d0d1e6750ab62ce763e07",
+  "vendor/HAETAE/src/poly.c": "bc2194fa0929674b6dee6f876b100b7637c99abf0a196cc53edbf77010720f17",
+  "vendor/HAETAE/src/polyfix.c": "cf7935818dae320471e87312468269c30fb21e3003b043cfc8f10dd12a2ed264",
+  "vendor/HAETAE/src/polymat.c": "c0c3f60690716d82e5cfefd9841f0300b0a4102211a85c525e5a1caacaa69cab",
+  "vendor/HAETAE/src/polyvec.c": "022d28e6dac529e4259b0db5501d6bf93bcb390765054e99f1104a9001889426",
+  "vendor/HAETAE/src/reduce.c": "8806547100d8cffe10c26bfa9ea79dc4747ef4d1e33ae559a1d4d71c097cdf00",
+  "vendor/HAETAE/src/sampler.c": "53548231f71cd56bfbe3c5218875ffb960bc3dc835b99fa9e46ee654d841b712",
+  "vendor/HAETAE/src/sign.c": "2dcc7c2a701f1bdaddba3dd12be9eefe571ca51432b54c9e8a67178f83a4ae5b",
+  "vendor/HAETAE/src/symmetric-shake.c": "68731ce2106de35b76b89787a7922340b50d663fd562cce566c08a2acb770417",
+  "vendor/SMAUG-T/include/api.h": "37aaa15592d0a64526de446927864eb2ac6e518a0f8ce59a6564baecf75083bb",
+  "vendor/SMAUG-T/include/cbd.h": "24742be57b3b3bc42938d2f2583b38fd5b74b3182ab96adb90a99cc83ceba5ce",
+  "vendor/SMAUG-T/include/ciphertext.h": "a54816cddb1d326b318fa3e30643b0ad9ba260eb4204a8f44f18654c011769e8",
+  "vendor/SMAUG-T/include/common.h": "b9bfe50157cb8090cac54acdc366abbf120d5f4fe679b23b1e2c0cb053668970",
+  "vendor/SMAUG-T/include/config.h": "20e87adc107580676b3297a700f9fff84986a1b4a77324a0328c37640e290ca7",
+  "vendor/SMAUG-T/include/dg.h": "803b5a6a7db75f0d3b71fc1207c33e69feedd601113720a3c200672260949a4e",
+  "vendor/SMAUG-T/include/fips202.h": "f7d3b2e001a7aff0b034f0b012e3bf33f34a739a15a0437002f58426175ee9fb",
+  "vendor/SMAUG-T/include/hash.h": "5d02e2325d21f063a10e0f5ad730ad48494651afaad34eb9d121dd01aa60937b",
+  "vendor/SMAUG-T/include/hwt.h": "e5a4d136e33dfd0f2b225888a058c6e8aad64070797fb3c882a63cf5939ae8c0",
+  "vendor/SMAUG-T/include/indcpa.h": "d870dcafdfb5dc490dba6cdb60d2ba4d860eb4089f836205b4165bbba0373112",
+  "vendor/SMAUG-T/include/key.h": "1a21a3db0636153f79e7b6745d6ed3182e74d2041587f0616745d6b9ff143183",
+  "vendor/SMAUG-T/include/pack.h": "e9217303e7e34397ed602c952075f91cb7a35b2aeda0d1a621bec15e81c5e44f",
+  "vendor/SMAUG-T/include/packring.h": "03ecb692793dc0523df23793e17f1f331bdd5e694be9c71d66df5aaaaa9e8af2",
+  "vendor/SMAUG-T/include/params.h": "5ef5666a889e1397de9daa092d9a32d0d06cd29df895cb797b75837d4d8938da",
+  "vendor/SMAUG-T/include/poly.h": "1602c5949f6c7f95f7c08d1e10c4e84a4844e5bc65825daf1e67966e274de2ca",
+  "vendor/SMAUG-T/include/randombytes.h": "727ddbb9b1c17116a43b4b731bb804be7d7267ff45adf63daf866376f3502495",
+  "vendor/SMAUG-T/include/toomcook.h": "3cd9611f83bd1856489aff175360672fee4882477557cc61329f9e60a1b24a84",
+  "vendor/SMAUG-T/include/verify.h": "3d5c280a0086901eefc4db4968f7c4853cf55bfd18ec4aac1c560456c315c66a",
+  "vendor/SMAUG-T/src/cbd.c": "82a164cd7402991e8702529b8804c201780cb5c9e173bd54738843cf4dc5427b",
+  "vendor/SMAUG-T/src/ciphertext.c": "919b4467829f7c543635827d351e30ce8b8014ba5e21cb722c44ef7f14a6d6cf",
+  "vendor/SMAUG-T/src/dg.c": "a3c72cd81120116a2608546e07ce442c8d83445051c516e2418f5022f5afc2d3",
+  "vendor/SMAUG-T/src/fips202.c": "3d41e7232b4581edc2cc0de7a6c041e773aec5736877357e4d3dbe660a65e9bf",
+  "vendor/SMAUG-T/src/hash.c": "a7d236420ede30b6294bdc4bbdd6e51c019a1dca39ea237f7337f19dc0b11e08",
+  "vendor/SMAUG-T/src/hwt.c": "f9da5c27f970f32a9d2f31a284c3d6b1fead3c8081906dd811777784f4ffabe3",
+  "vendor/SMAUG-T/src/indcpa.c": "1573a412921e2131fa321340ea00aa7637ccd1a0356e7a95f89e05dc1a2a4c72",
+  "vendor/SMAUG-T/src/kem.c": "fc542541ab26c62dc1f8f7b7f97e0ded0ab7921891aa311118f13afb6ba76c3a",
+  "vendor/SMAUG-T/src/key.c": "8c74792dd136aa10af43b2e71ac96b73912ca2fe3f5868303a1d8cc69dd1fafb",
+  "vendor/SMAUG-T/src/pack.c": "9256679884b392d5d7d7266d6e5b2733183c6ed1839cc0cb1f4b8248bfbef61c",
+  "vendor/SMAUG-T/src/packring.c": "fb6307cab3c4d9fb995acb8d9f459aa80ede71bd2639f209b4c0d0391ab426e0",
+  "vendor/SMAUG-T/src/poly.c": "d482cad2391551f1cdf1ceb7e99a5794df926ac4adc50d57cd9303d0d448c0f7",
+  "vendor/SMAUG-T/src/toomcook.c": "e8461ed10944b7bbfc0cf4232556f8cbaeb91f72a952a94a6f20a7a4cc21e56e",
+  "vendor/SMAUG-T/src/verify.c": "6d345e8b02f603fe8b8954b3a51a1f8ede63eac292fe971e66ea6c9128aa3e98",
+  "vendor/NTRUplus/NTRU+1152/api.h": "76275b8a5ae938aaabe94342237eff64e9eaa7b048b3de110485cc4fb98b704e",
+  "vendor/NTRUplus/NTRU+1152/fips202/fips202.c": "4871baddebf2d4771d86b5088719123e2e43addce1a3c0eca75b4d18970ffc1f",
+  "vendor/NTRUplus/NTRU+1152/fips202/fips202.h": "bf99a54bc1988380418054a18bd5a14d059770e70c1aac23b6d9c914539168e0",
+  "vendor/NTRUplus/NTRU+1152/kem.c": "2cd1f9c393a7ff8c414efbda932153b765d80f39e59bfb7e9760aa83da239862",
+  "vendor/NTRUplus/NTRU+1152/ntt.c": "77c9807a9566f01cd9e2df3f94f871c4858e91f8cc820900fc56e438b89fddec",
+  "vendor/NTRUplus/NTRU+1152/ntt.h": "ff0a9a18927593738820592c162455963e363ed138693bd8eeb74d149f2b5af5",
+  "vendor/NTRUplus/NTRU+1152/params.h": "3caa8223ce95acd081a2300e53ecdb9145c5b16215b414602954d117c06d78bd",
+  "vendor/NTRUplus/NTRU+1152/poly.c": "b6b53a43839a8f627c54ef2e25f765a3cf92b3a4fa465ba1591177c58fd46200",
+  "vendor/NTRUplus/NTRU+1152/poly.h": "e4c1fbc5453464881dba450fb22cf56edf2a02d1b078d4f6c7206b283be1f105",
+  "vendor/NTRUplus/NTRU+1152/randombytes.h": "5ece412ed498abfd892ecec23480910b76cb8ea1b605da10adc5584ede79f048",
+  "vendor/NTRUplus/NTRU+1152/symmetric.c": "e46dee314ce9f0aab46eb905c6e2f99c91d6751898aa7f052e09ccda136f12c2",
+  "vendor/NTRUplus/NTRU+1152/symmetric.h": "4734a7c10345908b9a9c5ce60f83a068140689a7a629101941a03d07b409b5c1",
+  "vendor/NTRUplus/NTRU+768/api.h": "76275b8a5ae938aaabe94342237eff64e9eaa7b048b3de110485cc4fb98b704e",
+  "vendor/NTRUplus/NTRU+768/fips202/fips202.c": "4871baddebf2d4771d86b5088719123e2e43addce1a3c0eca75b4d18970ffc1f",
+  "vendor/NTRUplus/NTRU+768/fips202/fips202.h": "bf99a54bc1988380418054a18bd5a14d059770e70c1aac23b6d9c914539168e0",
+  "vendor/NTRUplus/NTRU+768/kem.c": "2cd1f9c393a7ff8c414efbda932153b765d80f39e59bfb7e9760aa83da239862",
+  "vendor/NTRUplus/NTRU+768/ntt.c": "457e13722b81aa2f38faf8d88f6f67e4b7c872804fa5c23d404f24adc643a457",
+  "vendor/NTRUplus/NTRU+768/ntt.h": "1edc2346f1705cc98af0f64b2f0ac974f3d58ab9b6603ebbfa415f4e135f5851",
+  "vendor/NTRUplus/NTRU+768/params.h": "420bef5432154798239e1f09b18f31947e3afff248ff98d4e83346b84d27ebb8",
+  "vendor/NTRUplus/NTRU+768/poly.c": "afb0bb56bbe7172b058ce1acf03adbb60fe14e726e21052c84324a7cf7e56e23",
+  "vendor/NTRUplus/NTRU+768/poly.h": "e4c1fbc5453464881dba450fb22cf56edf2a02d1b078d4f6c7206b283be1f105",
+  "vendor/NTRUplus/NTRU+768/randombytes.h": "5ece412ed498abfd892ecec23480910b76cb8ea1b605da10adc5584ede79f048",
+  "vendor/NTRUplus/NTRU+768/symmetric.c": "e46dee314ce9f0aab46eb905c6e2f99c91d6751898aa7f052e09ccda136f12c2",
+  "vendor/NTRUplus/NTRU+768/symmetric.h": "4734a7c10345908b9a9c5ce60f83a068140689a7a629101941a03d07b409b5c1",
+  "vendor/NTRUplus/NTRU+864/api.h": "76275b8a5ae938aaabe94342237eff64e9eaa7b048b3de110485cc4fb98b704e",
+  "vendor/NTRUplus/NTRU+864/fips202/fips202.c": "4871baddebf2d4771d86b5088719123e2e43addce1a3c0eca75b4d18970ffc1f",
+  "vendor/NTRUplus/NTRU+864/fips202/fips202.h": "bf99a54bc1988380418054a18bd5a14d059770e70c1aac23b6d9c914539168e0",
+  "vendor/NTRUplus/NTRU+864/kem.c": "2cd1f9c393a7ff8c414efbda932153b765d80f39e59bfb7e9760aa83da239862",
+  "vendor/NTRUplus/NTRU+864/ntt.c": "e71c8e5eacbbae2d702ae8bb12eb77b34bd8a53fa1ed61cb3c517e1fcefb091d",
+  "vendor/NTRUplus/NTRU+864/ntt.h": "7af0edccfb9778b06472f26fe92641aa66eb86e4fb20872dd01d85b1affd43af",
+  "vendor/NTRUplus/NTRU+864/params.h": "39618b1552ab1f1f259ec2733211bca127b72948cec860563c1abe06ea132b50",
+  "vendor/NTRUplus/NTRU+864/poly.c": "fd23f07293637685058fb5286fc82984ea4d97f06405e9a280e9a6e52c051992",
+  "vendor/NTRUplus/NTRU+864/poly.h": "e4c1fbc5453464881dba450fb22cf56edf2a02d1b078d4f6c7206b283be1f105",
+  "vendor/NTRUplus/NTRU+864/randombytes.h": "5ece412ed498abfd892ecec23480910b76cb8ea1b605da10adc5584ede79f048",
+  "vendor/NTRUplus/NTRU+864/symmetric.c": "e46dee314ce9f0aab46eb905c6e2f99c91d6751898aa7f052e09ccda136f12c2",
+  "vendor/NTRUplus/NTRU+864/symmetric.h": "4734a7c10345908b9a9c5ce60f83a068140689a7a629101941a03d07b409b5c1"
+}