feat(dsa): implement DSA digital signature scheme with key generation…

.gitignore

@@ -1 +1,12 @@
 /target
+*.pdb
+.vscode/
+.idea/
+*~
+*.swp
+*.tmp
+
+.dockerignore
+docker-compose.yml
+Dockerfile
+

Cargo.toml

@@ -8,10 +8,19 @@ blstrs = "0.7.1"
 ff = "0.13.0"
 group = { version = "0.13.0", features = ["rand"] }
 rand_core = { version = "0.6.4", features = ["getrandom"] }
+rug = { version = "1.24", features = ["rand"] }
 
 [dev-dependencies]
 divan = "0.1.17"
 
 [[bench]]
 name = "bls"
 harness = false
+
+[[bench]]
+name = "dsa"
+harness = false
+
+[[example]]
+name = "dsa_example"
+path = "examples/dsa_example.rs"

README.md

@@ -3,7 +3,9 @@ Collection of digital signature schemes written in Rust for the University of Ca
 
 ## Schemes
 - [BLS on the BLS12-381 elliptic curve](./src/bls/)
+- [DSA (FIPS 186-4)](./src/dsa/)
 
 ## Libraries
 - [blstrs](https://github.com/filecoin-project/blstrs)
+- [rug](https://gitlab.com/tspiteri/rug)
 - [divan](https://github.com/nvzqz/divan)

benches/dsa.rs

@@ -0,0 +1,44 @@
+use divan::black_box;
+use divan::Bencher;
+use ds_rust::dsa::algorithms::DSA;
+use ds_rust::traits::digital_signature::DigitalSignature;
+use rug::rand::RandState;
+use ds_rust::utils::rand::rug_randseed_os_rng;
+
+const SECURITY_LEVEL: u64 = 80;
+
+#[divan::bench]
+fn dsa_keygen() {
+    let mut rng = RandState::new();
+    rug_randseed_os_rng(128, &mut rng).unwrap();
+    let _ = DSA::keygen(black_box(SECURITY_LEVEL), black_box(&mut rng)).unwrap();
+}
+
+#[divan::bench]
+fn dsa_sign(bencher: Bencher) {
+    let mut rng = RandState::new();
+    rug_randseed_os_rng(128, &mut rng).unwrap();
+    let (sk, _) = DSA::keygen(SECURITY_LEVEL, &mut rng).unwrap();
+    let message = b"benchmark message for DSA signing";
+
+    bencher.bench_local(|| {
+        let _ = DSA::sign(black_box(&sk), black_box(message), black_box(&mut rng)).unwrap();
+    });
+}
+
+#[divan::bench]
+fn dsa_verify(bencher: Bencher) {
+    let mut rng = RandState::new();
+    rug_randseed_os_rng(128, &mut rng).unwrap();
+    let (sk, pk) = DSA::keygen(SECURITY_LEVEL, &mut rng).unwrap();
+    let message = b"benchmark message for DSA verification";
+    let signature = DSA::sign(&sk, message, &mut rng).unwrap();
+
+    bencher.bench_local(|| {
+        let _ = DSA::verify(black_box(&pk), black_box(message), black_box(&signature)).unwrap();
+    });
+}
+
+fn main() {
+    divan::main();
+}

examples/dsa_example.rs

@@ -0,0 +1,69 @@
+use ds_rust::dsa::algorithms::DSA;
+use ds_rust::traits::digital_signature::DigitalSignature;
+use ds_rust::utils::rand::rug_randseed_os_rng;
+use rug::rand::RandState;
+use rug::integer::IntegerExt64;
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    println!("=== DSA Digital Signature Example ===\n");
+
+    let mut rng = RandState::new();
+    rug_randseed_os_rng(128, &mut rng)?;
+
+    println!("1. Generating DSA key pair (this may take a moment)...");
+    let (secret_key, public_key) = DSA::keygen(80, &mut rng)?;
+    println!("    Key pair generated successfully");
+    println!("   Domain parameters:");
+    println!("     p ({} bits): {}...", public_key.p.significant_bits_64(), 
+             public_key.p.to_string().chars().take(50).collect::<String>());
+    println!("     q ({} bits): {}...", public_key.q.significant_bits_64(), 
+             public_key.q.to_string().chars().take(50).collect::<String>());
+    println!("     g: {}...", public_key.g.to_string().chars().take(50).collect::<String>());
+
+    let message = b"Hello, this is a test message for DSA digital signature!";
+    println!("\n2. Message to sign: {:?}", String::from_utf8_lossy(message));
+
+    println!("\n3. Signing the message...");
+    let signature = DSA::sign(&secret_key, message, &mut rng)?;
+    println!("    Message signed successfully");
+    println!("   Signature:");
+    println!("     r: {}...", signature.r.to_string().chars().take(50).collect::<String>());
+    println!("     s: {}...", signature.s.to_string().chars().take(50).collect::<String>());
+
+    println!("\n4. Verifying the signature...");
+    let is_valid = DSA::verify(&public_key, message, &signature)?;
+    println!("   Signature valid: {}", is_valid);
+
+    if is_valid {
+        println!(" Signature verification successful!");
+    } else {
+        println!(" Signature verification failed!");
+        return Err(" Signature verification failed".into());
+    }
+
+    println!("\n5. Testing with tampered message...");
+    let tampered_message = b"Hello, this is a TAMPERED message for DSA digital signature!";
+    let is_tampered_valid = DSA::verify(&public_key, tampered_message, &signature)?;
+    println!("   Tampered message signature valid: {}", is_tampered_valid);
+
+    if !is_tampered_valid {
+        println!(" Correctly detected tampered message!");
+    } else {
+        println!(" Failed to detect tampered message!");
+    }
+
+    println!("\n6. Testing with tampered signature...");
+    let mut tampered_signature = signature.clone();
+    tampered_signature.r = &tampered_signature.r + rug::Integer::from(1);
+    let is_tampered_sig_valid = DSA::verify(&public_key, message, &tampered_signature)?;
+    println!(" Tampered signature valid: {}", is_tampered_sig_valid);
+
+    if !is_tampered_sig_valid {
+        println!(" Correctly detected tampered signature!");
+    } else {
+        println!(" Failed to detect tampered signature!");
+    }
+
+    println!("\n=== DSA Example Complete ===");
+    Ok(())
+}

src/dsa.rs

@@ -0,0 +1,2 @@
+pub mod algorithms;
+pub mod keys;