README update, add set_aces

Author: enum-class

README.md

@@ -1,7 +1,7 @@
-# c-aces
+# C-ACES
 
 ## Overview
-c-aces is a C implementation of [ACES](https://arxiv.org/pdf/2401.13255.pdf) (Arithmetic Channel Encryption Scheme), a novel cryptosystem constructed using category theory, specifically leveraging the Yoneda Lemma. ACES eliminates the need for bootstrapping techniques, offering a more efficient and secure Fully Homomorphic Encryption (FHE) scheme.
+**C-ACES** is a C implementation of [ACES](https://arxiv.org/pdf/2401.13255.pdf) (Arithmetic Channel Encryption Scheme), a novel cryptosystem constructed using **category theory**, specifically leveraging the **Yoneda Lemma**. ACES eliminates the need for bootstrapping techniques, offering a more efficient and secure **Fully Homomorphic Encryption (FHE) scheme**.
 
 This repository provides a practical and efficient implementation of ACES in C, enabling experimentation and integration into various systems requiring secure computations.
 It serves as an educational and experimental endeavor for exploring the implementation of ACES.
@@ -10,10 +10,51 @@ Please note that a Python implementation of ACES is already available, For addit
 
 
 ## Getting Started
-### Prerequisites
-C compiler compatible with C11 standard.
+### Prerequisites                          
+- CMake (version 3.16 or higher)                               
+- A C compiler that supports C11 (e.g., GCC or Clang)         
+
 ### Building
-### Usage
+1. Clone the Cring repository to your local machine:            
+```bash   
+   git clone https://github.com/your-username/Cring.git       
+```
+2. build
+```bash
+  cmake -B Release -DCRING_EXAMPLE=ON -DCRING_TEST=ON .
+  cmake --build Release
+```
+### Examples
+Here's a simple example of using C-ACES to do FHE operations:
+```c
+// initialize aces with proper parameters
+Aces aces;
+set_aces(&aces, DIM, memory, MEMORY_SIZE);
+init_aces(2/*p*/, 33/*q*/, DIM, &aces);
+
+// encrypt message 1
+uint64_t message_1 = 4;
+CipherMessage encrypted_message_1;
+aces_encrypt(&aces, &message_1, 1, &encrypted_message_1);
+
+// encrypt message 2
+uint64_t message_2 = 3;
+CipherMessage encrypted_message_2;
+aces_encrypt(&aces, &message_1, 1, &encrypted_message_1);
+
+uint64_t message_result;
+CipherMessage encrypted_result;
+
+// add encrypted_message_1 and encrypted_message_2
+aces_add(&encrypted_message_1, &encrypted_message_2, &aces.shared_info, &encrypted_result);
+
+// decrypt result
+aces_decrypt(&aces, &encrypted_result, 1, &message_result);
+
+uint64_t expected_result = (message_1 + message_2) % 2/*p*/;
+assert(expected_result == message_result);
+``` 
+For more usage examples, explore the [examples](examples) folder.
 
 ## References
 

examples/CMakeLists.txt

@@ -1,7 +1,7 @@
 find_package(Threads REQUIRED)
 
 set(EXAMPLE1_SOURCES
-    examples/aces_encrypt_decrypt.c
+    aces_encrypt_decrypt.c
 )
 
 add_executable(run_example1 ${EXAMPLE1_SOURCES})

examples/aces_encrypt_decrypt.c

@@ -5,49 +5,14 @@
 #include <time.h>
 
 #define DIM 10
+#define MEMORY_SIZE 2 << 14
 
 int main() {
-  srand(time(NULL));
-  Aces aces;
-
-  /** shared_info **/
-  // initialize U
-  Coeff u_mem[DIM + 1];
-  set_polynomial(&aces.shared_info.pk.u, u_mem, DIM + 1);
-
-  // initialize lambda
-  uint64_t lambda_mem[DIM][DIM * DIM];
-  Matrix2D lambda_mat[DIM];
-  for (int i = 0; i < DIM; ++i) {
-    lambda_mat[i].dim = DIM;
-    lambda_mat[i].data = lambda_mem[i];
-  }
-  aces.shared_info.pk.lambda.size = DIM;
-  aces.shared_info.pk.lambda.data = lambda_mat;
-
-  /** private_key **/
-  // initialize x
-  Coeff x_mem[DIM][DIM];
-  Polynomial x_polies[DIM];
-  for (int i = 0; i < DIM; ++i) {
-    set_polynomial(&x_polies[i], x_mem[i], DIM);
-  }
-  aces.private_key.x.size = DIM;
-  aces.private_key.x.polies = x_polies;
-
-  // initialize f0
-  Coeff f0_mem[DIM][DIM];
-  Polynomial f0_polies[DIM];
-  for (int i = 0; i < DIM; ++i) {
-    set_polynomial(&f0_polies[i], f0_mem[i], DIM);
-  }
-  aces.private_key.f0.size = DIM;
-  aces.private_key.f0.polies = f0_polies;
-
-  // initialize f1
-  Coeff f1_mem[DIM];
-  set_polynomial(&aces.private_key.f1, f1_mem, DIM);
+  srand(6);
+  uint8_t memory[MEMORY_SIZE];
 
+  Aces aces;
+  set_aces(&aces, DIM, memory, MEMORY_SIZE);
   init_aces(2, 33, DIM, &aces);
 
   uint64_t message = 1;

lib/Aces.h

@@ -105,6 +105,8 @@ typedef struct {
   uint64_t level;
 } CipherMessage;
 
+int set_aces(Aces *aces, size_t dim, void *mem, size_t size);
+
 /**
  * @brief Initializes an instance of the ACES (Arithmetic Channel Encryption
  * Scheme).

src/Aces.c

@@ -4,6 +4,67 @@
 
 #include <string.h>
 
+int set_aces(Aces *aces, size_t dim, void *memory, size_t size) {
+  size_t required = sizeof(Coeff) * (2 * dim + 1 + 2 * dim * dim) +
+                    sizeof(Matrix2D) * dim + sizeof(Polynomial) * 2 * dim +
+                    sizeof(uint64_t) * dim * dim * dim;
+
+  if (size < required)
+    return -1;
+
+  uint8_t *mem = (uint8_t *)memory;
+  // initialize U
+  Coeff *u_mem = (Coeff *)mem;
+  mem += ((dim + 1) * sizeof(Coeff));
+  set_polynomial(&aces->shared_info.pk.u, u_mem, dim + 1);
+
+  // initialize lambda
+  Matrix2D *lambda_mat = (Matrix2D *)mem;
+  mem += dim * sizeof(Matrix2D);
+
+  uint64_t *lambda_mem = (uint64_t *)mem;
+  mem += dim * dim * dim * sizeof(uint64_t);
+
+  for (size_t i = 0; i < dim; ++i) {
+    lambda_mat[i].dim = dim;
+    lambda_mat[i].data = lambda_mem + (i * dim * dim);
+  }
+  aces->shared_info.pk.lambda.size = dim;
+  aces->shared_info.pk.lambda.data = lambda_mat;
+
+  // initialize x
+  Polynomial *x_polies = (Polynomial *)mem;
+  mem += dim * sizeof(Polynomial);
+
+  Coeff *x_mem = (Coeff *)mem;
+  mem += dim * dim * sizeof(Coeff);
+
+  for (size_t i = 0; i < dim; ++i) {
+    set_polynomial(&x_polies[i], x_mem + i * dim, dim);
+  }
+  aces->private_key.x.size = dim;
+  aces->private_key.x.polies = x_polies;
+
+  // initialize f0
+  Polynomial *f0_polies = (Polynomial *)mem;
+  mem += dim * sizeof(Polynomial);
+
+  Coeff *f0_mem = (Coeff *)mem;
+  mem += dim * dim * sizeof(Coeff);
+  for (size_t i = 0; i < dim; ++i) {
+    set_polynomial(&f0_polies[i], f0_mem + i * dim, dim);
+  }
+  aces->private_key.f0.size = dim;
+  aces->private_key.f0.polies = f0_polies;
+
+  // initialize f1
+  Coeff *f1_mem = (Coeff *)mem;
+  mem += dim * sizeof(Coeff);
+  set_polynomial(&aces->private_key.f1, f1_mem, dim);
+
+  return 0;
+}
+
 int init_aces(uint64_t p, uint64_t q, uint64_t dim, Aces *aces) {
   aces->shared_info.param.dim = dim;
   aces->shared_info.param.N = 1;