abstract compress/decompress

Author: jacksonwalters

src/decrypt.rs

@@ -1,8 +1,6 @@
 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;
+use crate::utils::{Parameters,mul_vec_simple,decompress};
 
 /// Decrypt a ciphertext
 /// # Arguments
@@ -53,21 +51,15 @@ pub fn decrypt_string(sk_string: &String, ciphertext_base64: &String, params: &P
     let (n, k) = (params.n, params.k);
 
     // 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");
+    let sk_array: Vec<i64> = decompress(sk_string);
 
     // 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();
 
-    // 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");
+    // Base64 decode and deserialize the ciphertext string
+    let ciphertext_list: Vec<i64> = decompress(ciphertext_base64);
 
     let block_size = (k + 1) * n;
     let num_blocks = ciphertext_list.len() / block_size;

src/encrypt.rs

@@ -1,8 +1,6 @@
 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;
+use crate::utils::{Parameters, add_vec, mul_mat_vec_simple, transpose, mul_vec_simple, gen_small_vector, compress, decompress};
 
 /// Encrypt a message using the ring-LWE cryptosystem
 /// # Arguments
@@ -72,11 +70,8 @@ pub fn encrypt_string(pk_string: &String, message_string: &String, params: &Para
     // Get parameters
     let (n, k) = (params.n, params.k);
 
-    // Decode the base64-encoded public key string
-    let pk_bytes = general_purpose::STANDARD.decode(pk_string).expect("Failed to decode base64 public key");
-    
-    // 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");
+    // Decode and deserialize the base64-encoded public key string
+    let pk_list: Vec<i64> = decompress(pk_string);
 
     // Parse the public key
     let a: Vec<Vec<Polynomial<i64>>> = pk_list[..k * k * n]
@@ -120,9 +115,6 @@ pub fn encrypt_string(pk_string: &String, message_string: &String, params: &Para
         ciphertext_list.extend(v_flattened);
     }
 
-    // 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_base64
+    // Serialize and Base64 encode the ciphertext coefficient list
+    compress(&ciphertext_list)
 }

src/keygen.rs

@@ -1,8 +1,6 @@
 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;
+use crate::utils::{Parameters, add_vec, mul_mat_vec_simple, gen_small_vector, gen_uniform_matrix,compress};
 
 /// Generate public and secret keys for the ring-LWE cryptosystem
 /// # Arguments
@@ -77,18 +75,10 @@ pub fn keygen_string(params: &Parameters, seed: Option<u64>) -> HashMap<String,
         })
     .collect();
 
-    // 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_base64);
-    keys.insert(String::from("public"), pk_base64);
+    keys.insert(String::from("secret"), compress(&sk_coeffs));
+    keys.insert(String::from("public"), compress(&pk_coeffs));
 
     keys
 }

src/utils.rs

@@ -4,6 +4,8 @@ use rand::SeedableRng;
 use rand::rngs::StdRng;
 use ring_lwe::utils::{polyadd, polymul_fast, gen_uniform_poly};
 use ntt::omega;
+use base64::{engine::general_purpose, Engine as _};
+use bincode;
 
 #[derive(Debug)]
 /// default parameters for module-LWE
@@ -143,4 +145,24 @@ pub fn gen_uniform_matrix(size : usize, rank: usize, modulus: i64, seed: Option<
 		}
 	}
 	m
+}
+
+/// seralize and encode a vector of i64 to a base64 encoded string
+/// # Arguments
+/// * `data` - vector of i64
+/// # Returns
+/// * `encoded` - base64 encoded string
+pub fn compress(data: &Vec<i64>) -> String {
+    let serialized_data = bincode::serialize(data).expect("Failed to serialize data");
+    general_purpose::STANDARD.encode(&serialized_data)
+}
+
+/// decode and deserialize a base64 encoded string to a vector of i64
+/// # Arguments
+/// * `base64_str` - base64 encoded string
+/// # Returns
+/// * `decoded_data` - vector of i64
+pub fn decompress(base64_str: &str) -> Vec<i64> {
+    let decoded_bytes = general_purpose::STANDARD.decode(base64_str).expect("Failed to decode base64 string");
+    bincode::deserialize(&decoded_bytes).expect("Failed to deserialize data")
 }