feat: add Vernam cipher implementation (#984)

Author: AliAlimohammadi

DIRECTORY.md

@@ -54,6 +54,7 @@
     * [Tea](https://github.com/TheAlgorithms/Rust/blob/master/src/ciphers/tea.rs)
     * [Theoretical ROT13](https://github.com/TheAlgorithms/Rust/blob/master/src/ciphers/theoretical_rot13.rs)
     * [Transposition](https://github.com/TheAlgorithms/Rust/blob/master/src/ciphers/transposition.rs)
+    * [Vernam](https://github.com/TheAlgorithms/Rust/blob/master/src/ciphers/vernam.rs)
     * [Vigenere](https://github.com/TheAlgorithms/Rust/blob/master/src/ciphers/vigenere.rs)
     * [XOR](https://github.com/TheAlgorithms/Rust/blob/master/src/ciphers/xor.rs)
   * Compression

src/ciphers/mod.rs

@@ -19,6 +19,7 @@ mod sha3;
 mod tea;
 mod theoretical_rot13;
 mod transposition;
+mod vernam;
 mod vigenere;
 mod xor;
 
@@ -46,5 +47,6 @@ pub use self::sha3::{sha3_224, sha3_256, sha3_384, sha3_512};
 pub use self::tea::{tea_decrypt, tea_encrypt};
 pub use self::theoretical_rot13::theoretical_rot13;
 pub use self::transposition::transposition;
+pub use self::vernam::{vernam_decrypt, vernam_encrypt};
 pub use self::vigenere::vigenere;
 pub use self::xor::xor;

src/ciphers/vernam.rs

@@ -0,0 +1,244 @@
+//! Vernam Cipher
+//!
+//! The Vernam cipher is a symmetric stream cipher where plaintext is combined
+//! with a random or pseudorandom stream of data (the key) of the same length.
+//! This implementation uses the alphabet A-Z with modular arithmetic.
+//!
+//! # Algorithm
+//!
+//! For encryption: C = (P + K) mod 26
+//! For decryption: P = (C - K) mod 26
+//!
+//! Where P is plaintext, K is key, and C is ciphertext (all converted to 0-25 range)
+
+/// Encrypts a plaintext string using the Vernam cipher.
+///
+/// The function converts all input to uppercase and works only with letters A-Z.
+/// The key is repeated cyclically if it's shorter than the plaintext.
+///
+/// # Arguments
+///
+/// * `plaintext` - The text to encrypt (will be converted to uppercase)
+/// * `key` - The encryption key (will be converted to uppercase, must not be empty)
+///
+/// # Returns
+///
+/// The encrypted ciphertext as an uppercase string
+///
+/// # Panics
+///
+/// Panics if the key is empty
+///
+/// # Example
+///
+/// ```
+/// use the_algorithms_rust::ciphers::vernam_encrypt;
+///
+/// let ciphertext = vernam_encrypt("HELLO", "KEY");
+/// assert_eq!(ciphertext, "RIJVS");
+/// ```
+pub fn vernam_encrypt(plaintext: &str, key: &str) -> String {
+    assert!(!key.is_empty(), "Key cannot be empty");
+
+    let plaintext = plaintext.to_uppercase();
+    let key = key.to_uppercase();
+
+    let plaintext_bytes: Vec<u8> = plaintext
+        .chars()
+        .filter(|c| c.is_ascii_alphabetic())
+        .map(|c| (c as u8) - b'A')
+        .collect();
+
+    let key_bytes: Vec<u8> = key
+        .chars()
+        .filter(|c| c.is_ascii_alphabetic())
+        .map(|c| (c as u8) - b'A')
+        .collect();
+
+    assert!(
+        !key_bytes.is_empty(),
+        "Key must contain at least one letter"
+    );
+
+    plaintext_bytes
+        .iter()
+        .enumerate()
+        .map(|(i, &p)| {
+            let k = key_bytes[i % key_bytes.len()];
+            let encrypted = (p + k) % 26;
+            (encrypted + b'A') as char
+        })
+        .collect()
+}
+
+/// Decrypts a ciphertext string using the Vernam cipher.
+///
+/// The function converts all input to uppercase and works only with letters A-Z.
+/// The key is repeated cyclically if it's shorter than the ciphertext.
+///
+/// # Arguments
+///
+/// * `ciphertext` - The text to decrypt (will be converted to uppercase)
+/// * `key` - The decryption key (will be converted to uppercase, must not be empty)
+///
+/// # Returns
+///
+/// The decrypted plaintext as an uppercase string
+///
+/// # Panics
+///
+/// Panics if the key is empty
+///
+/// # Example
+///
+/// ```
+/// use the_algorithms_rust::ciphers::vernam_decrypt;
+///
+/// let plaintext = vernam_decrypt("RIJVS", "KEY");
+/// assert_eq!(plaintext, "HELLO");
+/// ```
+pub fn vernam_decrypt(ciphertext: &str, key: &str) -> String {
+    assert!(!key.is_empty(), "Key cannot be empty");
+
+    let ciphertext = ciphertext.to_uppercase();
+    let key = key.to_uppercase();
+
+    let ciphertext_bytes: Vec<u8> = ciphertext
+        .chars()
+        .filter(|c| c.is_ascii_alphabetic())
+        .map(|c| (c as u8) - b'A')
+        .collect();
+
+    let key_bytes: Vec<u8> = key
+        .chars()
+        .filter(|c| c.is_ascii_alphabetic())
+        .map(|c| (c as u8) - b'A')
+        .collect();
+
+    assert!(
+        !key_bytes.is_empty(),
+        "Key must contain at least one letter"
+    );
+
+    ciphertext_bytes
+        .iter()
+        .enumerate()
+        .map(|(i, &c)| {
+            let k = key_bytes[i % key_bytes.len()];
+            // Add 26 before modulo to handle negative numbers properly
+            let decrypted = (c + 26 - k) % 26;
+            (decrypted + b'A') as char
+        })
+        .collect()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_encrypt_basic() {
+        assert_eq!(vernam_encrypt("HELLO", "KEY"), "RIJVS");
+    }
+
+    #[test]
+    fn test_decrypt_basic() {
+        assert_eq!(vernam_decrypt("RIJVS", "KEY"), "HELLO");
+    }
+
+    #[test]
+    fn test_encrypt_decrypt_roundtrip() {
+        let plaintext = "HELLO";
+        let key = "KEY";
+        let encrypted = vernam_encrypt(plaintext, key);
+        let decrypted = vernam_decrypt(&encrypted, key);
+        assert_eq!(decrypted, plaintext);
+    }
+
+    #[test]
+    fn test_encrypt_decrypt_long_text() {
+        let plaintext = "THEQUICKBROWNFOXJUMPSOVERTHELAZYDOG";
+        let key = "SECRET";
+        let encrypted = vernam_encrypt(plaintext, key);
+        let decrypted = vernam_decrypt(&encrypted, key);
+        assert_eq!(decrypted, plaintext);
+    }
+
+    #[test]
+    fn test_lowercase_input() {
+        // Should convert to uppercase
+        assert_eq!(vernam_encrypt("hello", "key"), "RIJVS");
+        assert_eq!(vernam_decrypt("rijvs", "key"), "HELLO");
+    }
+
+    #[test]
+    fn test_mixed_case_input() {
+        assert_eq!(vernam_encrypt("HeLLo", "KeY"), "RIJVS");
+        assert_eq!(vernam_decrypt("RiJvS", "kEy"), "HELLO");
+    }
+
+    #[test]
+    fn test_single_character() {
+        assert_eq!(vernam_encrypt("A", "B"), "B");
+        assert_eq!(vernam_decrypt("B", "B"), "A");
+    }
+
+    #[test]
+    fn test_key_wrapping() {
+        // Key shorter than plaintext, should wrap around
+        let encrypted = vernam_encrypt("AAAA", "BC");
+        assert_eq!(encrypted, "BCBC");
+        let decrypted = vernam_decrypt(&encrypted, "BC");
+        assert_eq!(decrypted, "AAAA");
+    }
+
+    #[test]
+    fn test_alphabet_boundary() {
+        // Test wrapping at alphabet boundaries
+        assert_eq!(vernam_encrypt("Z", "B"), "A"); // 25 + 1 = 26 -> 0
+        assert_eq!(vernam_decrypt("A", "B"), "Z"); // 0 - 1 = -1 -> 25
+    }
+
+    #[test]
+    fn test_same_key_as_plaintext() {
+        let text = "HELLO";
+        let encrypted = vernam_encrypt(text, text);
+        assert_eq!(encrypted, "OIWWC");
+    }
+
+    #[test]
+    fn test_with_spaces_and_numbers() {
+        // Non-alphabetic characters should be filtered out
+        let encrypted = vernam_encrypt("HELLO 123 WORLD", "KEY");
+        let expected = vernam_encrypt("HELLOWORLD", "KEY");
+        assert_eq!(encrypted, expected);
+    }
+
+    #[test]
+    #[should_panic(expected = "Key cannot be empty")]
+    fn test_empty_key_encrypt() {
+        vernam_encrypt("HELLO", "");
+    }
+
+    #[test]
+    #[should_panic(expected = "Key cannot be empty")]
+    fn test_empty_key_decrypt() {
+        vernam_decrypt("HELLO", "");
+    }
+
+    #[test]
+    #[should_panic(expected = "Key must contain at least one letter")]
+    fn test_key_with_only_numbers() {
+        vernam_encrypt("HELLO", "12345");
+    }
+
+    #[test]
+    fn test_empty_plaintext() {
+        assert_eq!(vernam_encrypt("", "KEY"), "");
+    }
+
+    #[test]
+    fn test_plaintext_with_only_numbers() {
+        assert_eq!(vernam_encrypt("12345", "KEY"), "");
+    }
+}