use super::Encryptor;
 use blowfish::cipher::{block_padding::Pkcs7, BlockDecryptMut, BlockEncryptMut, KeyIvInit};
 use blowfish::Blowfish;
 use rand::Rng;
 
 type BlowfishCbcEnc = cbc::Encryptor<Blowfish>;
 #[allow(dead_code)]
 type BlowfishCbcDec = cbc::Decryptor<Blowfish>;
 
 /// Blowfish cipher implementation with CBC mode
 pub struct BlowfishEncryptor {
     key: Vec<u8>,
 }
 
 impl BlowfishEncryptor {
     /// Creates a new Blowfish encryptor with the given key
     /// Blowfish supports key sizes from 4 to 56 bytes
     pub fn new(key: &str) -> Self {
         let key_data = key.as_bytes();
 
         // Ensure key is at least 4 bytes and at most 56 bytes
         let key = if key_data.len() < 4 {
             println!(
                 "[Blowfish] WARNING: Key length {} is less than 4 bytes, padding to 4 bytes",
                 key_data.len()
             );
             // Pad short keys
             let mut padded = key_data.to_vec();
             while padded.len() < 4 {
                 padded.push(0);
             }
             padded
         } else if key_data.len() > 56 {
             println!(
                 "[Blowfish] WARNING: Key length {} exceeds 56 bytes, truncating to 56 bytes",
                 key_data.len()
             );
             // Truncate long keys
             key_data[..56].to_vec()
         } else {
             key_data.to_vec()
         };
 
         println!("[Blowfish] Using key length: {} bytes", key.len());
 
         Self { key }
     }
 }
 
 impl Encryptor for BlowfishEncryptor {
     fn encrypt(&self, data: &[u8]) -> Result<Vec<u8>, String> {
         // Generate random IV (8 bytes for Blowfish)
         let mut rng = rand::thread_rng();
         let mut iv = [0u8; 8];
         rng.fill(&mut iv);
 
         println!(
             "[Blowfish] Generated random IV for encryption: {:02x?}",
             &iv
         );
 
         let cipher = BlowfishCbcEnc::new_from_slices(&self.key, &iv)
             .map_err(|e| format!("Failed to create cipher: {:?}", e))?;
 
         let ciphertext = cipher.encrypt_padded_vec_mut::<Pkcs7>(data);
 
         // Prepend IV to ciphertext
         let mut result = iv.to_vec();
         result.extend_from_slice(&ciphertext);
 
         Ok(result)
     }
 
     fn decrypt(&self, data: &[u8]) -> Result<Vec<u8>, String> {
         if data.len() < 8 {
             return Err("Ciphertext too short to contain IV".to_string());
         }
 
         // Extract IV from beginning of data
         let iv: [u8; 8] = data[..8].try_into().unwrap();
         let ciphertext = &data[8..];
 
         println!("[Blowfish] Extracted IV for decryption: {:02x?}", &iv);
 
         let cipher = BlowfishCbcDec::new_from_slices(&self.key, &iv)
             .map_err(|e| format!("Failed to create cipher: {:?}", e))?;
 
         cipher
             .decrypt_padded_vec_mut::<Pkcs7>(ciphertext)
             .map_err(|e| format!("Decryption error: {:?}", e))
     }
 
     fn key_size(&self) -> usize {
         self.key.len()
     }
 
     fn algorithm_name(&self) -> &'static str {
         "Blowfish-CBC"
     }
 
     fn uses_iv(&self) -> bool {
         true
     }
 
     fn generate_decrypt_code(&self) -> &'static str {
         r#"/// Decrypts Blowfish CBC encrypted data using the provided key
 ///
 /// Returns `Ok(Vec<u8>)` with decrypted data if successful, otherwise returns an error.
 pub fn decrypt_blowfish(data: &[u8], key: &[u8]) -> Result<Vec<u8>, String> {
     use blowfish::cipher::{block_padding::Pkcs7, BlockDecryptMut, KeyIvInit};
     use blowfish::Blowfish;
     
     if data.len() < 8 {
         return Err("Ciphertext too short to contain IV".to_string());
     }
     
     if key.is_empty() || key.len() > 56 {
         return Err("Key must be between 1 and 56 bytes for Blowfish".to_string());
     }
     
     let iv: [u8; 8] = data[..8].try_into().unwrap();
     let ciphertext = &data[8..];
     
     type BlowfishCbcDec = cbc::Decryptor<Blowfish>;
     let cipher = BlowfishCbcDec::new_from_slices(key, &iv)
         .map_err(|e| format!("Failed to create cipher: {:?}", e))?;
     
     cipher
         .decrypt_padded_vec_mut::<Pkcs7>(ciphertext)
         .map_err(|e| format!("Decryption error: {:?}", e))
 }"#
     }
 
     fn required_dependencies(&self) -> Vec<(&'static str, &'static str)> {
         vec![("blowfish", "0.9"), ("cbc", "0.1")]
     }
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
 
     #[test]
     fn test_blowfish_encrypt_decrypt() {
         let encryptor = BlowfishEncryptor::new("my-secret-key-123");
         let plaintext = b"Hello, World!";
 
         let encrypted = encryptor.encrypt(plaintext).unwrap();
         assert_ne!(encrypted, plaintext);
 
         let decrypted = encryptor.decrypt(&encrypted).unwrap();
         assert_eq!(decrypted, plaintext);
     }
 
     #[test]
     fn test_blowfish_different_keys() {
         let encryptor1 = BlowfishEncryptor::new("key1");
         let encryptor2 = BlowfishEncryptor::new("key2");
         let plaintext = b"Test data";
 
         let encrypted1 = encryptor1.encrypt(plaintext).unwrap();
         let encrypted2 = encryptor2.encrypt(plaintext).unwrap();
 
         assert_ne!(encrypted1, encrypted2);
     }
 
     #[test]
     fn test_blowfish_empty_data() {
         let encryptor = BlowfishEncryptor::new("key");
         let empty: &[u8] = &[];
 
         let encrypted = encryptor.encrypt(empty).unwrap();
         // Blowfish with padding will have at least one block (8 bytes)
         assert!(encrypted.len() >= 8);
 
         let decrypted = encryptor.decrypt(&encrypted).unwrap();
         assert_eq!(decrypted.len(), 0);
     }
 
     #[test]
     fn test_blowfish_short_key() {
         let encryptor = BlowfishEncryptor::new("ab");
         let plaintext = b"Test";
 
         let encrypted = encryptor.encrypt(plaintext).unwrap();
         let decrypted = encryptor.decrypt(&encrypted).unwrap();
         assert_eq!(decrypted, plaintext);
     }
 
     #[test]
     fn test_blowfish_long_key() {
         let encryptor = BlowfishEncryptor::new(
             "this-is-a-very-long-key-that-exceeds-56-bytes-and-should-be-truncated",
         );
         let plaintext = b"Test";
 
         let encrypted = encryptor.encrypt(plaintext).unwrap();
         let decrypted = encryptor.decrypt(&encrypted).unwrap();
         assert_eq!(decrypted, plaintext);
     }
 
     #[test]
     fn test_blowfish_wrong_key_decryption() {
         let encryptor1 = BlowfishEncryptor::new("correct-key");
         let encryptor2 = BlowfishEncryptor::new("wrong-key");
         let plaintext = b"Secret message";
 
         let encrypted = encryptor1.encrypt(plaintext).unwrap();
         let result = encryptor2.decrypt(&encrypted);
 
         // Decryption with wrong key should fail or produce garbage
         assert!(result.is_err() || result.unwrap() != plaintext);
     }
 
     #[test]
     fn test_blowfish_long_data() {
         let encryptor = BlowfishEncryptor::new("secret-key");
         let plaintext = b"This is a much longer message that exceeds the Blowfish block size";
 
         let encrypted = encryptor.encrypt(plaintext).unwrap();
         assert_ne!(encrypted, plaintext);
 
         let decrypted = encryptor.decrypt(&encrypted).unwrap();
         assert_eq!(decrypted, plaintext);
     }
 
     #[test]
     fn test_blowfish_binary_data() {
         let encryptor = BlowfishEncryptor::new("key");
         let plaintext: Vec<u8> = (0..=255).collect();
 
         let encrypted = encryptor.encrypt(&plaintext).unwrap();
         assert_ne!(encrypted, plaintext);
 
         let decrypted = encryptor.decrypt(&encrypted).unwrap();
         assert_eq!(decrypted, plaintext);
     }
 }

© 2024 - 2026 djnn, inc • generated with stagit