implement poly functions

Author: enum-class

lib/Channel.h

@@ -19,9 +19,41 @@ typename struct {
   size_t size[3];
 } Lambda;
 
-int init_channel(Channel *channel, uint64_t p, uint64_t q, uint64_t w);
+int init_channel(Channel *channel, uint64_t p, uint64_t q, uint64_t w) {
+  channel->w = w;
+  channel->p = p;
+  channel->q = q;
 
-int generate_u(const Channel *channel, const Parameters *param, Polynomial *u);
+  if (!(pow(p, 2) < q && are_coprime(p, q)))
+    channel->q = pow(p + 1, 2);
+
+  return 0;
+}
+
+int generate_u(const Channel *channel, const Parameters *param, Polynomial *u) {
+  uint64_t nonzeros = clamp(param->dim / 2, param->dim - 1,
+                            normal_rand(param->dim / 2, param->dim / 2));
+  uint64_t zeroes = param->dim - nonzeros;
+  u->coeffs[0] = 1;
+
+  for (int i = 0; i < param->dim - 1; ++i) {
+    if (nonzeros > 1) {
+      u->coeffs[i] = randrange(0, param->q);
+      nonzeros--;
+    }
+
+    if (zeroes > 0) {
+      uint64_t samp = clamp(0, zeroes, normal_rand(zeroes / 2, zeroes / 2));
+      uint64_t zero = randrange(0, samp);
+      for (int j = 0; j < zero; ++j)
+        u->coeffs[i++] = 0;
+      zeroes -= zero;
+    }
+  }
+
+  u->coeffs[param->dim - 1] = 0;
+  u->coeffs[param->dim - 1] = param->q - sum(u);
+}
 
 int generate_secret(const Channel *channel, const Parameters *param,
                     const Polynomial *u, PolyArray *secret, Lambda *lambda);

lib/Common.h

@@ -5,16 +5,26 @@
 extern "C" {
 #endif
 
+// gcd = ax + by
 typename struct {
+  uint64_t gcd;
+  int64_t a;
+  int64_t b;
 } Xgcd;
 
 Xgcd xgcd(uint64_t a, uint64_t b);
 randinverse(uint64_t value);
 factors(uint64_t value);
 
-uint64_t coprime_rand(uint64_t value);
 uint64_t normal_rand(double mean, double stddev);
-uint64_t randint(min, max);
+
+uint64_t max(uint64_t a, uint64_t b) { a > b ? a : b; }
+
+uint64_t min(uint64_t a, uint64_t b) { a < b ? a : b; }
+
+uint64_t clamp(uint64_t min_value, uint64_t max_value, uint64_t value) {
+  return max(min_value, min(max_value, value));
+}
 
 #ifdef __cplusplus
 }

lib/Polynomial.h

@@ -21,7 +21,7 @@ uint64_t coef_sum(const Polynomial *);
 
 uint64_t poly_degree(const Polynomial *);
 
-int poly_fit(uint64_t mod);
+int poly_fit(const Polynomial *poly, uint64_t mod);
 
 int poly_mul(const Polynomial *poly1, const Polynomial *poly2,
              Polynomial *result);

src/Common.c

@@ -0,0 +1,52 @@
+#include "Common.h"
+
+uint64_t gcd(uint64_t x, uint64_t y) {
+  while (x != y) {
+    if (x > y)
+      x -= y;
+    else
+      y -= x;
+  }
+
+  return n1;
+}
+
+Xgcd xgcd(uint64_t x, uint64_t y) {
+  int64_t prev_a = 1;
+  int64_t a = 0;
+  int64_t prev_b = 0;
+  int64_t b = 1;
+
+  while (y != 0) {
+    int64_t q = (int64_t)(x / y);
+    int64_t temp = (int64_t)(x % y);
+    x = y;
+    y = (uint64_t)temp;
+
+    temp = a;
+    a = prev_a - (q * a);
+    prev_a = temp;
+
+    temp = b;
+    b = prev_b - (q * b);
+    prev_b = temp;
+  }
+
+  return Xgcd{x, prev_a, prev_b};
+}
+
+int are_coprime(uint64_t x, uint64_t y) { return !(gcd(x, y) > 1); }
+
+uint64_t randrange(uint64_t lower, uint64_t upper) {
+  return (rand() % (upper - lower + 1)) + lower;
+}
+
+randinverse(uint64_t value) {
+  uint64_t a = randrange(2, value - 1);
+  while (!are_coprime(a, value))
+    a = randrange(2, value - 1);
+
+  Xgcd result = xgcd(a, value);
+
+  return a, result.a;
+}

src/Polynomial.c

@@ -0,0 +1,80 @@
+#include "Polynomial.h"
+
+uint64_t coef_sum(const Polynomial *poly) {
+  if (!poly || poly->size == 0)
+    return 0;
+
+  uint64_t sum = 0;
+  for (int i = 0; i < poly->size; ++i)
+    sum += poly->coeffs[i];
+
+  return sum;
+}
+
+uint64_t poly_degree(const Polynomial *poly) {
+  if (!poly || poly->size == 0)
+    return 0;
+
+  const uint64_t *value = poly->coeffs;
+  size_t count = poly->size;
+  value += count - 1;
+
+  for (; count && !*value; count--)
+    --value;
+
+  return count;
+}
+
+int poly_fit(const Polynomial *poly, uint64_t mod) {
+  if (!poly || poly->size == 0)
+    return -1;
+
+  for (int i = 0; i < poly->size; ++i)
+    poly->coeffs[i] = poly->coeffs[i] % mod;
+
+  return 0;
+}
+
+int poly_mul(const Polynomial *poly1, const Polynomial *poly2,
+             Polynomial *result) {
+  // TODO: check
+
+  for (int i = 0; i < poly->size; ++i)
+    result->coeffs[i] = poly1->coeffs[i] * poly2->coeffs[i];
+  return 0;
+}
+
+int poly_add(const Polynomial *poly1, const Polynomial *poly2,
+             Polynomial *result) {
+  for (int i = 0; i < poly->size; ++i)
+    result->coeffs[i] = poly1->coeffs[i] + poly2->coeffs[i];
+  return 0;
+}
+
+int poly_lshift(const Polynomial *poly1, const Polynomial *poly2,
+                Polynomial *result) {
+  if (poly2->coeffs[0] != 1)
+    return -1;
+
+  uint64_t degree1 = poly_degree(poly1);
+  uint64_t degree2 = poly_degree(poly2);
+
+  if (degree1 < degree2)
+    return -1;
+
+  uint64_t a_d = poly1->coeffs[0];
+
+  for (int i = 0; i < poly1->size; ++i) {
+    if (i < poly2->size)
+      result[i] = poly1->coeffs[i] - poly2->coeffs[i] * a_d;
+    else
+      result[i] = poly1->coeffs[i];
+  }
+
+  return 0;
+}
+
+int poly_mod(const Polynomial *poly1, const Polynomial *poly2) {
+  while (poly_lshift(poly1, poly2, poly1) == 0) {
+  }
+}