reproduce tea3 from C implementation

src/main.rs

@@ -1,6 +1,7 @@
 mod lfsr;
 mod period;
 mod tea3;
+mod tea3_from_c;
 
 use clap::{Parser, Subcommand};
 

src/tea3_from_c.rs

@@ -0,0 +1,157 @@
+#[derive(Debug, Clone)]
+pub struct Tea3FromC {
+    key_register: [u8; 10],
+    iv: u64,
+    next_skip_rounds: usize,
+}
+
+impl Tea3FromC {
+    pub fn new(frame_number: u32, key_register: [u8; 10]) -> Self {
+        Self {
+            key_register,
+            iv: Self::compute_iv(frame_number),
+            next_skip_rounds: 51,
+        }
+    }
+
+    pub fn reset(&mut self, frame_number: u32, key_register: [u8; 10]) {
+        self.key_register = key_register;
+        self.iv = Self::compute_iv(frame_number);
+        self.next_skip_rounds = 51;
+    }
+
+    pub fn next_byte(&mut self) -> u8 {
+        for _ in 0..self.next_skip_rounds {
+            self.step();
+        }
+
+        self.next_skip_rounds = 19;
+        (self.iv >> 56) as u8
+    }
+
+    pub fn keystream(&mut self, len: usize) -> Vec<u8> {
+        (0..len).map(|_| self.next_byte()).collect()
+    }
+
+    fn step(&mut self) {
+        // Step 1: Derive non-linear feedback byte with the SBOX and feed back into key register
+        let b_sbox_out = TEA3_SBOX[(self.key_register[7] ^ self.key_register[2]) as usize] ^ self.key_register[0];
+        self.key_register.copy_within(1..10, 0);
+        self.key_register[9] = b_sbox_out;
+
+        // Step 2: Compute 3 bytes derived from current state
+        let b_deriv_byte12 = tea3_state_word_to_newbyte(((self.iv >> 8) & 0xffff) as u16, &TEA3_LUT_A);
+        let b_deriv_byte56 = tea3_state_word_to_newbyte(((self.iv >> 40) & 0xffff) as u16, &TEA3_LUT_B);
+        let b_reord_byte4 = tea3_reorder_state_byte(((self.iv >> 32) & 0xff) as u8);
+
+        // Step 3: Combine current state with state derived values and XOR in key derived SBOX output
+        let b_new_byte = (((self.iv >> 56) as u8) ^ b_reord_byte4 ^ b_deriv_byte12 ^ b_sbox_out) & 0xff;
+        let b_mix_byte = b_deriv_byte56 as u64;
+
+        // Step 4: Update 64 bits state
+        self.iv = ((self.iv << 8) ^ (b_mix_byte << 40)) | (b_new_byte as u64);
+    }
+
+    pub fn compute_iv(frame_number: u32) -> u64 {
+        let mut dw_xorred = frame_number ^ 0xC43A7D51;
+        dw_xorred = dw_xorred.rotate_left(8);
+        let qw_iv = ((frame_number as u64) << 32) | (dw_xorred as u64);
+        qw_iv.rotate_right(8)
+    }
+
+    pub fn iv(&self) -> u64 {
+        self.iv
+    }
+
+    pub fn key_register(&self) -> &[u8; 10] {
+        &self.key_register
+    }
+}
+
+pub fn tea3_from_c(frame_number: u32, key_register: [u8; 10], len: usize) -> Vec<u8> {
+    let mut cipher = Tea3FromC::new(frame_number, key_register);
+    cipher.keystream(len)
+}
+
+fn tea3_state_word_to_newbyte(w_st: u16, aw_lut: &[u16; 8]) -> u8 {
+    let mut b_st0 = w_st as u8;
+    let mut b_st1 = (w_st >> 8) as u8;
+    let mut b_out = 0u8;
+
+    for i in 0..8 {
+        let b_dist = ((b_st0 >> 5) & 3) | ((b_st1 >> 3) & 12);
+        if (aw_lut[i] & (1 << b_dist)) != 0 {
+            b_out |= 1 << i;
+        }
+
+        b_st0 = b_st0.rotate_right(1);
+        b_st1 = b_st1.rotate_right(1);
+    }
+
+    b_out
+}
+
+fn tea3_reorder_state_byte(b_st_byte: u8) -> u8 {
+    let mut b_out = 0u8;
+    b_out |= (b_st_byte << 6) & 0x40;
+    b_out |= (b_st_byte << 1) & 0x20;
+    b_out |= (b_st_byte << 2) & 0x98;
+    b_out |= (b_st_byte >> 4) & 0x04;
+    b_out |= (b_st_byte >> 3) & 0x01;
+    b_out |= (b_st_byte >> 6) & 0x02;
+    b_out
+}
+
+const TEA3_SBOX: [u8; 256] = [
+    0x7D, 0xBF, 0x7B, 0x92, 0xAE, 0x7C, 0xF2, 0x10, 0x5A, 0x0F, 0x61, 0x7A, 0x98, 0x76, 0x07, 0x64,
+    0xEE, 0x89, 0xF7, 0xBA, 0xC2, 0x02, 0x0D, 0xE8, 0x56, 0x2E, 0xCA, 0x58, 0xC0, 0xFA, 0x2A, 0x01,
+    0x57, 0x6E, 0x3F, 0x4B, 0x9C, 0xDA, 0xA6, 0x5B, 0x41, 0x26, 0x50, 0x24, 0x3E, 0xF8, 0x0A, 0x86,
+    0xB6, 0x5C, 0x34, 0xE9, 0x06, 0x88, 0x1F, 0x39, 0x33, 0xDF, 0xD9, 0x78, 0xD8, 0xA8, 0x51, 0xB2,
+    0x09, 0xCD, 0xA1, 0xDD, 0x8E, 0x62, 0x69, 0x4D, 0x23, 0x2B, 0xA9, 0xE1, 0x53, 0x94, 0x90, 0x1E,
+    0xB4, 0x3B, 0xF9, 0x4E, 0x36, 0xFE, 0xB5, 0xD1, 0xA2, 0x8D, 0x66, 0xCE, 0xB7, 0xC4, 0x60, 0xED,
+    0x96, 0x4F, 0x31, 0x79, 0x35, 0xEB, 0x8F, 0xBB, 0x54, 0x14, 0xCB, 0xDE, 0x6B, 0x2D, 0x19, 0x82,
+    0x80, 0xAC, 0x17, 0x05, 0xFF, 0xA4, 0xCF, 0xC6, 0x6F, 0x65, 0xE6, 0x74, 0xC8, 0x93, 0xF4, 0x7E,
+    0xF3, 0x43, 0x9F, 0x71, 0xAB, 0x9A, 0x0B, 0x87, 0x55, 0x70, 0x0C, 0xAD, 0xCC, 0xA5, 0x44, 0xE7,
+    0x46, 0x45, 0x03, 0x30, 0x1A, 0xEA, 0x67, 0x99, 0xDB, 0x4A, 0x42, 0xD7, 0xAA, 0xE4, 0xC2, 0xD5,
+    0xF0, 0x77, 0x20, 0xC3, 0x3C, 0x16, 0xB9, 0xE2, 0xEF, 0x6C, 0x3D, 0x1B, 0x22, 0x84, 0x2F, 0x81,
+    0x1D, 0xB1, 0x3A, 0xE5, 0x73, 0x40, 0xD0, 0x18, 0xC7, 0x6A, 0x9E, 0x91, 0x48, 0x27, 0x95, 0x72,
+    0x68, 0x0E, 0x00, 0xFC, 0xC5, 0x5F, 0xF1, 0xF5, 0x38, 0x11, 0x7F, 0xE3, 0x5E, 0x13, 0xAF, 0x37,
+    0xE0, 0x8A, 0x49, 0x1C, 0x21, 0x47, 0xD4, 0xDC, 0xB0, 0xEC, 0x83, 0x28, 0xB8, 0xF6, 0xA7, 0xC9,
+    0x63, 0x59, 0xBD, 0x32, 0x85, 0x08, 0xBE, 0xD3, 0xFD, 0x4C, 0x2C, 0xFB, 0xA0, 0xC1, 0x9D, 0xB3,
+    0x52, 0x8C, 0x5D, 0x29, 0x6D, 0x04, 0xBC, 0x25, 0x15, 0x8B, 0x12, 0x9B, 0xD6, 0x75, 0xA3, 0x97,
+];
+
+const TEA3_LUT_A: [u16; 8] = [0x92A7, 0xA761, 0x974C, 0x6B8C, 0x29CE, 0x176C, 0x39D4, 0x7463];
+const TEA3_LUT_B: [u16; 8] = [0x9D58, 0xA46D, 0x176C, 0x79C4, 0xC62B, 0xB2C9, 0x4D93, 0x2E93];
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_tea3_from_c_vectors() {
+        let cases: [([u8; 10], u32, [u8; 10]); 2] = [
+            (
+                [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00],
+                0x11111111,
+                [0x06, 0xA6, 0x58, 0x8C, 0x5D, 0x9A, 0x99, 0x6D, 0xD2, 0x5E],
+            ),
+            (
+                [0xA7, 0x98, 0x39, 0xE4, 0xBA, 0x88, 0xEE, 0x54, 0xA0, 0x29],
+                0x01234567,
+                [0x02, 0x49, 0x1E, 0xF5, 0x57, 0xC5, 0x1C, 0x17, 0x73, 0x0C],
+            ),
+        ];
+
+        for (key, frame, expected) in cases {
+            let mut cipher = Tea3FromC::new(frame, key);
+            let got = cipher.keystream(expected.len());
+            assert_eq!(got.as_slice(), &expected, "frame = {frame:#010X}");
+        }
+    }
+
+    #[test]
+    fn test_compute_iv() {
+        assert_eq!(Tea3FromC::compute_iv(0x11111111), 0xD5111111112B6C40);
+    }
+}