zus_common/

encryption.rs

//! DES Encryption support for ZUS RPC protocol
//!
//! This module provides DES-ECB encryption/decryption compatible with
//! the C++ and Java ZUS implementations.
//!
//! ## Encryption Details
//!
//! - Algorithm: DES (Data Encryption Standard)
//! - Mode: ECB (Electronic Codebook)
//! - Padding: Zero-padding to 8-byte blocks
//! - Key size: 8 bytes (64 bits, with 56 effective bits)
//!
//! ## Cross-Language Compatibility
//!
//! This implementation is compatible with:
//! - C++: `zus::DesEncrypt` class in `des.cpp`
//! - Java: `CryptUtil.desEncrypt()` / `CryptUtil.desDecrypt()` in `CryptUtil.java`
//!
//! ## Example
//!
//! ```rust
//! use zus_common::encryption::{DesEncryptor, encrypt_des, decrypt_des};
//!
//! // Using the simple functions
//! let key = b"12345678";
//! let plaintext = b"Hello, World!";
//! let encrypted = encrypt_des(plaintext, key).unwrap();
//! let decrypted = decrypt_des(&encrypted, key).unwrap();
//! assert_eq!(&decrypted[..plaintext.len()], plaintext);
//!
//! // Using the DesEncryptor for multiple operations
//! let encryptor = DesEncryptor::new(key);
//! let encrypted = encryptor.encrypt(plaintext).unwrap();
//! let decrypted = encryptor.decrypt(&encrypted).unwrap();
//! ```

use des::{
  Des,
  cipher::{BlockDecrypt, BlockEncrypt, KeyInit},
};

use crate::{Result, ZusError};

/// DES block size in bytes
pub const DES_BLOCK_SIZE: usize = 8;

/// DES key size in bytes
pub const DES_KEY_SIZE: usize = 8;

/// DES Encryptor for encrypting and decrypting data using DES-ECB mode.
///
/// This is compatible with the C++ `zus::DesEncrypt` and Java `CryptUtil` implementations.
#[derive(Clone)]
pub struct DesEncryptor {
  cipher: Des,
}

impl DesEncryptor {
  /// Create a new DES encryptor with the given key.
  ///
  /// # Arguments
  /// * `key` - 8-byte DES key
  ///
  /// # Panics
  /// Panics if the key is not exactly 8 bytes.
  pub fn new(key: &[u8]) -> Self {
    assert_eq!(key.len(), DES_KEY_SIZE, "DES key must be exactly 8 bytes");
    let cipher = Des::new_from_slice(key).expect("Invalid key length");
    Self { cipher }
  }

  /// Create a new DES encryptor, returning an error if the key is invalid.
  ///
  /// # Arguments
  /// * `key` - 8-byte DES key
  ///
  /// # Returns
  /// * `Ok(DesEncryptor)` if the key is valid
  /// * `Err(ZusError)` if the key is not 8 bytes
  pub fn try_new(key: &[u8]) -> Result<Self> {
    if key.len() != DES_KEY_SIZE {
      return Err(ZusError::Encryption(format!(
        "DES key must be exactly 8 bytes, got {}",
        key.len()
      )));
    }
    let cipher = Des::new_from_slice(key).map_err(|e| ZusError::Encryption(e.to_string()))?;
    Ok(Self { cipher })
  }

  /// Encrypt data using DES-ECB mode with zero-padding.
  ///
  /// The data is padded with zeros to the next 8-byte boundary if necessary.
  ///
  /// # Arguments
  /// * `data` - Data to encrypt (any length)
  ///
  /// # Returns
  /// * Encrypted data (length is multiple of 8)
  pub fn encrypt(&self, data: &[u8]) -> Result<Vec<u8>> {
    // Calculate padded length (round up to next 8-byte boundary)
    let padded_len = if data.is_empty() {
      DES_BLOCK_SIZE
    } else {
      data.len().div_ceil(DES_BLOCK_SIZE) * DES_BLOCK_SIZE
    };

    // Create padded buffer with zeros
    let mut buffer = vec![0u8; padded_len];
    buffer[..data.len()].copy_from_slice(data);

    // Encrypt each 8-byte block
    for chunk in buffer.chunks_exact_mut(DES_BLOCK_SIZE) {
      let block: &mut [u8; 8] = chunk.try_into().unwrap();
      self.cipher.encrypt_block(block.into());
    }

    Ok(buffer)
  }

  /// Decrypt data using DES-ECB mode.
  ///
  /// Note: The decrypted data may contain trailing zeros from padding.
  /// The caller should know the original data length to trim padding.
  ///
  /// # Arguments
  /// * `data` - Encrypted data (length must be multiple of 8)
  ///
  /// # Returns
  /// * Decrypted data (same length as input, may contain padding zeros)
  pub fn decrypt(&self, data: &[u8]) -> Result<Vec<u8>> {
    if !data.len().is_multiple_of(DES_BLOCK_SIZE) {
      return Err(ZusError::Encryption(format!(
        "Encrypted data length must be multiple of 8, got {}",
        data.len()
      )));
    }

    let mut buffer = data.to_vec();

    // Decrypt each 8-byte block
    for chunk in buffer.chunks_exact_mut(DES_BLOCK_SIZE) {
      let block: &mut [u8; 8] = chunk.try_into().unwrap();
      self.cipher.decrypt_block(block.into());
    }

    Ok(buffer)
  }

  /// Encrypt data in-place starting from the given offset.
  ///
  /// This matches the C++ `DesEncrypt::Encrypt(std::string& data, offset)` method.
  ///
  /// # Arguments
  /// * `data` - Mutable data buffer (will be extended if necessary)
  /// * `offset` - Starting offset for encryption
  pub fn encrypt_in_place(&self, data: &mut Vec<u8>, offset: usize) -> Result<()> {
    if offset >= data.len() {
      return Ok(());
    }

    let len = data.len() - offset;
    let padded_len = len.div_ceil(DES_BLOCK_SIZE) * DES_BLOCK_SIZE;

    // Extend buffer if needed for padding
    if offset + padded_len > data.len() {
      data.resize(offset + padded_len, 0);
    }

    // Encrypt each 8-byte block
    let slice = &mut data[offset..];
    for chunk in slice.chunks_exact_mut(DES_BLOCK_SIZE) {
      let block: &mut [u8; 8] = chunk.try_into().unwrap();
      self.cipher.encrypt_block(block.into());
    }

    Ok(())
  }

  /// Decrypt data in-place starting from the given offset.
  ///
  /// This matches the C++ `DesEncrypt::Decrypt(std::string& data, offset)` method.
  ///
  /// # Arguments
  /// * `data` - Mutable data buffer
  /// * `offset` - Starting offset for decryption
  pub fn decrypt_in_place(&self, data: &mut [u8], offset: usize) -> Result<()> {
    if offset >= data.len() {
      return Ok(());
    }

    let slice = &mut data[offset..];
    if !slice.len().is_multiple_of(DES_BLOCK_SIZE) {
      return Err(ZusError::Encryption(format!(
        "Data length from offset must be multiple of 8, got {}",
        slice.len()
      )));
    }

    // Decrypt each 8-byte block
    for chunk in slice.chunks_exact_mut(DES_BLOCK_SIZE) {
      let block: &mut [u8; 8] = chunk.try_into().unwrap();
      self.cipher.decrypt_block(block.into());
    }

    Ok(())
  }
}

impl std::fmt::Debug for DesEncryptor {
  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
    f.debug_struct("DesEncryptor").field("cipher", &"[...]").finish()
  }
}

/// Encrypt data using DES-ECB mode with zero-padding.
///
/// # Arguments
/// * `data` - Data to encrypt
/// * `key` - 8-byte DES key
///
/// # Returns
/// * Encrypted data
pub fn encrypt_des(data: &[u8], key: &[u8]) -> Result<Vec<u8>> {
  let encryptor = DesEncryptor::try_new(key)?;
  encryptor.encrypt(data)
}

/// Decrypt data using DES-ECB mode.
///
/// # Arguments
/// * `data` - Encrypted data (length must be multiple of 8)
/// * `key` - 8-byte DES key
///
/// # Returns
/// * Decrypted data (may contain padding zeros)
pub fn decrypt_des(data: &[u8], key: &[u8]) -> Result<Vec<u8>> {
  let encryptor = DesEncryptor::try_new(key)?;
  encryptor.decrypt(data)
}

#[cfg(test)]
mod tests {
  use super::*;

  #[test]
  fn test_encrypt_decrypt_roundtrip() {
    let key = b"12345678";
    let plaintext = b"Hello, World!";

    let encrypted = encrypt_des(plaintext, key).unwrap();
    assert_eq!(encrypted.len(), 16); // 13 bytes padded to 16

    let decrypted = decrypt_des(&encrypted, key).unwrap();
    assert_eq!(&decrypted[..plaintext.len()], plaintext);
  }

  #[test]
  fn test_encrypt_exact_block_size() {
    let key = b"12345678";
    let plaintext = b"12345678"; // Exactly 8 bytes

    let encrypted = encrypt_des(plaintext, key).unwrap();
    assert_eq!(encrypted.len(), 8);

    let decrypted = decrypt_des(&encrypted, key).unwrap();
    assert_eq!(&decrypted[..], plaintext);
  }

  #[test]
  fn test_encrypt_multiple_blocks() {
    let key = b"testkey!";
    let plaintext = b"This is a longer message that spans multiple DES blocks.";

    let encrypted = encrypt_des(plaintext, key).unwrap();
    assert_eq!(encrypted.len() % 8, 0);

    let decrypted = decrypt_des(&encrypted, key).unwrap();
    assert_eq!(&decrypted[..plaintext.len()], plaintext);
  }

  #[test]
  fn test_encrypt_empty() {
    let key = b"12345678";
    let plaintext = b"";

    let encrypted = encrypt_des(plaintext, key).unwrap();
    assert_eq!(encrypted.len(), 8); // Empty is padded to one block

    let decrypted = decrypt_des(&encrypted, key).unwrap();
    // All zeros after decryption
    assert!(decrypted.iter().all(|&b| b == 0));
  }

  #[test]
  fn test_invalid_key_length() {
    let key = b"short";
    let result = encrypt_des(b"test", key);
    assert!(result.is_err());
  }

  #[test]
  fn test_invalid_decrypt_length() {
    let key = b"12345678";
    let invalid_data = vec![1, 2, 3, 4, 5]; // Not multiple of 8
    let result = decrypt_des(&invalid_data, key);
    assert!(result.is_err());
  }

  #[test]
  fn test_encryptor_reuse() {
    let key = b"mykey123";
    let encryptor = DesEncryptor::new(key);

    let data1 = b"First message";
    let data2 = b"Second message";

    let enc1 = encryptor.encrypt(data1).unwrap();
    let enc2 = encryptor.encrypt(data2).unwrap();

    let dec1 = encryptor.decrypt(&enc1).unwrap();
    let dec2 = encryptor.decrypt(&enc2).unwrap();

    assert_eq!(&dec1[..data1.len()], data1);
    assert_eq!(&dec2[..data2.len()], data2);
  }

  #[test]
  fn test_in_place_encryption() {
    let key = b"12345678";
    let encryptor = DesEncryptor::new(key);

    let mut data = b"Hello, World!".to_vec();
    let original_len = data.len();

    encryptor.encrypt_in_place(&mut data, 0).unwrap();
    assert_eq!(data.len() % 8, 0);

    encryptor.decrypt_in_place(&mut data, 0).unwrap();
    assert_eq!(&data[..original_len], b"Hello, World!");
  }

  #[test]
  fn test_in_place_with_offset() {
    let key = b"12345678";
    let encryptor = DesEncryptor::new(key);

    // Simulate a message with header + body
    let mut data = vec![0x01, 0x02, 0x03, 0x04]; // 4-byte header
    data.extend_from_slice(b"Body data here"); // Body

    let header = data[..4].to_vec();

    encryptor.encrypt_in_place(&mut data, 4).unwrap();
    assert_eq!(&data[..4], &header[..]); // Header unchanged

    encryptor.decrypt_in_place(&mut data, 4).unwrap();
    assert_eq!(&data[4..4 + 14], b"Body data here");
  }
}