cli interface (symmetric scheme)

Cargo.toml

@@ -6,6 +6,7 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+clap = { version = "4.5.38", features = ["derive"] }
 rand = "0.9.1"
 rug = "1.27.0"
 

src/main.rs

@@ -3,20 +3,71 @@ mod dghv;
 mod dghv_asym;
 mod utils;
 use crate::dghv::{decrypt_bit, encrypt_bit, generate_secret_key};
+use std::path::{Path, PathBuf};
+use rug::Integer;
+use clap::{Parser, Subcommand};
+
+
+#[derive(Parser)]
+#[command(author, version, about, long_about = None)]
+#[command(propagate_version = true)]
+struct Cli {
+    #[command(subcommand)]
+    command: Commands,
+}
+
+#[derive(Subcommand)]
+enum Commands {
+    /// Generate a secret key
+    Keygen {
+        /// security parameter eta (p bit-length)
+        #[clap(short = 's', long, default_value_t = 6400)]
+        size: u32,
+    },
+    /// Encrypt a single bit
+    Encrypt {
+        /// bit to encrypt (0 or 1)
+        #[clap(short = 'b', long)]
+        bit: u8,
+        /// secret key (hex)
+        #[clap(short = 'k', long)]
+        key: String,
+        /// noise parameter
+        #[clap(short = 'n', long, default_value_t = 80)]
+        noise: u32,
+    },
+    /// Decrypt a single bit
+    Decrypt {
+        /// ciphertext to decrypt (hex)
+        #[clap(short = 'c', long)]
+        ciphertext: String,
+        /// secret key (hex)
+        #[clap(short = 'k', long)]
+        key: String,
+    },
+}
 
 fn main() {
-    let eta = 6400;
+    let cli = Cli::parse();
-    let secret_key = generate_secret_key(eta);
 
-    let bit = 1;
+    match cli.command {
-    let ciphertext = encrypt_bit(bit, &secret_key, 80, 80);
+        Commands::Keygen { size } => {
-    let decrypted = decrypt_bit(&ciphertext, &secret_key);
+            let sk = generate_secret_key(size as u32);
-    let opx2 = ciphertext.clone() * encrypt_bit(1, &secret_key, 80, 80);
+            println!("Secret key (p): {}", sk.to_string_radix(16));
-    let decrypted_opx2 = decrypt_bit(&opx2, &secret_key);
+        }
-
+        Commands::Encrypt { bit, key, noise } => {
-    println!("clear bit (b): {}", bit);
+            let p = Integer::from_str_radix(&key, 16)
-    println!("Secret key (p): {}", secret_key);
+                .expect("Invalid secret key: must be hexadecimal integer");
-    println!("Encrypted bit (c): {}", ciphertext);
+            let ct = encrypt_bit(bit, &p, noise as u32, noise as u32);
-    println!("decrypted bit : {}", decrypted);
+            println!("Encrypted bit (c): {}", ct.to_string_radix(16));
-    println!("decrypted bit AND 1: {}", decrypted_opx2);
+        }
+        Commands::Decrypt { ciphertext, key } => {
+            let p = Integer::from_str_radix(&key, 16)
+                .expect("Invalid secret key: must be hexadecimal integer");
+            let ct = Integer::from_str_radix(&ciphertext, 16)
+                .expect("Invalid ciphertext: must be hexadecimal integer");
+            let res = decrypt_bit(&ct, &p);
+            println!("Decrypted bit: {}", res);
+        }
+    }
 }