Merge pull request #21 from lattice-based-cryptography/ensure_doctests_run

ensure doctests are running

Author: jacksonwalters

src/decrypt.rs

@@ -1,6 +1,6 @@
 use polynomial_ring::Polynomial;
-use module_lwe::{Parameters,mul_vec_simple};
 use ring_lwe::{polysub,nearest_int};
+use crate::utils::{Parameters,mul_vec_simple};
 
 /// Decrypt a ciphertext
 /// # Arguments
@@ -13,13 +13,12 @@ use ring_lwe::{polysub,nearest_int};
 /// * `decrypted_coeffs` - plaintext vector
 /// # Example
 /// ```
-/// use polynomial_ring::Polynomial;
-/// use module_lwe::decrypt;
-/// let params = Parameters::default();
-/// let (pk,sk) = keygen(&params, None);
-/// let m_b = vec![0,1,0,1,1,0,1,0];
-/// let (u, v) = encrypt(&pk.0, &pk.1, m_b, &params, None);
-/// let decrypted_coeffs = decrypt(&sk, params.q, &params.f, &u, &v);
+/// let params = module_lwe::utils::Parameters::default();
+/// let (pk,sk) = module_lwe::keygen::keygen(&params, None);
+/// let mut m_b = vec![0,1,0,1,0,0,1,1,1,0,1];
+/// m_b.resize(params.n, 0);
+/// let (u, v) = module_lwe::encrypt::encrypt(&pk.0, &pk.1, &m_b, &params, None);
+/// let decrypted_coeffs = module_lwe::decrypt::decrypt(&sk, params.q, &params.f, &u, &v);
 /// assert_eq!(m_b, decrypted_coeffs);
 /// ```
 pub fn decrypt(

src/encrypt.rs

@@ -1,6 +1,6 @@
 use polynomial_ring::Polynomial;
 use ring_lwe::{polyadd,polysub,nearest_int};
-use module_lwe::{Parameters, add_vec, mul_mat_vec_simple, transpose, mul_vec_simple, gen_small_vector};
+use crate::utils::{Parameters, add_vec, mul_mat_vec_simple, transpose, mul_vec_simple, gen_small_vector};
 
 /// Encrypt a message using the ring-LWE cryptosystem
 /// # Arguments
@@ -13,17 +13,15 @@ use module_lwe::{Parameters, add_vec, mul_mat_vec_simple, transpose, mul_vec_sim
 /// * `(u, v)` - ciphertext
 /// # Example
 /// ```
-/// use module_lwe::Parameters;
-/// use module_lwe::encrypt;
-/// let params = Parameters::default();
-/// let (pk,sk) = keygen(&params, None);
+/// let params = module_lwe::utils::Parameters::default();
+/// let (pk,sk) = module_lwe::keygen::keygen(&params, None);
 /// let m_b = vec![0,1,0,1,1,0,1,0];
-/// let (u, v) = encrypt(&pk.0, &pk.1, m_b, &params, None);
+/// let (u, v) = module_lwe::encrypt::encrypt(&pk.0, &pk.1, &m_b, &params, None);
 /// ```
 pub fn encrypt(
     a: &Vec<Vec<Polynomial<i64>>>,
     t: &Vec<Polynomial<i64>>,
-    m_b: Vec<i64>,
+    m_b: &Vec<i64>,
     params: &Parameters,
     seed: Option<u64>
 ) -> (Vec<Polynomial<i64>>, Polynomial<i64>) {
@@ -40,7 +38,7 @@ pub fn encrypt(
     let half_q = nearest_int(q,2);
 
     // Convert binary message to polynomial
-    let m = Polynomial::new(vec![half_q])*Polynomial::new(m_b);
+    let m = Polynomial::new(vec![half_q])*Polynomial::new(m_b.to_vec());
 
     // Compute u = a^T * r + e_1 mod q
     let u = add_vec(&mul_mat_vec_simple(&transpose(a), &r, q, f), &e1, q, f);
@@ -61,12 +59,12 @@ pub fn encrypt(
 /// * `ciphertext_str` - ciphertext string
 /// # Example
 /// ```
-/// use module_lwe::Parameters;
-/// use module_lwe::encrypt_string;
-/// let params = Parameters::default();
-/// let (pk,sk) = keygen(&params, None);
+/// let params = module_lwe::utils::Parameters::default();
+/// let keypair = module_lwe::keygen::keygen_string(&params,None);
+/// let pk_string = keypair.get("public").unwrap();
+/// let sk_string = keypair.get("secret").unwrap();
 /// let message_string = "Hello, world!".to_string();
-/// let ciphertext_string = encrypt_string(&pk_string, &message_string, &params, None);
+/// 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 {
 
@@ -104,7 +102,7 @@ pub fn encrypt_string(pk_string: &String, message_string: &String, params: &Para
     // Encrypt each block
     let mut ciphertext_list = vec![];
     for block in message_blocks {
-        let (u, v) = encrypt(&a, &t, block, params, seed);
+        let (u, v) = encrypt(&a, &t, &block, params, seed);
         let u_flattened: Vec<i64> = u.iter()
             .flat_map(|poly| {
                 let mut coeffs = poly.coeffs().to_vec();

src/keygen.rs

@@ -1,6 +1,6 @@
 use polynomial_ring::Polynomial;
-use module_lwe::{Parameters, add_vec, mul_mat_vec_simple, gen_small_vector, gen_uniform_matrix};
 use std::collections::HashMap;
+use crate::utils::{Parameters, add_vec, mul_mat_vec_simple, gen_small_vector, gen_uniform_matrix};
 
 /// Generate public and secret keys for the ring-LWE cryptosystem
 /// # Arguments
@@ -10,10 +10,8 @@ use std::collections::HashMap;
 /// * `((a, t), sk)` - public key (a, t) and secret key (sk)
 /// # Example
 /// ```
-/// use module_lwe::Parameters;
-/// use module_lwe::keygen;
-/// let params = Parameters::default();
-/// let (pk, sk) = keygen(&params, None);
+/// let params = module_lwe::utils::Parameters::default();
+/// let (pk, sk) = module_lwe::keygen::keygen(&params, None);
 /// ```
 pub fn keygen(
 	params: &Parameters,
@@ -38,10 +36,8 @@ pub fn keygen(
 /// * `keys` - HashMap containing the public and secret keys
 /// # Example
 /// ```
-/// use module_lwe::Parameters;
-/// use module_lwe::keygen_string;
-/// let params = Parameters::default();
-/// let keys = keygen_string(&params, None);
+/// 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> {
 

src/lib.rs

@@ -1,141 +1,4 @@
-use polynomial_ring::Polynomial;
-use rand_distr::{Uniform, Distribution};
-use rand::SeedableRng;
-use rand::rngs::StdRng;
-use ring_lwe::{polyadd, polymul, gen_uniform_poly};
-
-#[derive(Debug)]
-/// default parameters for module-LWE
-pub struct Parameters {
-	/// degree of the polynomials
-    pub n: usize,
-	/// Ciphertext modulus
-    pub q: i64,
-	/// Plaintext modulus    
-    pub k: usize,     
-	/// Polynomial modulus
-    pub f: Polynomial<i64>, 
-}
-
-/// default parameters for module-LWE
-impl Default for Parameters {
-    fn default() -> Self {
-        let n = 32;
-        let q = 59049;
-        let k = 8;
-        let mut poly_vec = vec![0i64;n+1];
-        poly_vec[0] = 1;
-        poly_vec[n] = 1;
-        let f = Polynomial::new(poly_vec);
-        Parameters { n, q, k, f }
-    }
-}
-
-/// add two vectors of polynomials
-/// # Arguments
-/// * `v0` - vector of polynomials
-/// * `v1` - vector of polynomials
-/// * `modulus` - modulus
-/// * `poly_mod` - polynomial modulus
-/// # Returns
-/// * `result` - vector of polynomials
-pub fn add_vec(v0: &Vec<Polynomial<i64>>, v1: &Vec<Polynomial<i64>>, modulus: i64, poly_mod: &Polynomial<i64>) -> Vec<Polynomial<i64>> {
-	assert!(v0.len() == v1.len());
-	let mut result = vec![];
-	for i in 0..v0.len() {
-		result.push(polyadd(&v0[i], &v1[i], modulus, &poly_mod));
-	}
-	result
-}
-
-/// take the dot product of two vectors of polynomials
-/// # Arguments
-/// * `v0` - vector of polynomials
-/// * `v1` - vector of polynomials
-/// * `modulus` - modulus
-/// * `poly_mod` - polynomial modulus
-/// # Returns
-/// * `result` - polynomial
-pub fn mul_vec_simple(v0: &Vec<Polynomial<i64>>, v1: &Vec<Polynomial<i64>>, modulus: i64, poly_mod: &Polynomial<i64>) -> Polynomial<i64> {
-	assert!(v0.len() == v1.len());
-	let mut result = Polynomial::new(vec![]);
-	for i in 0..v0.len() {
-		result = polyadd(&result, &polymul(&v0[i], &v1[i], modulus, &poly_mod), modulus, &poly_mod);
-	}
-	result
-}
-
-/// multiply a matrix by a vector of polynomials
-/// # Arguments
-/// * `m` - matrix of polynomials
-/// * `v` - vector of polynomials
-/// * `modulus` - modulus
-/// * `poly_mod` - polynomial modulus
-/// # Returns
-/// * `result` - vector of polynomials
-pub fn mul_mat_vec_simple(m: &Vec<Vec<Polynomial<i64>>>, v: &Vec<Polynomial<i64>>, modulus: i64, poly_mod: &Polynomial<i64>) -> Vec<Polynomial<i64>> {
-	
-	let mut result = vec![];
-	for i in 0..m.len() {
-		result.push(mul_vec_simple(&m[i], &v, modulus, &poly_mod));
-	}
-	result
-}
-
-/// take the transpose of a matrix of polynomials
-/// # Arguments
-/// * `m` - matrix of polynomials
-/// # Returns
-/// * `result` - matrix of polynomials
-pub fn transpose(m: &Vec<Vec<Polynomial<i64>>>) -> Vec<Vec<Polynomial<i64>>> {
-	let mut result = vec![vec![Polynomial::new(vec![]); m.len()]; m[0].len()];
-	for i in 0..m.len() {
-		for j in 0..m[0].len() {
-			result[j][i] = m[i][j].clone();
-		}
-	}
-	result
-}
-
-/// generates a vector of given rank of degree size-1 polynomials with coefficients in {-1,0,1}
-/// # Arguments
-/// * `size` - degree of the polynomials
-/// * `rank` - rank of the vector
-/// * `seed` - seed for the random number generator
-/// # Returns
-/// * `v` - vector of polynomials
-pub fn gen_small_vector(size : usize, rank: usize, seed: Option<u64>) -> Vec<Polynomial<i64>> {
-	let mut v = vec![];
-	let between = Uniform::new(0,3);
-	let mut rng = match seed {
-        Some(seed) => StdRng::seed_from_u64(seed),
-        None => StdRng::from_entropy(),
-    };
-    let mut coeffs = vec![0i64;size];
-	for _i in 0..rank {
-		for j in 0.. size {
-			coeffs[j] = between.sample(&mut rng)-1;
-		}
-		v.push(Polynomial::new(coeffs.clone()));
-	}
-	v
-}
-
-/// generates a `rank x rank` matrix of degree `size-1` polynomials with uniform coefficients in Z_modulus
-/// # Arguments
-/// * `size` - degree of the polynomials
-/// * `rank` - rank of the matrix
-/// * `modulus` - modulus
-/// * `seed` - seed for the random number generator
-/// # Returns
-/// * `m` - matrix of polynomials
-pub fn gen_uniform_matrix(size : usize, rank: usize, modulus: i64, seed: Option<u64>) -> Vec<Vec<Polynomial<i64>>> {
-	let mut m = vec![vec![Polynomial::new(vec![]); rank]; rank];
-	for i in 0..rank {
-		for j in 0..rank {
-			m[i][j] = gen_uniform_poly(size, modulus, seed);
-		}
-	}
-	m
-}
-	
+pub mod keygen;
+pub mod encrypt;
+pub mod decrypt;
+pub mod utils;

src/main.rs

@@ -1,13 +1,14 @@
 mod keygen;
 mod encrypt;
 mod decrypt;
+mod utils;
 mod test;
 
 use crate::keygen::keygen_string;
 use crate::encrypt::encrypt_string;
 use crate::decrypt::decrypt_string;
+use crate::utils::Parameters;
 use std::env;
-use module_lwe::Parameters;
 use polynomial_ring::Polynomial;
 
 fn main() {

src/test.rs

@@ -3,7 +3,7 @@ mod tests {
     use crate::keygen::{keygen,keygen_string};
     use crate::encrypt::{encrypt,encrypt_string};
     use crate::decrypt::{decrypt,decrypt_string};
-    use module_lwe::{Parameters,add_vec};
+    use crate::utils::{Parameters,add_vec};
     use ring_lwe::polyadd;
 
     // Test for basic keygen/encrypt/decrypt of a message
@@ -42,8 +42,8 @@ mod tests {
         let (pk, sk) = keygen(&params,seed);
 
         // Encrypt plaintext messages
-        let u = encrypt(&pk.0, &pk.1, m0, &params, seed);
-        let v = encrypt(&pk.0, &pk.1, m1, &params, seed);
+        let u = encrypt(&pk.0, &pk.1, &m0, &params, seed);
+        let v = encrypt(&pk.0, &pk.1, &m1, &params, seed);
 
         // Compute sum of encrypted data
         let ciphertext_sum = (add_vec(&u.0,&v.0,q,f), polyadd(&u.1,&v.1,q,f));