polynomial unit tests

Author: enum-class

CMakeLists.txt

@@ -19,7 +19,11 @@ set(CMAKE_EXPORT_COMPILE_COMMANDS On)
 add_compile_options(-Wall -Wextra -pedantic -Werror)
 
 set(SOURCE_FILES
-    ${CMAKE_CURRENT_SOURCE_DIR}/src/Aces.c
+    #${CMAKE_CURRENT_SOURCE_DIR}/src/Aces.c
+    #${CMAKE_CURRENT_SOURCE_DIR}/src/Channel.c
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/Common.c
+    #${CMAKE_CURRENT_SOURCE_DIR}/src/Operations.c
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/Polynomial.c
 )
 
 add_library(CAces STATIC ${SOURCE_FILES})
@@ -36,7 +40,7 @@ if (CACES_BENCHMARK)
     add_subdirectory(benchmarks)
 endif()
 
-if (CACES_TESTS)
+if (CACES_TEST)
     add_subdirectory(tests)
 endif()
 

lib/Aces.h

@@ -10,39 +10,37 @@ extern "C" {
 
 #define EPROB 0.5
 
-typename struct {
+typedef struct {
   Polynomial u;
   Lambda lambda;
 } PublicKey;
 
-typename struct {
+typedef struct {
   PolyArray x;
   PolyArray f0;
   Polynomial f1;
 } PrivateKey;
 
-typename struct {
+typedef struct {
   Channel channel;
   Parameters param;
   PublicKey pk;
 } SharedInfo;
 
-typename struct {
+typedef struct {
   SharedInfo info;
   PrivateKey privte_key;
 } Aces;
 
-typename struct {
+typedef struct {
   PolyArray c1;
   Polynomial c2;
   uint64_t level;
 } CipherMessage;
 
-int aces_encrypt(const Aces *aces, const uint64_t *message, size_t size,
-                 CipherMessage *result);
+int aces_encrypt(const Aces *, const uint64_t *, size_t, CipherMessage *);
 
-int aces_decrypt(const Aces *aces, const CipherMessage *message, size_t size,
-                 uint64_t *message);
+int aces_decrypt(const Aces *, const CipherMessage *, size_t size, uint64_t *);
 
 #ifdef __cplusplus
 }

lib/Channel.h

@@ -3,33 +3,33 @@
 
 #include "Polynomial.h"
 
-typename struct {
+typedef struct {
   uint64_t dim;
   uint64_t N;
 } Parameters;
 
-typename struct {
+typedef struct {
   uint64_t p;
   uint64_t q;
   uint64_t w;
 } Channel;
 
-typename struct {
+typedef struct {
   uint64_t ***lambda;
   size_t size[3];
 } Lambda;
 
-int init_channel(Channel *channel, uint64_t p, uint64_t q, uint64_t w);
+int init_channel(Channel *, uint64_t, uint64_t, uint64_t);
 
-int generate_u(const Channel *channel, const Parameters *param, Polynomial *u);
+int generate_u(const Channel *, const Parameters *, Polynomial *);
 
-int generate_secret(const Channel *channel, const Parameters *param,
-                    const Polynomial *u, PolyArray *secret, Lambda *lambda);
+int generate_secret(const Channel *, const Parameters *, const Polynomial *,
+                    PolyArray *, Lambda *);
 
-int generate_f0(const Channel *channel, const Parameters *param, PolyArray *f0);
+int generate_f0(const Channel *, const Parameters *, PolyArray *);
 
-int generate_f1(const Channel *channel, const Parameters *param,
-                const PolyArray *f0, const PolyArray *x, Polynomial *f1);
+int generate_f1(const Channel *, const Parameters *, const PolyArray *,
+                const PolyArray *, Polynomial *);
 
 #ifdef __cplusplus
 }

lib/Common.h

@@ -5,29 +5,39 @@
 extern "C" {
 #endif
 
+#include <stdint.h>
+
 // gcd = ax + by
-typename struct {
+typedef struct {
   uint64_t gcd;
   int64_t a;
   int64_t b;
 } Xgcd;
 
+typedef struct {
+  uint64_t first;
+  uint64_t second;
+} Pair;
+
 uint64_t gcd(uint64_t x, uint64_t y);
 
 Xgcd xgcd(uint64_t a, uint64_t b);
 
 int are_coprime(uint64_t x, uint64_t y);
 
-randinverse(uint64_t value);
-factors(uint64_t value);
+Pair randinverse(uint64_t value);
+
+uint64_t randrange(uint64_t lower, uint64_t upper);
+// factors(uint64_t value);
 
 uint64_t normal_rand(double mean, double stddev);
 
-uint64_t max(uint64_t a, uint64_t b) { a > b ? a : b; }
+static inline uint64_t max(uint64_t a, uint64_t b) { return a > b ? a : b; }
 
-uint64_t min(uint64_t a, uint64_t b) { a < b ? a : b; }
+static inline uint64_t min(uint64_t a, uint64_t b) { return a < b ? a : b; }
 
-uint64_t clamp(uint64_t min_value, uint64_t max_value, uint64_t value) {
+static inline uint64_t clamp(uint64_t min_value, uint64_t max_value,
+                             uint64_t value) {
   return max(min_value, min(max_value, value));
 }
 

lib/Operations.h

@@ -1,13 +1,15 @@
 #ifndef OPERATIONS_H
 #define OPERATIONS_H
 
-int aces_add(const CipherMessage *a, const CipherMessage *b,
-             const SharedInfo *info, CipherMessage *result);
+#include "Aces.h"
 
-int aces_mul(const CipherMessage *a, const CipherMessage *b,
-             const SharedInfo *info, CipherMessage *result);
+int aces_add(const CipherMessage *, const CipherMessage *, const SharedInfo *,
+             CipherMessage *);
 
-int aces_refresh(CipherMessage *a, uint64_t k);
+int aces_mul(const CipherMessage *, const CipherMessage *, const SharedInfo *,
+             CipherMessage *);
+
+int aces_refresh(CipherMessage *, uint64_t);
 
 #ifdef __cplusplus
 }

lib/Polynomial.h

@@ -5,35 +5,55 @@
 extern "C" {
 #endif
 
-typename uint64_t Coeff;
+#include <stddef.h>
+#include <stdint.h>
 
-typename struct {
+typedef uint64_t Coeff;
+
+typedef struct {
   Coeff *coeffs;
   size_t size;
 } Polynomial;
 
-typename struct {
-  Polynomial *secret;
+typedef struct {
+  Polynomial *polies;
   size_t size;
 } PolyArray;
 
+int poly_equal(const Polynomial *, const Polynomial *);
+void poly_free(Polynomial *poly);
+
+int set_polynomial(Polynomial *p, Coeff *coeffs, size_t size);
+
+int get_polynomial(Polynomial *p, size_t size);
+
+int get_polyarray(PolyArray *p, size_t size);
+
+int set_zero(const Polynomial *);
+
 uint64_t coef_sum(const Polynomial *);
 
 uint64_t poly_degree(const Polynomial *);
 
-int poly_fit(const Polynomial *poly, uint64_t mod);
+int poly_fit(Polynomial *poly, uint64_t mod);
 
 int poly_mul(const Polynomial *poly1, const Polynomial *poly2,
              Polynomial *result, uint64_t mod);
 
 int poly_add(const Polynomial *poly1, const Polynomial *poly2,
              Polynomial *result, uint64_t mod);
 
+int poly_sub(const Polynomial *poly1, const Polynomial *poly2,
+             Polynomial *result, uint64_t mod);
+
 int poly_lshift(const Polynomial *poly1, const Polynomial *poly2,
                 Polynomial *result, uint64_t mod);
 
-int poly_mod(const Polynomial *poly1, const Polynomial *poly2,
-             Polynomial *result, uint64_t mod);
+int poly_mod(Polynomial *, const Polynomial *, uint64_t);
+
+int poly_sub_scaler(const Polynomial *, uint64_t, Polynomial *, uint64_t);
+
+int poly_add_scaler(const Polynomial *, uint64_t, Polynomial *, uint64_t);
 
 #ifdef __cplusplus
 }

src/Aces.c

@@ -1,31 +1,36 @@
 #include "Aces.h"
+#include "Common.h"
+#include <stddef.h>
 
 static int generate_error(uint64_t q, uint64_t dim, uint64_t message,
                           Polynomial *rm) {
   for (int i = 0; i < rm->size; ++i)
     rm->coeffs[i] = randrange(0, q);
 
-  rm->coeffs[0] += m - sum(rm);
+  // rm->coeffs[0] += m - sum(rm);
   rm->coeffs[0] %= q;
+  return 0;
 }
 
-static ssize_t generate_vanisher(uint64_t p, uint64_t q, uint64_t dim,
-                                 Polynomial *e) {
+static uint64_t generate_vanisher(uint64_t p, uint64_t q, uint64_t dim,
+                                  Polynomial *e) {
   uint64_t k = randrange(0, 1) < EPROB ? 0 : 1;
-  for (int i = 0; i < rm->size; ++i)
+  for (int i = 0; i < e->size; ++i)
     e->coeffs[i] = randrange(0, q);
 
   e->coeffs[0] += p * k - sum(e);
   e->coeffs[0] %= q;
+  return k;
 }
 
-static ssize_t generate_linear(uint64_t p, uint64_t q, uint64_t dim,
-                               Polynomial *b) {
+static uint64_t generate_linear(uint64_t p, uint64_t q, uint64_t dim,
+                                Polynomial *b) {
   uint64_t k = randrange(0, p);
-  for (int i = 0; i < rm->size; ++i)
+  for (int i = 0; i < b->size; ++i)
     b->coeffs[i] = randrange(0, q);
-  b->coeffs[0] += k - sum(e);
+  b->coeffs[0] += k - sum(b);
   b->coeffs[0] %= q;
+  return k;
 }
 
 int aces_encrypt(const Aces *aces, const uint64_t *message, size_t size,
@@ -35,37 +40,43 @@ int aces_encrypt(const Aces *aces, const uint64_t *message, size_t size,
   Polynomial b;
 
   for (int i = 0; i < size; ++i) {
-    generate_error(aces->info.channel.q, aces->info.param.dim, message[i], &rm);
+    generate_error(aces->info.channel.q, aces->info.param.dim, message[i],
+                   &r_m);
     uint64_t k = generate_vanisher(aces->info.channel.p, aces->info.channel.q,
                                    aces->info.param.dim, &e);
     generate_linear(aces->info.channel.p, aces->info.channel.q,
                     aces->info.param.dim, &b);
 
     for (int j = 0; j < aces->info.param.dim; ++j) {
-      poly_mul(b, aces->privte_key.f0[j], result[i].c1[j]);
-      poly_mod(result[i].c1[j], aces->info.pk.u, result[i].c1[j]);
+      poly_mul(&b, &(aces->privte_key.f0.polys[j]), &(result[i].c1.polys[j]),
+               aces->info.channel.q);
+      poly_mod(&(result[i].c1.polys[j]), &(aces->info.pk.u),
+               &(result[i].c1.polys[j]), aces->info.channel.q);
     }
 
-    result[i].c2 = (r_m + b * (self.f1 + e)) % self.u; // TODO
+    // result[i].c2 = (r_m + b * (self.f1 + e)) % self.u; // TODO
     result[i].level = k * sum(b) % aces->info.channel.q;
   }
+
+  return 0;
 }
 
 int aces_decrypt(const Aces *aces, const CipherMessage *message, size_t size,
                  uint64_t *result) {
   Polynomial c0Tx;
   Polynomial tmp;
   Polynomial m_pre;
-  set_zero(c0Tx);
+  set_zero(&c0Tx);
 
   for (int i = 0; i < size; ++i) {
     for (int j = 0; j < aces->info.param.dim; ++j) {
-      poly_mul(message[i].c1[j], aces->privte_key.x[j], tmp);
-      poly_add(c0Tx, tmp, c0Tx);
+      poly_mul(&(message[i].c1.polys[j]), &(aces->privte_key.x.polys[j]), &tmp,
+               aces->info.channel.q);
+      poly_add(&c0Tx, &tmp, &c0Tx, aces->info.channel.q);
     }
 
-    poly_sub(message[i].c2, c0Tx, m_pre);
-    result[i] = (sum(m_pre) % q) % p;
+    poly_sub(&(message[i].c2), &c0Tx, &m_pre, aces->info.channel.q);
+    result[i] = (sum(m_pre) % aces->info.channel.q) % aces->info.channel.p;
   }
 
   return 0;

src/Channel.c

@@ -1,3 +1,5 @@
+#include "Channel.h"
+
 int init_channel(Channel *channel, uint64_t p, uint64_t q, uint64_t w) {
   channel->w = w;
   channel->p = p;