From f1f59dcec61a2842f08b4f4e572d7bde75e9574b Mon Sep 17 00:00:00 2001
From: Sam Hadow <sam.hadow@inbox.lv>
Date: Mon, 19 May 2025 18:57:10 +0200
Subject: [PATCH] cli interface (symmetric scheme)

---
 Cargo.toml  |  1 +
 src/main.rs | 77 ++++++++++++++++++++++++++++++++++++++++++++---------
 2 files changed, 65 insertions(+), 13 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index 6f35c36..13d3861 100644
--- a/Cargo.toml
+++ b/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"
 
diff --git a/src/main.rs b/src/main.rs
index 80d7730..e49b34c 100644
--- a/src/main.rs
+++ b/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 secret_key = generate_secret_key(eta);
+    let cli = Cli::parse();
 
-    let bit = 1;
-    let ciphertext = encrypt_bit(bit, &secret_key, 80, 80);
-    let decrypted = decrypt_bit(&ciphertext, &secret_key);
-    let opx2 = ciphertext.clone() * encrypt_bit(1, &secret_key, 80, 80);
-    let decrypted_opx2 = decrypt_bit(&opx2, &secret_key);
-
-    println!("clear bit (b): {}", bit);
-    println!("Secret key (p): {}", secret_key);
-    println!("Encrypted bit (c): {}", ciphertext);
-    println!("decrypted bit : {}", decrypted);
-    println!("decrypted bit AND 1: {}", decrypted_opx2);
+    match cli.command {
+        Commands::Keygen { size } => {
+            let sk = generate_secret_key(size as u32);
+            println!("Secret key (p): {}", sk.to_string_radix(16));
+        }
+        Commands::Encrypt { bit, key, noise } => {
+            let p = Integer::from_str_radix(&key, 16)
+                .expect("Invalid secret key: must be hexadecimal integer");
+            let ct = encrypt_bit(bit, &p, noise as u32, noise as u32);
+            println!("Encrypted bit (c): {}", ct.to_string_radix(16));
+        }
+        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);
+        }
+    }
 }