encrypt/decrypt + generate key

Cargo.toml

@@ -6,3 +6,5 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+rand = "0.9.1"
+rug = "1.27.0"

src/dghv.rs

@@ -0,0 +1,46 @@
+use rand::rngs::StdRng;
+use rand::RngCore;
+use rand::SeedableRng;
+use rug::{Assign, Integer};
+
+pub fn encrypt_bit(bit: u8, key: &Integer) -> Integer {
+    assert!(bit == 0 || bit == 1, "Only bits (0 or 1) are allowed");
+
+    let mut rng = StdRng::from_os_rng();
+
+    let q: Integer = Integer::from(rng.next_u64()) % key;
+
+    // noise
+    let mut r: Integer;
+    let p_div_4: Integer = key.clone() / 4;
+    loop {
+        r = Integer::from(rng.next_u64());
+        if r.clone() * 2 < p_div_4 {
+            break;
+        }
+    }
+
+    // c = b + p*q + 2*r
+    let mut c = Integer::new();
+    c.assign(key.clone() * &q + 2 * &r + bit);
+
+    c
+}
+
+pub fn decrypt_bit(encrypted: &Integer, key: &Integer) -> u8 {
+    let bit: Integer = (encrypted.clone() % key.clone()) % 2; // ((c mod p) mod 2)
+    bit.to_u8().unwrap()
+}
+
+pub fn generate_secret_key(eta: u32) -> Integer {
+    let mut rng = StdRng::from_os_rng();
+    let lower = Integer::from(1) << (eta - 1);
+    let upper = Integer::from(1) << eta;
+
+    loop {
+        let p = Integer::from(rng.next_u64()) % (upper.clone() - lower.clone()) + &lower;
+        if p.is_odd() {
+            return p;
+        }
+    }
+}

src/main.rs

@@ -1,3 +1,16 @@
+mod dghv;
+use crate::dghv::{decrypt_bit, encrypt_bit, generate_secret_key};
+
 fn main() {
-    println!("Hello, world!");
+    let eta = 64;
+    let secret_key = generate_secret_key(eta);
+
+    let bit = 1;
+    let ciphertext = encrypt_bit(bit, &secret_key);
+    let decrypted = decrypt_bit(&ciphertext, &secret_key);
+
+    println!("clear bit (b): {}", bit);
+    println!("Secret key (p): {}", secret_key);
+    println!("Encrypted bit (c): {}", ciphertext);
+    println!("decrypted bit : {}", decrypted);
 }