old_crypto_rs/transposition/

regular.rs

//! Transposition cipher implementation.
//!
//! This module implements a columnar transposition cipher, which rearranges the plaintext
//! by writing it in rows of a fixed length (determined by the key), then reading out the
//! columns in an order determined by the alphabetical order of the key letters.
//!
//! # Examples
//!
//! ```
//! use old_crypto_rs::{Block, Transposition};
//!
//! let cipher = Transposition::new("ZEBRAS").unwrap();
//! let plaintext = b"WEAREDISCOVEREDFLEEATONCE";
//! let mut ciphertext = vec![0u8; plaintext.len()];
//! cipher.encrypt(&mut ciphertext, plaintext);
//! ```
//!

use crate::{helpers, Block};

use eyre::Result;
use crate::error::Error;

/// A columnar transposition cipher.
/// 
#[derive(Debug)]
pub struct Transposition {
    #[allow(dead_code)]
    key: String,
    tkey: Vec<u8>,
}

impl Transposition {
    /// Creates a new regular columnar transposition cipher.
    pub fn new(key: &str) -> Result<Self> {
        if key.is_empty() {
            return Err(Error::EmptyKeys.into());
        }
        Ok(Transposition {
            key: key.to_string(),
            tkey: helpers::to_numeric(key),
        })
    }
}

impl Block for Transposition {
    fn block_size(&self) -> usize {
        self.tkey.len()
    }

    /// Encrypts the source data using columnar transposition.
    ///
    /// The encryption process works as follows:
    ///
    /// 1. **Write plaintext in rows**: The plaintext is written into a grid row by row,
    ///    with each row having a length equal to the key length.
    ///
    /// 2. **Read columns in key order**: The ciphertext is generated by reading the grid
    ///    column by column in the order determined by the alphabetical order of the key
    ///    letters. For example, if the key is "ZEBRAS", the columns are read in the order
    ///    corresponding to "ABERSZ" (alphabetical order of key letters).
    ///
    /// # Arguments
    ///
    /// * `dst` - The destination buffer where encrypted data will be written
    /// * `src` - The source plaintext data to encrypt
    ///
    /// # Returns
    ///
    /// Returns the number of bytes written to `dst` (equal to the length of `src`).
    ///
    /// # Examples
    ///
    /// ```
    /// use old_crypto_rs::{Block, Transposition};
    ///
    /// let cipher = Transposition::new("ZEBRAS").unwrap();
    /// let plaintext = b"WEAREDISCOVEREDFLEEATONCE";
    /// let mut ciphertext = vec![0u8; plaintext.len()];
    /// let n = cipher.encrypt(&mut ciphertext, plaintext);
    /// assert_eq!(n, plaintext.len());
    /// ```
    ///
    fn encrypt(&self, dst: &mut [u8], src: &[u8]) -> usize {
        let klen = self.tkey.len();
        let mut offset = 0;
        for i in 0..klen {
            let j = self.tkey.iter().position(|&x| x == i as u8).unwrap();
            let mut curr = j;
            while curr < src.len() {
                dst[offset] = src[curr];
                offset += 1;
                curr += klen;
            }
        }
        src.len()
    }

    /// Decrypts the source data using columnar transposition.
    ///
    /// The decryption process reverses the encryption:
    ///
    /// 1. **Determine column structure**: Calculate how many complete rows exist and how
    ///    many columns have an extra character (when the plaintext length doesn't divide
    ///    evenly by the key length).
    ///
    /// 2. **Read columns in key order**: Read the ciphertext column by column in the order
    ///    determined by the alphabetical order of the key letters. Each column is read
    ///    according to its calculated length.
    ///
    /// 3. **Write back row by row**: Place each character into its original position in
    ///    the grid, effectively reconstructing the original row-by-row layout of the
    ///    plaintext.
    ///
    /// # Arguments
    ///
    /// * `dst` - The destination buffer where decrypted data will be written
    /// * `src` - The source ciphertext data to decrypt
    ///
    /// # Returns
    ///
    /// Returns the number of bytes written to `dst` (equal to the length of `src`),
    /// or 0 if the key length is 0 or the source is empty.
    ///
    /// # Examples
    ///
    /// ```
    /// use old_crypto_rs::{Block, Transposition};
    ///
    /// let cipher = Transposition::new("ZEBRAS").unwrap();
    /// let ciphertext = b"EVLNACDTESEAROFODEECWIREE";
    /// let mut plaintext = vec![0u8; ciphertext.len()];
    /// let n = cipher.decrypt(&mut plaintext, ciphertext);
    /// assert_eq!(n, ciphertext.len());
    /// ```
    ///
    fn decrypt(&self, dst: &mut [u8], src: &[u8]) -> usize {
        let klen = self.tkey.len();
        if klen == 0 || src.is_empty() {
            return 0;
        }

        let scol = src.len() / klen;
        let extra = src.len() % klen;

        let mut current = 0;
        for j in 0..klen {
            let ind = self.tkey.iter().position(|&x| x == j as u8).unwrap();
            let how_many = if ind < extra { scol + 1 } else { scol };

            let mut dst_idx = ind;
            for k in 0..how_many {
                dst[dst_idx] = src[current + k];
                dst_idx += klen;
            }
            current += how_many;
        }
        src.len()
    }
}


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

    use rstest::rstest;

    #[test]
    fn test_new_cipher() {
        let c = Transposition::new("ABCDE").unwrap();
        assert_eq!(c.key, "ABCDE");
        assert_eq!(c.tkey, vec![0, 1, 2, 3, 4]);
    }

    #[test]
    fn test_new_cipher_empty() {
        let c = Transposition::new("");
        assert!(c.is_err());
    }

    #[test]
    fn test_transposition_block_size() {
        let c = Transposition::new("ABCDE").unwrap();
        assert_eq!(c.block_size(), 5);
    }

    #[rstest]
    #[case("ARABESQUE", "AATNIITN2MIHAAXOOTCT2RNXDNENNAOXMB2TW4DTGKP3ES1TISUY3", "ATTACKATDAWNATPOINT42X23XSENDMOREMUNITIONSBYNIGHTX123")]
    #[case("SUBWAY", "CWI2DUNG3TDP2EEIN1AAATXOIBTTTT4SRTYXAAOXNMOI2KNN3MNSH", "ATTACKATDAWNATPOINT42X23XSENDMOREMUNITIONSBYNIGHTX123")]
    #[case("PORTABLE", "CA2DIN3KTXMTITO3ROHAP2OIGTANSMSXADIXENTTWTEUB1AN4NNY2", "ATTACKATDAWNATPOINT42X23XSENDMOREMUNITIONSBYNIGHTX123")]
    #[case("SUBWAY", "AAGGDAVGAAVGFGVVFAVGDAFX", "AFDFADAGAAAAVVVVGFGVGGGX")]
    #[case("PRIVACY", "DFDDAAVVDGDADDDVGDFFDAAAGDDX", "DGDDDAGDDGAFADDFDADVDVFAADVX")]
    fn test_transposition_encrypt(#[case] key: &str, #[case] ct: &str, #[case] pt: &str) {
        let c = Transposition::new(key).unwrap();
        let mut dst = vec![0u8; pt.len()];
        c.encrypt(&mut dst, pt.as_bytes());
        assert_eq!(String::from_utf8(dst).unwrap(), ct);
    }

    #[rstest]
    #[case("ARABESQUE", "AATNIITN2MIHAAXOOTCT2RNXDNENNAOXMB2TW4DTGKP3ES1TISUY3", "ATTACKATDAWNATPOINT42X23XSENDMOREMUNITIONSBYNIGHTX123")]
    #[case("SUBWAY", "CWI2DUNG3TDP2EEIN1AAATXOIBTTTT4SRTYXAAOXNMOI2KNN3MNSH", "ATTACKATDAWNATPOINT42X23XSENDMOREMUNITIONSBYNIGHTX123")]
    #[case("PORTABLE", "CA2DIN3KTXMTITO3ROHAP2OIGTANSMSXADIXENTTWTEUB1AN4NNY2", "ATTACKATDAWNATPOINT42X23XSENDMOREMUNITIONSBYNIGHTX123")]
    #[case("SUBWAY", "AAGGDAVGAAVGFGVVFAVGDAFX", "AFDFADAGAAAAVVVVGFGVGGGX")]
    #[case("PRIVACY", "DFDDAAVVDGDADDDVGDFFDAAAGDDX", "DGDDDAGDDGAFADDFDADVDVFAADVX")]
    fn test_transposition_decrypt(#[case] key: &str, #[case] ct: &str, #[case] pt: &str) {
        let c = Transposition::new(key).unwrap();
        let mut dst = vec![0u8; pt.len()];
        c.decrypt(&mut dst, ct.as_bytes());
        assert_eq!(String::from_utf8(dst).unwrap(), pt);
    }

}