channel tests

Author: enum-class

lib/Channel.h

@@ -1,6 +1,7 @@
 #ifndef CHANNEL_H
 #define CHANNEL_H
 
+#include "Common.h"
 #include "Polynomial.h"
 
 typedef struct {
@@ -15,10 +16,12 @@ typedef struct {
 } Channel;
 
 typedef struct {
-  uint64_t ***lambda;
-  size_t size[3];
+  Matrix2D *data;
+  size_t size;
 } Lambda;
 
+Matrix2D *lambda_get(Lambda *lambda, size_t idx);
+
 int init_channel(Channel *, uint64_t, uint64_t, uint64_t);
 
 int generate_u(const Channel *, const Parameters *, Polynomial *);

lib/Common.h

@@ -5,8 +5,11 @@
 extern "C" {
 #endif
 
+#include <stddef.h>
 #include <stdint.h>
 
+#define TRANSFORM_COUNT 3
+
 // gcd = ax + by
 typedef struct {
   uint64_t gcd;
@@ -19,6 +22,26 @@ typedef struct {
   uint64_t second;
 } Pair;
 
+typedef struct {
+  size_t dim;
+  uint64_t *data;
+} Matrix2D;
+
+static inline uint64_t *matrix2d_row(Matrix2D *matrix, size_t row) {
+  return matrix->data + row * matrix->dim;
+}
+
+static inline uint64_t matrix2d_get(Matrix2D *matrix, size_t row, size_t col) {
+  size_t dim = matrix->dim;
+  return matrix->data[row * dim + col];
+}
+
+static inline void matrix2d_set(Matrix2D *matrix, size_t row, size_t col,
+                                uint64_t value) {
+  size_t dim = matrix->dim;
+  matrix->data[row * dim + col] = value;
+}
+
 uint64_t gcd(uint64_t x, uint64_t y);
 
 Xgcd xgcd(uint64_t a, uint64_t b);
@@ -28,7 +51,6 @@ int are_coprime(uint64_t x, uint64_t y);
 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);
 
@@ -41,13 +63,18 @@ static inline uint64_t clamp(uint64_t min_value, uint64_t max_value,
   return max(min_value, min(max_value, value));
 }
 
-int fill_inv_random(size_t dim, uint64_t m[dim][dim], inv_m[dim][dim]);
+int matrix2d_multiply(Matrix2D *m, Matrix2D *invm, Matrix2D *result,
+                      uint64_t mod);
 
-int random_swap_transform(size_t dim, uint64_t m[dim][dim]) {}
+typedef int (*Transformer)(Matrix2D *m, Matrix2D *invm, uint64_t mod);
 
-int random_multiply_transform(size_t dim, uint64_t m[dim][dim]) {}
+int swap_transform(Matrix2D *m, Matrix2D *invm, uint64_t mod);
+int linear_mix_transform(Matrix2D *m, Matrix2D *invm, uint64_t mod);
+int scale_transform(Matrix2D *m, Matrix2D *invm, uint64_t mod);
 
-int random_linear_transform(size_t dim, uint64_t m[dim][dim]) {}
+int matrix2d_eye(Matrix2D *m);
+int fill_random_invertible_pairs(Matrix2D *m, Matrix2D *invm, uint64_t mod,
+                                 size_t iterations);
 
 #ifdef __cplusplus
 }

src/Channel.c

@@ -2,8 +2,6 @@
 
 #include <math.h>
 
-#include "Common.h"
-
 int init_channel(Channel *channel, uint64_t p, uint64_t q, uint64_t w) {
   channel->w = w;
   channel->p = p;
@@ -15,6 +13,8 @@ int init_channel(Channel *channel, uint64_t p, uint64_t q, uint64_t w) {
   return 0;
 }
 
+Matrix2D *lambda_get(Lambda *lambda, size_t idx) { return &lambda->data[idx]; }
+
 int generate_u(const Channel *channel, const Parameters *param, Polynomial *u) {
   uint64_t nonzeros = randrange(
       param->dim / 2,
@@ -48,17 +48,46 @@ int generate_u(const Channel *channel, const Parameters *param, Polynomial *u) {
 
 int generate_secret(const Channel *channel, const Parameters *param,
                     const Polynomial *u, PolyArray *secret, Lambda *lambda) {
-  uint64_t m[param.dim][param.dim];
-  uint64_t inv_m[param.dim][param.dim];
-  fill_inv_random(m, inv_m, param.dim);
-  //
-  //  for (int i = 0; i < secret->size; ++i) {
-  //    for (int j = 0; j < secret[i]->size; ++j) {
-  //      secret[i][j] = m[j][i];
-  //    }
-  //  }
+  Matrix2D m;
+  Matrix2D invm;
+
+  m.dim = param->dim;
+  invm.dim = param->dim;
+
+  size_t required_mem = m.dim * m.dim;
+  uint64_t mem[2 * required_mem];
+  m.data = mem;
+  invm.data = mem + required_mem;
+
+  fill_random_invertible_pairs(&m, &invm, channel->q, 600);
+
+  secret->size = m.dim;
+  for (int i = 0; i < m.dim; ++i) {
+    for (int j = 0; j < m.dim; ++j) {
+      secret->polies[i].coeffs[j] = matrix2d_get(&m, j, i); // m[j][i];
+    }
+  }
 
-  // TODO:
+  Matrix2D *arr = &m;
+  Polynomial a_ij_poly; // TODO:
+
+  Coeff miim[2 * secret->size];
+
+  for (int i = 0; i < secret->size; ++i) {
+    for (int j = 0; j < secret->size; ++j) {
+      set_polynomial(&a_ij_poly, miim, 2 * secret->size);
+      poly_mul(&secret->polies[i], &secret->polies[j], &a_ij_poly, channel->q);
+      poly_mod(&a_ij_poly, u, channel->q);
+
+      for (int row = 0; row < arr->dim; row++) {
+        matrix2d_set(arr, row, j, a_ij_poly.coeffs[arr->dim - row - 1]);
+      }
+    }
+
+    matrix2d_multiply(&invm, arr, lambda_get(lambda, i), channel->q);
+  }
+
+  return 0;
 }
 
 int generate_f0(const Channel *channel, const Parameters *param,

src/Common.c

@@ -1,6 +1,7 @@
 #include "Common.h"
 
 #include <stdlib.h>
+#include <string.h>
 
 uint64_t normal_rand(double mean, double stddev) {
   // TODO:
@@ -58,10 +59,100 @@ Pair randinverse(uint64_t value) {
 
   Xgcd result = xgcd(a, value);
 
-  Pair p = {.first = a, .second = result.a};
+  Pair p = {.first = a, .second = result.a > 0 ? result.a : result.a + value};
   return p;
 }
 
-// factors(uint64_t value) {
-//   // TODO:
-// }
+int matrix2d_multiply(Matrix2D *m, Matrix2D *invm, Matrix2D *result,
+                      uint64_t mod) {
+  size_t dim = m->dim;
+  for (int i = 0; i < dim; i++) {
+    for (int j = 0; j < dim; j++) {
+      matrix2d_set(result, i, j, 0);
+      for (int k = 0; k < dim; k++) {
+        matrix2d_set(result, i, j,
+                     matrix2d_get(result, i, j) +
+                         matrix2d_get(m, i, k) * matrix2d_get(invm, k, j));
+      }
+      matrix2d_set(result, i, j, matrix2d_get(result, i, j) % mod);
+    }
+  }
+
+  return 0;
+}
+
+int swap_transform(Matrix2D *m, Matrix2D *invm, uint64_t mod) {
+  size_t dim = m->dim;
+  uint64_t tmp;
+  uint64_t tmp_row[dim];
+
+  size_t source = randrange(1, dim - 1);
+  size_t target = randrange(0, source - 1);
+
+  for (size_t row = 0; row < dim; ++row) {
+    tmp = matrix2d_get(m, row, source);
+    matrix2d_set(m, row, source, matrix2d_get(m, row, target));
+    matrix2d_set(m, row, target, tmp);
+  }
+
+  memcpy(tmp_row, matrix2d_row(invm, source), sizeof(uint64_t) * dim);
+  memcpy(matrix2d_row(invm, source), matrix2d_row(invm, target),
+         sizeof(uint64_t) * dim);
+  memcpy(matrix2d_row(invm, target), tmp_row, sizeof(uint64_t) * dim);
+
+  return 0;
+}
+
+int scale_transform(Matrix2D *m, Matrix2D *invm, uint64_t mod) {
+  size_t dim = m->dim;
+  Pair scale = randinverse(mod);
+  for (size_t idx = 0; idx < dim * dim; ++idx) {
+    m->data[idx] = (m->data[idx] * scale.first) % mod;
+    invm->data[idx] = (invm->data[idx] * scale.second) % mod;
+  }
+  return 1;
+}
+
+int linear_mix_transform(Matrix2D *m, Matrix2D *invm, uint64_t mod) {
+  size_t dim = m->dim;
+  size_t scale = randrange(1, mod - 1);
+  size_t source = randrange(1, dim - 1);
+  size_t target = randrange(0, source - 1);
+
+  for (size_t row = 0; row < dim; ++row) {
+    matrix2d_set(
+        m, row, target,
+        (matrix2d_get(m, row, target) + matrix2d_get(m, row, source) * scale) %
+            mod);
+    matrix2d_set(invm, source, row,
+                 (matrix2d_get(invm, source, row) +
+                  matrix2d_get(invm, target, row) * (mod - scale)) %
+                     mod);
+  }
+
+  return 0;
+}
+
+int matrix2d_eye(Matrix2D *m) {
+  size_t dim = m->dim;
+  memset(m->data, 0, dim * dim * sizeof(uint64_t));
+
+  for (size_t row = 0; row < dim; ++row)
+    matrix2d_set(m, row, row, 1);
+
+  return 0;
+}
+
+int fill_random_invertible_pairs(Matrix2D *m, Matrix2D *invm, uint64_t mod,
+                                 size_t iterations) {
+  const Transformer transformers[TRANSFORM_COUNT] = {
+      &swap_transform, &scale_transform, &linear_mix_transform};
+
+  matrix2d_eye(m);
+  matrix2d_eye(invm);
+
+  for (int i = 0; i < iterations; ++i) {
+    size_t select = randrange(0, TRANSFORM_COUNT - 1);
+    transformers[select](m, invm, mod);
+  }
+}

src/Polynomial.c

@@ -139,6 +139,7 @@ int poly_lshift(const Polynomial *poly1, const Polynomial *poly2,
       result->coeffs[i] = poly1->coeffs[i];
   }
 
+  poly_fit(result, mod);
   return 0;
 }
 

tests/CMakeLists.txt

@@ -3,6 +3,7 @@ find_package(Threads REQUIRED)
 set(TESTS_SOURCES
     polynomial-test.c
     channel-test.c
+    common-test.c
     main-test.c
 )
 

tests/channel-test.c

@@ -4,7 +4,6 @@
 #include <Polynomial.h>
 
 #include <assert.h>
-#include <stdio.h>
 
 int generate_u_test() {
   Polynomial u;
@@ -41,18 +40,48 @@ int generate_f0_test() {
   param.dim = 10;
 
   generate_f0(&channel, &param, &f0);
-  for (int i = 0; i < 10; i++) {
-    for (int j = 0; j < 10; j++) {
-      printf("%ld\t", f0.polies[i].coeffs[j]);
-    }
-    printf("\n");
+
+  return 1;
+}
+
+int generate_secret_test() {
+  Channel channel;
+  init_channel(&channel, 2, 33, 1);
+
+  Parameters param;
+  param.dim = 10;
+
+  Coeff mem_u[11];
+  Polynomial u;
+  set_polynomial(&u, mem_u, 11);
+  set_zero(&u);
+  generate_u(&channel, &param, &u);
+
+  Polynomial polies[10];
+  Coeff mem_secret[10][10];
+  for (int i = 0; i < 10; ++i)
+    set_polynomial(&polies[i], mem_secret[i], 10);
+  PolyArray secret;
+  secret.size = 10;
+  secret.polies = polies;
+
+  Matrix2D data[10];
+  uint64_t mem_lambda[10][100];
+  for (int i = 0; i < 10; ++i) {
+    data[i].data = mem_lambda[i];
+    data[i].dim = 10;
   }
+  Lambda lambda;
+  lambda.size = 10;
+  lambda.data = data;
 
+  generate_secret(&channel, &param, &u, &secret, &lambda);
   return 1;
 }
 
 int run_channel_tests() {
   assert(generate_u_test());
   assert(generate_f0_test());
+  assert(generate_secret_test());
   return 1;
 }