Function encrypt 

pub fn encrypt(text: &str, rails: usize) -> Result<String>

Encrypts text using the Rail Fence cipher algorithm.

Arranges the input text in a zigzag pattern across the specified number of rails, then reads the text row by row to create the ciphertext.

Arguments

• text - The plaintext to encrypt
• rails - Number of rails (rows) to use (must be ≥ 2)

Returns

Returns the encrypted text as a Result<String>.

Algorithm

1. Create N empty strings for each rail
2. Traverse the text, placing each character on the appropriate rail
3. Use a direction indicator to create the zigzag pattern
4. Concatenate all rails to form the ciphertext

Zigzag Pattern

• Start at rail 0, move down
• When reaching the last rail, change direction to move up
• When reaching the first rail, change direction to move down
• Continue until all characters are placed

Examples

use ruscrypt::classical::rail_fence;

// With 3 rails: "HELLO" becomes "HOELL"
let result = rail_fence::encrypt("HELLO", 3).unwrap();

// With 2 rails: "HELLO" becomes "HLOEL"  
let result2 = rail_fence::encrypt("HELLO", 2).unwrap();

Edge Cases

• If rails < 2, returns the original text unchanged
• Preserves all characters including spaces and punctuation
• Empty text returns empty string

Examples found in repository

examples/demo.rs (line 81)

fn demo_classical_ciphers() -> Result<()> {
    let sample_text = "HELLO WORLD";
    
    // Caesar Cipher Demo
    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");
    
    // Vigenère Cipher Demo
    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");
    
    // Rail Fence Cipher Demo
    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");
    
    // Playfair Cipher Demo
    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(())
}