Diffie-Hellman algo

Author: ml3m

Diffie-Hellman/Cargo.toml

@@ -0,0 +1,7 @@
+[package]
+name = "Diffie-Hellman"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+rand = "0.8"

Diffie-Hellman/README.md

@@ -0,0 +1,67 @@
+# Diffie-Hellman Key Exchange - Rust
+
+This is a simple implementation of the **Diffie-Hellman key exchange protocol**
+in Rust. The program demonstrates how two parties (Alice and Bob) can securely
+share a secret key over an insecure channel using public-key cryptography.
+
+## Features
+- **Prime Number (`p`) and Base (`g`) input**: Users can input the prime number and base for the Diffie-Hellman protocol.
+- **Private Key input**: Users can input the private keys for Alice and Bob.
+- **Key Exchange**: The program computes the public keys for Alice and Bob, and then calculates the shared secret key for both.
+- **Security**: The Diffie-Hellman protocol allows both parties to compute the same shared secret without directly transmitting it.
+
+## Prerequisites
+```toml
+[dependencies]
+rand = "0.8"
+```
+
+## Usage
+
+when you run the program, you will be prompted to enter the following inputs:
+
+1. **Prime number (`p`)**: A prime number that is publicly agreed upon by both parties.
+2. **Base (`g`)**: A base number used for modular exponentiation.
+3. **Alice's private key**: A secret number chosen by Alice.
+4. **Bob's private key**: A secret number chosen by Bob.
+
+### Example Interaction
+
+```
+Enter a prime number (p): 23
+Enter the base (g): 5
+Enter Alice's private key: 6
+Enter Bob's private key: 15
+
+Prime number (p): 23
+Base (g): 5
+Alice's private key: 6
+Bob's private key: 15
+Alice's public key: 8
+Bob's public key: 19
+
+Exchanging public keys...
+
+Alice's computed shared secret: 2
+Bob's computed shared secret: 2
+
+The shared secret is the same! Key exchange successful.
+```
+
+## Code Explanation
+
+- **Modular Exponentiation**: The core of the Diffie-Hellman key exchange uses modular exponentiation to compute public and shared keys. This is implemented in the `mod_exp` function.
+- **Private Key Generation**: Private keys are randomly generated for Alice and Bob within the range `[1, p)`.
+- **Public Key Calculation**: The public keys `A` and `B` are calculated using the formula:
+  
+  ```
+  A = g^a mod p
+  B = g^b mod p
+  ```
+
+- **Shared Secret Calculation**: Alice and Bob each calculate the shared secret using the other’s public key and their own private key:
+  
+  ```
+  Shared Secret = B^a mod p (for Alice)
+  Shared Secret = A^b mod p (for Bob)
+  ```

Diffie-Hellman/diffie.png

@@ -0,0 +1,64 @@
+extern crate rand;
+use std::io::{self, Write};
+
+fn mod_exp(base: u64, exp: u64, modulus: u64) -> u64 {
+    let mut result = 1;
+    let mut base = base % modulus;
+    let mut exp = exp;
+
+    while exp > 0 {
+        if exp % 2 == 1 {
+            result = (result * base) % modulus;
+        }
+        exp = exp >> 1;
+        base = (base * base) % modulus;
+    }
+    result
+}
+
+fn read_input(prompt: &str) -> u64 {
+    print!("{}", prompt);
+    io::stdout().flush().unwrap(); // Ensure prompt is printed before reading
+    let mut input = String::new();
+    io::stdin().read_line(&mut input).unwrap();
+    input.trim().parse().unwrap()
+}
+
+fn main() {
+    // Get the prime number (p) and base (g) from user input
+    let p = read_input("Enter a prime number (p): ");
+    let g = read_input("Enter the base (g): ");
+
+    // Get private keys for Alice and Bob
+    let a = read_input("Enter Alice's private key: ");
+    let b = read_input("Enter Bob's private key: ");
+
+    // Compute the public keys
+    let avar = mod_exp(g, a, p); // Alice's public key
+    let bvar = mod_exp(g, b, p); // Bob's public key
+
+    println!("\nPrime number (p): {}", p);
+    println!("Base (g): {}", g);
+    println!("Alice's private key: {}", a);
+    println!("Bob's private key: {}", b);
+    println!("Alice's public key: {}", avar);
+    println!("Bob's public key: {}", bvar);
+
+    // Exchange public keys (this is done securely in a real-world scenario)
+    println!("\nExchanging public keys...");
+
+    // Alice computes the shared secret using Bob's public key
+    let shared_secret_alice = mod_exp(bvar, a, p);
+    // Bob computes the shared secret using Alice's public key
+    let shared_secret_bob = mod_exp(avar, b, p);
+
+    println!("\nAlice's computed shared secret: {}", shared_secret_alice);
+    println!("Bob's computed shared secret: {}", shared_secret_bob);
+
+    // Verify that the shared secrets are the same
+    if shared_secret_alice == shared_secret_bob {
+        println!("\nThe shared secret is the same! Key exchange successful.");
+    } else {
+        println!("\nThe shared secrets do not match. Something went wrong.");
+    }
+}