use base64 encoding for sk, pk, ct

use base64 encoding (binary serialization of vectors of integers followed by encoding) for secret key, public key, and ciphertext

Author: jacksonwalters

Cargo.toml

@@ -15,6 +15,8 @@ rand = "0.8.5"
 rand_distr = "0.4.3"
 ntt = "0.1.9"
 ring-lwe = "0.1.6"
+base64 = "0.21"
+bincode = "1.3"
 
 [dev-dependencies]
 criterion = "0.5.1"

src/decrypt.rs

@@ -1,6 +1,8 @@
 use polynomial_ring::Polynomial;
 use ring_lwe::utils::{polysub,nearest_int};
 use crate::utils::{Parameters,mul_vec_simple};
+use base64::{engine::general_purpose, Engine as _};
+use bincode;
 
 /// Decrypt a ciphertext
 /// # Arguments
@@ -46,55 +48,59 @@ pub fn decrypt(
 /// * `params` - Parameters for the ring-LWE cryptosystem
 /// # Returns
 /// * `message_string` - decrypted message string
-pub fn decrypt_string(sk_string: &String, ciphertext_string: &String, params: &Parameters) -> String {
-
-    //get parameters
+pub fn decrypt_string(sk_string: &String, ciphertext_base64: &String, params: &Parameters) -> String {
+    // Get parameters
     let (n, k) = (params.n, params.k);
-    
-    // Convert the secret key string into a Vec<Polynomial<i64>>
-    let sk_array: Vec<i64> = sk_string.split(',')
-        .filter_map(|s| s.parse().ok())
-        .collect();
+
+    // Base64 decode the secret key string
+    let sk_bytes = general_purpose::STANDARD.decode(sk_string).expect("Failed to decode base64 secret key");
+
+    // Deserialize the secret key from bytes (it was serialized with bincode)
+    let sk_array: Vec<i64> = bincode::deserialize(&sk_bytes).expect("Failed to deserialize secret key");
+
+    // Convert the secret key into a Vec<Polynomial<i64>>
     let sk: Vec<Polynomial<i64>> = sk_array.chunks(n)
         .map(|chunk| Polynomial::new(chunk.to_vec()))
         .collect();
-    
-    // Parse ciphertext into u and v
-    let ciphertext_list: Vec<i64> = ciphertext_string.split(',')
-        .filter_map(|s| s.parse().ok())
-        .collect();
+
+    // Base64 decode the ciphertext string
+    let ciphertext_bytes = general_purpose::STANDARD.decode(ciphertext_base64).expect("Failed to decode ciphertext");
+
+    // Deserialize the ciphertext list from the decoded bytes
+    let ciphertext_list: Vec<i64> = bincode::deserialize(&ciphertext_bytes).expect("Failed to deserialize ciphertext");
+
     let block_size = (k + 1) * n;
     let num_blocks = ciphertext_list.len() / block_size;
 
     let mut message_binary = vec![];
-    
+
     for i in 0..num_blocks {
         // Get u and v for this block
         let u_array = &ciphertext_list[i * block_size..i * block_size + k * n];
         let v_array = &ciphertext_list[i * block_size + k * n..(i + 1) * block_size];
-            
+        
         let u: Vec<Polynomial<i64>> = u_array.chunks(n)
             .map(|chunk| Polynomial::new(chunk.to_vec()))
             .collect();
         let v = Polynomial::new(v_array.to_vec());
-            
+        
         // Decrypt the ciphertext
         let mut m_b = decrypt(&sk, &u, &v, &params);
-        m_b.resize(n,0);
-            
+        m_b.resize(n, 0);
+        
         message_binary.extend(m_b);
     }
-    
+
     // Group the bits back into bytes (8 bits each)
     let byte_chunks: Vec<String> = message_binary.chunks(8)
         .map(|chunk| chunk.iter().map(|bit| bit.to_string()).collect())
         .collect();
-        
+
     // Convert each binary string back into a character
     let message_string: String = byte_chunks.iter()
         .map(|byte| char::from_u32(i64::from_str_radix(byte, 2).unwrap() as u32).unwrap())
         .collect();
-    
-    //trim the null characters \0 = '00000000' from the end
+
+    // Trim the null characters \0 = '00000000' from the end
     message_string.trim_end_matches('\0').to_string()
-}
+}

src/encrypt.rs

@@ -1,6 +1,8 @@
 use polynomial_ring::Polynomial;
 use ring_lwe::utils::{polyadd,polysub,nearest_int};
 use crate::utils::{Parameters, add_vec, mul_mat_vec_simple, transpose, mul_vec_simple, gen_small_vector};
+use base64::{engine::general_purpose, Engine as _};
+use bincode;
 
 /// Encrypt a message using the ring-LWE cryptosystem
 /// # Arguments
@@ -43,6 +45,8 @@ pub fn encrypt(
     // Compute u = a^T * r + e_1 mod q
     let u = add_vec(&mul_mat_vec_simple(&transpose(a), &r, q, f, omega), &e1, q, f);
 
+    println!("t: {:?}", t);
+
     // Compute v = t * r + e_2 - m mod q
     let v = polysub(&polyadd(&mul_vec_simple(t, &r, q, &f, omega), &e2, q, f), &m, q, f);
 
@@ -51,12 +55,12 @@ pub fn encrypt(
 
 /// function to encrypt a message given a public_key string
 /// # Arguments
-/// * `pk_string` - public key string
-/// * `message_string` - message string
+/// * `pk_string` - public key string in base64 encoding
+/// * `message_string` - message string in base64 encoding
 /// * `params` - Parameters for the ring-LWE cryptosystem
 /// * `seed` - random seed
 /// # Returns
-/// * `ciphertext_str` - ciphertext string
+/// * `ciphertext_str` - ciphertext string, base64 encoded
 /// # Example
 /// ```
 /// let params = module_lwe::utils::Parameters::default();
@@ -67,14 +71,16 @@ pub fn encrypt(
 /// let ciphertext_string = module_lwe::encrypt::encrypt_string(&pk_string, &message_string, &params, None);
 /// ```
 pub fn encrypt_string(pk_string: &String, message_string: &String, params: &Parameters, seed: Option<u64>) -> String {
-
-    //get parameters
+    // Get parameters
     let (n, k) = (params.n, params.k);
 
-    // Parse public key
+    // Decode the base64-encoded public key string
+    let pk_bytes = general_purpose::STANDARD.decode(pk_string).expect("Failed to decode base64 public key");
 
-    let pk_list: Vec<i64> = pk_string.split(',').map(|x| x.parse::<i64>().unwrap()).collect();
+    // Deserialize the public key from bytes (it was serialized with bincode)
+    let pk_list: Vec<i64> = bincode::deserialize(&pk_bytes).expect("Failed to deserialize public key");
 
+    // Parse the public key
     let a: Vec<Vec<Polynomial<i64>>> = pk_list[..k * k * n]
         .chunks(k * n)
         .map(|chunk| {
@@ -93,7 +99,7 @@ pub fn encrypt_string(pk_string: &String, message_string: &String, params: &Para
         .flat_map(|byte| (0..8).rev().map(move |i| ((byte >> i) & 1) as i64))
         .collect();
 
-    // Break message into blocks, including the last partial block if necessary
+    // Break message into blocks
     let message_blocks: Vec<Vec<i64>> = message_binary
         .chunks(n) // Divide the binary message into chunks of size `n`
         .map(|chunk| chunk.to_vec()) // Convert each chunk into a vector
@@ -111,12 +117,14 @@ pub fn encrypt_string(pk_string: &String, message_string: &String, params: &Para
             })
             .collect();
         let mut v_flattened: Vec<i64> = v.coeffs().to_vec();
-        v_flattened.resize(n,0);
+        v_flattened.resize(n, 0);
         ciphertext_list.extend(u_flattened);
         ciphertext_list.extend(v_flattened);
     }
 
-    let ciphertext_str = ciphertext_list.iter().map(|x| x.to_string()).collect::<Vec<String>>().join(",");
+    // Serialize and Base64 encode the ciphertext
+    let ciphertext_bytes = bincode::serialize(&ciphertext_list).expect("Failed to serialize ciphertext");
+    let ciphertext_base64 = general_purpose::STANDARD.encode(ciphertext_bytes);
 
-    ciphertext_str
+    ciphertext_base64
 }

src/keygen.rs

@@ -1,6 +1,8 @@
 use polynomial_ring::Polynomial;
 use std::collections::HashMap;
 use crate::utils::{Parameters, add_vec, mul_mat_vec_simple, gen_small_vector, gen_uniform_matrix};
+use base64::{engine::general_purpose, Engine as _};
+use bincode;
 
 /// Generate public and secret keys for the ring-LWE cryptosystem
 /// # Arguments
@@ -29,22 +31,22 @@ pub fn keygen(
 }
 
 /// Generate public and secret keys for the ring-LWE cryptosystem and return them as a HashMap
+/// They are serialized and base64 encoded
 /// # Arguments
 /// * `params` - Parameters for the ring-LWE cryptosystem
 /// * `seed` - random seed
 /// # Returns
-/// * `keys` - HashMap containing the public and secret keys
+/// * `keys` - HashMap containing the public and secret keys as base64 encoded strings
 /// # Example
 /// ```
 /// let params = module_lwe::utils::Parameters::default();
 /// let keys = module_lwe::keygen::keygen_string(&params, None);
 /// ```
 pub fn keygen_string(params: &Parameters, seed: Option<u64>) -> HashMap<String, String> {
+    // Generate public and secret keys
+    let (pk, sk) = keygen(params, seed);
 
-    //generate public, secret keys
-    let (pk,sk) = keygen(params,seed);
-
-    // Convert public key to a flattened list of coefficients
+    // Convert the public key to a flattened list of coefficients
     let mut pk_coeffs: Vec<i64> = pk.0
         .iter()
         .flat_map(|row| {
@@ -64,7 +66,7 @@ pub fn keygen_string(params: &Parameters, seed: Option<u64>) -> HashMap<String,
         })
     );
 
-    // Convert secret key to a flattened list of coefficients
+    // Convert the secret key to a flattened list of coefficients
     let sk_coeffs: Vec<i64> = sk
         .iter()
         .flat_map(|poly| {
@@ -74,20 +76,18 @@ pub fn keygen_string(params: &Parameters, seed: Option<u64>) -> HashMap<String,
         })
     .collect();
 
-    // Convert the public/secret key coefficients to a comma-separated string
-    let pk_coeffs_str = pk_coeffs.iter()
-        .map(|coef| coef.to_string())
-        .collect::<Vec<String>>()
-        .join(",");
-    let sk_coeffs_str = sk_coeffs.iter()
-        .map(|coef| coef.to_string())
-        .collect::<Vec<String>>()
-        .join(",");
-    
-    //store the secret/public key in a HashMap
+    // Serialize the public and secret key coefficients
+    let pk_bytes = bincode::serialize(&pk_coeffs).expect("Failed to serialize public key coefficients");
+    let sk_bytes = bincode::serialize(&sk_coeffs).expect("Failed to serialize secret key coefficients");
+
+    // Base64 encode the serialized keys
+    let pk_base64 = general_purpose::STANDARD.encode(pk_bytes);
+    let sk_base64 = general_purpose::STANDARD.encode(sk_bytes);
+
+    // Store the Base64 encoded keys in a HashMap
     let mut keys: HashMap<String, String> = HashMap::new();
-    keys.insert(String::from("secret"), sk_coeffs_str);
-    keys.insert(String::from("public"), pk_coeffs_str);
-    
+    keys.insert(String::from("secret"), sk_base64);
+    keys.insert(String::from("public"), pk_base64);
+
     keys
 }

src/utils.rs

@@ -62,6 +62,8 @@ pub fn add_vec(v0: &Vec<Polynomial<i64>>, v1: &Vec<Polynomial<i64>>, modulus: i6
 /// # Returns
 /// * `result` - polynomial
 pub fn mul_vec_simple(v0: &Vec<Polynomial<i64>>, v1: &Vec<Polynomial<i64>>, modulus: i64, poly_mod: &Polynomial<i64>, omega: i64) -> Polynomial<i64> {
+	println!("v0: {:?}", v0);
+	println!("v1: {:?}", v1);
 	assert!(v0.len() == v1.len());
 	let mut result = Polynomial::new(vec![]);
 	for i in 0..v0.len() {