use anyhow::Result;
use colored::*;
use ruscrypt::classical::{caesar, rail_fence, vigenere, playfair};
use ruscrypt::stream::rc4;
use ruscrypt::block::{aes, des};
use ruscrypt::asym::{rsa, dh};
use ruscrypt::hash::{md5, sha1, sha256};
fn main() -> Result<()> {
print_demo_banner();
println!("{}", "🔐 Classical Ciphers Demo".cyan().bold());
println!("{}", "═══════════════════════════".cyan());
demo_classical_ciphers()?;
println!("\n{}", "🌊 Stream Ciphers Demo".green().bold());
println!("{}", "══════════════════════".green());
demo_stream_ciphers()?;
println!("\n{}", "🧱 Block Ciphers Demo".blue().bold());
println!("{}", "═════════════════════".blue());
demo_block_ciphers()?;
println!("\n{}", "🔑 Asymmetric Cryptography Demo".purple().bold());
println!("{}", "════════════════════════════════".purple());
demo_asymmetric_crypto()?;
println!("\n{}", "🔢 Hash Functions Demo".magenta().bold());
println!("{}", "══════════════════════".magenta());
demo_hash_functions()?;
println!("\n{}", "✨ Complete RusCrypt Demo Finished!".bright_green().bold());
println!("{}", "🎓 All algorithms successfully demonstrated.".cyan());
Ok(())
}
fn print_demo_banner() {
println!("{}", r"
____ ____ _ ____
| _ \ _ _ ___ / ___|_ __ _ _ _ __ | |_ | _ \ ___ _ __ ___ ___
| |_) | | | / __| | | '__| | | | '_ \| __| | | | |/ _ \ '_ ` _ \ / _ \
| _ <| |_| \__ \ |___| | | |_| | |_) | |_ | |_| | __/ | | | | | (_) |
|_| \_\\__,_|___/\____|_| \__, | .__/ \__| |____/ \___|_| |_| |_|\___/
|___/|_|
".yellow());
println!("{}", "🚀 RusCrypt Comprehensive Demo".yellow().bold());
println!("{}\n", "Showcasing ALL implemented cryptographic algorithms".bright_blue().italic());
}
fn demo_classical_ciphers() -> Result<()> {
let sample_text = "HELLO WORLD";
println!("{}", "📜 Caesar Cipher:".yellow());
let shift = 3;
let caesar_encrypted = caesar::encrypt(sample_text, shift)?;
let caesar_decrypted = caesar::decrypt(&caesar_encrypted, shift)?;
println!(" Original: {}", sample_text.white());
println!(" Shift: {}", shift.to_string().cyan());
println!(" Encrypted: {}", caesar_encrypted.green());
println!(" Decrypted: {}", caesar_decrypted.blue());
println!(" ⚠️ Security: Educational only - easily broken");
println!("\n{}", "🔤 Vigenère Cipher:".yellow());
let keyword = "KEY";
let vigenere_encrypted = vigenere::encrypt(sample_text, keyword)?;
let vigenere_decrypted = vigenere::decrypt(&vigenere_encrypted, keyword)?;
println!(" Original: {}", sample_text.white());
println!(" Keyword: {}", keyword.cyan());
println!(" Encrypted: {}", vigenere_encrypted.green());
println!(" Decrypted: {}", vigenere_decrypted.blue());
println!(" ⚠️ Security: Educational only - vulnerable to frequency analysis");
println!("\n{}", "🚂 Rail Fence Cipher:".yellow());
let rails = 3;
let railfence_encrypted = rail_fence::encrypt(sample_text, rails)?;
let railfence_decrypted = rail_fence::decrypt(&railfence_encrypted, rails)?;
println!(" Original: {}", sample_text.white());
println!(" Rails: {}", rails.to_string().cyan());
println!(" Encrypted: {}", railfence_encrypted.green());
println!(" Decrypted: {}", railfence_decrypted.blue());
println!(" ⚠️ Security: Educational only - simple transposition");
println!("\n{}", "🎯 Playfair Cipher:".yellow());
let playfair_key = "MONARCHY";
let playfair_text = "HELLO";
let playfair_encrypted = playfair::encrypt(playfair_text, playfair_key)?;
let playfair_decrypted = playfair::decrypt(&playfair_encrypted, playfair_key)?;
println!(" Original: {}", playfair_text.white());
println!(" Key: {}", playfair_key.cyan());
println!(" Encrypted: {}", playfair_encrypted.green());
println!(" Decrypted: {}", playfair_decrypted.blue());
println!(" ⚠️ Security: Educational only - digraph substitution");
Ok(())
}
fn demo_stream_ciphers() -> Result<()> {
let sample_text = "Hello, World! This is a secret message.";
println!("{}", "🔐 RC4 Stream Cipher (Base64):".yellow());
let key = "secretkey123";
let rc4_encrypted_b64 = rc4::encrypt(sample_text, key, "base64")?;
let rc4_decrypted_b64 = rc4::decrypt(&rc4_encrypted_b64, key, "base64")?;
println!(" Original: {}", sample_text.white());
println!(" Key: {}", key.cyan());
println!(" Encrypted (Base64): {}", rc4_encrypted_b64.green());
println!(" Decrypted: {}", rc4_decrypted_b64.blue());
println!("\n{}", "🔐 RC4 Stream Cipher (Hex):".yellow());
let rc4_encrypted_hex = rc4::encrypt(sample_text, key, "hex")?;
let rc4_decrypted_hex = rc4::decrypt(&rc4_encrypted_hex, key, "hex")?;
println!(" Original: {}", sample_text.white());
println!(" Key: {}", key.cyan());
println!(" Encrypted (Hex): {}", rc4_encrypted_hex.green());
println!(" Decrypted: {}", rc4_decrypted_hex.blue());
println!(" ⚠️ Security: DEPRECATED - Known vulnerabilities, educational use only");
Ok(())
}
fn demo_block_ciphers() -> Result<()> {
let sample_text = "This is a block cipher test message!";
println!("{}", "🛡️ AES (Advanced Encryption Standard):".yellow());
let password = "strongpassword";
println!("\n 📌 AES-128 ECB Mode:");
let aes128_ecb = aes::encrypt(sample_text, password, "128", "ECB", "base64")?;
let aes128_decrypted = aes::decrypt(&aes128_ecb, password, "128", "ECB", "base64")?;
println!(" Original: {}", sample_text.white());
println!(" Password: {}", password.cyan());
println!(" Encrypted: {}", aes128_ecb.green());
println!(" Decrypted: {}", aes128_decrypted.blue());
println!("\n 📌 AES-256 CBC Mode:");
let aes256_cbc = aes::encrypt(sample_text, password, "256", "CBC", "hex")?;
let aes256_decrypted = aes::decrypt(&aes256_cbc, password, "256", "CBC", "hex")?;
println!(" Original: {}", sample_text.white());
println!(" Password: {}", password.cyan());
println!(" Encrypted: {}", aes256_cbc.green());
println!(" Decrypted: {}", aes256_decrypted.blue());
println!(" ✅ Security: Modern standard - recommended for production");
println!("\n{}", "🔒 DES (Data Encryption Standard):".yellow());
let des_key = "8charkey";
println!("\n 📌 DES ECB Mode:");
let des_ecb = des::encrypt(sample_text, des_key, "ECB", "base64")?;
let des_ecb_decrypted = des::decrypt(&des_ecb, des_key, "ECB", "base64")?;
println!(" Original: {}", sample_text.white());
println!(" Key: {}", des_key.cyan());
println!(" Encrypted: {}", des_ecb.green());
println!(" Decrypted: {}", des_ecb_decrypted.blue());
println!("\n 📌 DES CBC Mode:");
let des_cbc = des::encrypt(sample_text, des_key, "CBC", "hex")?;
let des_cbc_decrypted = des::decrypt(&des_cbc, des_key, "CBC", "hex")?;
println!(" Original: {}", sample_text.white());
println!(" Key: {}", des_key.cyan());
println!(" Encrypted: {}", des_cbc.green());
println!(" Decrypted: {}", des_cbc_decrypted.blue());
println!(" ⚠️ Security: DEPRECATED - 56-bit key too small, educational use only");
Ok(())
}
fn demo_asymmetric_crypto() -> Result<()> {
let sample_text = "Asymmetric encryption test!";
println!("{}", "🔐 RSA (Rivest-Shamir-Adleman):".yellow());
for key_size in ["512", "1024"] {
println!("\n 📌 RSA-{} Encryption:", key_size);
let (encrypted, private_key) = rsa::encrypt(sample_text, key_size, "base64", "n:e")?;
let decrypted = rsa::decrypt(&encrypted, &private_key, "base64")?;
println!(" Original: {}", sample_text.white());
println!(" Key Size: {} bits", key_size.cyan());
println!(" Encrypted: {}...", encrypted[..50].green());
println!(" Private Key: {}...", private_key[..20].yellow());
println!(" Decrypted: {}", decrypted.blue());
}
println!(" ✅ Security: Secure with ≥2048 bits (demo uses smaller for speed)");
println!("\n{}", "🤝 Diffie-Hellman Key Exchange:".yellow());
println!(" 📌 Educational Concept Demonstration:");
let alice = dh::DHParticipant::new();
let mut bob = dh::DHParticipant::new();
println!(" 👩 Alice generates keys:");
println!(" Private: {} (secret)", alice.private_key.to_string().red());
println!(" Public: {} (shared)", alice.public_key.to_string().green());
println!(" 👨 Bob generates keys:");
println!(" Private: {} (secret)", bob.private_key.to_string().red());
println!(" Public: {} (shared)", bob.public_key.to_string().green());
let shared_secret = bob.compute_shared_secret(alice.public_key)?;
println!(" 🤝 Computed shared secret: {}", shared_secret.to_string().cyan());
println!(" ✅ Security: Secure with proper parameters and authentication");
Ok(())
}
fn demo_hash_functions() -> Result<()> {
let sample_texts = vec![
"Hello, World!",
"RusCrypt is awesome!",
"Secure hashing with Rust",
"Small change",
"small change", ];
println!("{}", "Hash Function Comparison:".yellow());
println!("{}", "═════════════════════════".yellow());
for (i, text) in sample_texts.iter().enumerate() {
println!("\n{} {}:", "Sample".cyan(), (i + 1).to_string().cyan());
println!(" Input: {}", text.white());
let md5_hash = md5::hash(text)?;
println!(" MD5 (128-bit): {}", md5_hash.bright_red());
let sha1_hash = sha1::hash(text)?;
println!(" SHA-1 (160-bit): {}", sha1_hash.bright_yellow());
let sha256_hash = sha256::hash(text)?;
println!(" SHA-256(256-bit): {}", sha256_hash.bright_green());
if i == 3 { println!(" 💡 Notice how 'Small change' vs 'small change' produces completely different hashes!");
}
}
println!("\n{}", "Security Status:".yellow());
println!(" ❌ MD5: BROKEN - Collision attacks possible");
println!(" ⚠️ SHA-1: DEPRECATED - Use only for legacy compatibility");
println!(" ✅ SHA-256: SECURE - Recommended for modern applications");
println!("\n{}", "🔍 Hash Consistency Verification:".yellow());
let test_input = "consistency_test";
let hash1 = sha256::hash(test_input)?;
let hash2 = sha256::hash(test_input)?;
println!(" Input: {}", test_input.white());
println!(" Hash 1: {}", hash1.green());
println!(" Hash 2: {}", hash2.green());
println!(" Match: {}", if hash1 == hash2 { "✅ Perfect consistency".bright_green() } else { "❌ Error!".bright_red() });
Ok(())
}