old_crypto_rs/transposition/

irregular.rs

//! An irregular transposition cipher used in the VIC cipher.
//!
//! This cipher is a variant of columnar transposition where the grid is filled in an irregular
//! pattern, creating triangular areas that are filled after the regular areas. It's specifically
//! designed for use in the VIC cipher.
//!
//! The cipher uses two special positions (rank 0 and rank 1) in the key to define triangular
//! areas. These areas are filled separately from the rest of the grid, creating a more complex
//! transposition pattern.
//!
//! # Examples
//!
//! ```
//! use old_crypto_rs::{Block, IrregularTransposition};
//!
//! let cipher = IrregularTransposition::new("SUBWAY").unwrap();
//! let plaintext = b"ATTACKATDAWN";
//! let mut ciphertext = vec![0u8; plaintext.len()];
//! cipher.encrypt(&mut ciphertext, plaintext);
//! ```

use crate::{helpers, Block};

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

#[derive(Debug)]
pub struct IrregularTransposition {
    #[allow(dead_code)]
    key: String,
    tkey: Vec<u8>,
    rank_pos: [usize; 2],
    tkey_order: Vec<usize>,
}

impl IrregularTransposition {
    /// Creates a new irregular transposition cipher.
    ///
    /// The key is converted to a numeric representation where each character's position
    /// in alphabetical order determines its rank. The positions of ranks 0 and 1 define
    /// the triangular areas used in the irregular transposition.
    ///
    /// # Arguments
    ///
    /// * `key` - The key string used for transposition. Must not be empty.
    ///
    /// # Returns
    ///
    /// Returns `Ok(IrregularTransposition)` if the key is valid, or an error message
    /// if the key is empty.
    ///
    /// # Errors
    ///
    /// Returns an error if the key is empty.
    ///
    /// # Examples
    ///
    /// ```
    /// use old_crypto_rs::IrregularTransposition;
    ///
    /// let cipher = IrregularTransposition::new("SUBWAY").unwrap();
    /// ```
    pub fn new(key: &str) -> Result<Self> {
        if key.is_empty() {
            return Err(Error::EmptyKeys.into());
        }
        let tkey = helpers::to_numeric(key);
        let pos0 = tkey.iter().position(|&x| x == 0).unwrap();
        let pos1 = tkey.iter().position(|&x| x == 1).unwrap();
        
        let klen = tkey.len();
        let mut tkey_order = vec![0; klen];
        for i in 0..klen {
            tkey_order[i] = tkey.iter().position(|&x| x == i as u8).unwrap();
        }

        Ok(IrregularTransposition {
            key: key.to_string(),
            tkey,
            rank_pos: [pos0, pos1],
            tkey_order,
        })
    }

    /// Computes which cells are "irregular" (triangular areas) for a given message length.
    ///
    /// The triangular areas start at the positions of ranks 0 and 1 in the key, and expand
    /// to the right as row numbers increase. A cell at position (r, c) is in a triangular
    /// area if it's at or beyond `rank_pos[0] + r` or `rank_pos[1] + r`, and within the
    /// grid width.
    ///
    /// # Arguments
    ///
    /// * `r` - The row index (0-based)
    /// * `c` - The column index (0-based)
    ///
    /// # Returns
    ///
    /// Returns `true` if the cell is in a triangular area, `false` otherwise.
    #[inline]
    fn is_in_triangular_area(&self, r: usize, c: usize) -> bool {
        // The triangle starts at (row 0, start_col)
        // It expands to the right: at row `i`, it covers columns `start_col + i` to `klen - 1`
        (c >= self.rank_pos[0] + r || c >= self.rank_pos[1] + r) && c < self.tkey.len()
    }
}

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

    /// Encrypts the source data using irregular transposition.
    ///
    /// The encryption process works in three phases:
    ///
    /// 1. **Fill non-triangular areas**: The plaintext is written into a grid row by row,
    ///    filling only the cells that are NOT in the triangular areas (defined by ranks 0 and 1).
    ///    This creates the "regular" part of the transposition.
    ///
    /// 2. **Fill triangular areas**: After the regular areas are filled, the remaining plaintext
    ///    continues filling the triangular areas row by row. These are the cells at positions
    ///    (r, c) where `c >= rank_pos[0] + r` or `c >= rank_pos[1] + r`.
    ///
    /// 3. **Read column by column**: The ciphertext is generated by reading the grid column by
    ///    column in the order specified by `tkey_order` (alphabetical order of the key). Only
    ///    active cells (those that were filled) are read.
    ///
    /// # 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, IrregularTransposition};
    ///
    /// let cipher = IrregularTransposition::new("SUBWAY").unwrap();
    /// let plaintext = b"ATTACKATDAWN";
    /// 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 len = src.len();
        if klen == 0 || len == 0 {
            return 0;
        }
        let rows = (len + klen - 1) / klen;

        let mut grid = vec![0u8; rows * klen];
        let mut active = vec![0u8; (rows * klen + 7) / 8];
        let mut src_idx = 0;

        // Phase 1: Fill non-triangular areas row by row
        for r in 0..rows {
            let row_off = r * klen;
            for c in 0..klen {
                if !self.is_in_triangular_area(r, c) && src_idx < len {
                    let idx = row_off + c;
                    grid[idx] = src[src_idx];
                    active[idx >> 3] |= 1 << (idx & 7);
                    src_idx += 1;
                }
            }
        }

        // Phase 2: Fill triangular areas row by row
        for r in 0..rows {
            let row_off = r * klen;
            for c in 0..klen {
                if self.is_in_triangular_area(r, c) && src_idx < len {
                    let idx = row_off + c;
                    grid[idx] = src[src_idx];
                    active[idx >> 3] |= 1 << (idx & 7);
                    src_idx += 1;
                }
            }
        }

        // Read out column by column according to tkey
        let mut dst_idx = 0;
        for &col in &self.tkey_order {
            for r in 0..rows {
                let idx = r * klen + col;
                if (active[idx >> 3] & (1 << (idx & 7))) != 0 {
                    dst[dst_idx] = grid[idx];
                    dst_idx += 1;
                }
            }
        }

        len
    }

    /// Decrypts the source data using irregular transposition.
    ///
    /// The decryption process reverses the encryption:
    ///
    /// 1. **Determine active cells**: First, we determine which cells in the grid are active
    ///    by simulating the filling process (non-triangular areas first, then triangular areas).
    ///    This tells us which cells contain actual ciphertext data.
    ///
    /// 2. **Fill grid from columns**: The ciphertext is read column by column in the order
    ///    specified by `tkey_order`, filling the grid's active cells. This reverses the
    ///    column-wise reading done during encryption.
    ///
    /// 3. **Read in two phases**: The plaintext is recovered by reading the grid in two phases:
    ///    - First phase: Read row by row from non-triangular areas
    ///    - Second phase: Read row by row from triangular areas
    ///    This reverses the two-phase filling done during encryption.
    ///
    /// # 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`).
    ///
    /// # Examples
    ///
    /// ```
    /// use old_crypto_rs::{Block, IrregularTransposition};
    ///
    /// let cipher = IrregularTransposition::new("SUBWAY").unwrap();
    /// let ciphertext = b"ATWATADCAKN";
    /// 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();
        let len = src.len();
        if klen == 0 || len == 0 {
            return 0;
        }
        let rows = (len + klen - 1) / klen;

        // Determine active cells
        let mut active = vec![0u8; (rows * klen + 7) / 8];
        let mut count = 0;
        for r in 0..rows {
            let row_off = r * klen;
            for c in 0..klen {
                if !self.is_in_triangular_area(r, c) && count < len {
                    let idx = row_off + c;
                    active[idx >> 3] |= 1 << (idx & 7);
                    count += 1;
                }
            }
        }
        for r in 0..rows {
            let row_off = r * klen;
            for c in 0..klen {
                if self.is_in_triangular_area(r, c) && count < len {
                    let idx = row_off + c;
                    active[idx >> 3] |= 1 << (idx & 7);
                    count += 1;
                }
            }
        }

        // Fill grid from src column by column
        let mut grid = vec![0u8; rows * klen];
        let mut src_idx = 0;
        for &col in &self.tkey_order {
            for r in 0..rows {
                let idx = r * klen + col;
                if (active[idx >> 3] & (1 << (idx & 7))) != 0 {
                    grid[idx] = src[src_idx];
                    src_idx += 1;
                }
            }
        }

        // Read out row by row, first non-mask then mask
        let mut dst_idx = 0;
        for r in 0..rows {
            let row_off = r * klen;
            for c in 0..klen {
                let idx = row_off + c;
                if ((active[idx >> 3] & (1 << (idx & 7))) != 0) && !self.is_in_triangular_area(r, c) {
                    dst[dst_idx] = grid[idx];
                    dst_idx += 1;
                }
            }
        }
        for r in 0..rows {
            let row_off = r * klen;
            for c in 0..klen {
                let idx = row_off + c;
                if ((active[idx >> 3] & (1 << (idx & 7))) != 0) && self.is_in_triangular_area(r, c) {
                    dst[dst_idx] = grid[idx];
                    dst_idx += 1;
                }
            }
        }

        len
    }
}

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

    #[test]
    fn test_irregular_transposition_mask() {
        let key = "94735236270398134";
        let c = IrregularTransposition::new(key).unwrap();

        // Row 0:
        // Rank 0 is at pos 10.
        // Rank 1 is at pos 14.
        for col in 10..17 {
            assert!(c.is_in_triangular_area(0, col), "Row 0 col {} should be true", col);
        }
        for col in 0..10 {
            assert!(!c.is_in_triangular_area(0, col), "Row 0 col {} should be false", col);
        }

        // Row 1: col 11 to 16 are true for the first triangle.
        for col in 11..17 {
            assert!(c.is_in_triangular_area(1, col), "Row 1 col {} should be true", col);
        }
        assert!(!c.is_in_triangular_area(1, 10));

        // Row 0: rank 1 is at pos 14.
        assert!(c.is_in_triangular_area(0, 14));
    }
}