use derive_more::Display;
use rand::Rng;
#[derive(Clone, Copy, Debug, Eq, PartialEq, Display)]
pub enum Parity {
#[display("even")]
Even,
#[display("odd")]
Odd,
}
impl Parity {
#[must_use]
pub const fn from_cp_number(cp_number: u16) -> Self {
if cp_number & 1 == 0 {
Parity::Even
} else {
Parity::Odd
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct CwAdvance {
pub cp_number: u16,
pub parity: Parity,
pub active: [u8; 8],
pub current: [u8; 8],
pub next: [u8; 8],
}
#[derive(Debug)]
pub struct CwGenerator {
slots: [[u8; 8]; 2],
cw_number: u16,
}
impl CwGenerator {
pub fn new(rng: &mut impl Rng) -> Self {
let mut slots = [[0u8; 8]; 2];
Self::fill_key(&mut slots[1], rng);
Self {
slots,
cw_number: 0,
}
}
pub fn advance(&mut self, rng: &mut impl Rng) -> CwAdvance {
let written = (self.cw_number & 1) as usize;
let kept = 1 - written;
Self::fill_key(&mut self.slots[written], rng);
let current_cp = self.cw_number;
let next_cp = self.cw_number.wrapping_add(1);
let advance = CwAdvance {
cp_number: current_cp,
parity: Parity::from_cp_number(current_cp),
active: self.slots[kept],
current: self.slots[kept],
next: self.slots[written],
};
self.cw_number = next_cp;
advance
}
fn fill_key(key: &mut [u8; 8], rng: &mut impl Rng) {
rng.fill_bytes(key);
key[3] = key[0].wrapping_add(key[1]).wrapping_add(key[2]);
key[7] = key[4].wrapping_add(key[5]).wrapping_add(key[6]);
}
}
#[cfg(test)]
mod tests {
use super::*;
struct StepRng(u8);
impl rand::TryRng for StepRng {
type Error = std::convert::Infallible;
fn try_next_u32(&mut self) -> Result<u32, Self::Error> {
let mut buf = [0u8; 4];
self.try_fill_bytes(&mut buf)?;
Ok(u32::from_le_bytes(buf))
}
fn try_next_u64(&mut self) -> Result<u64, Self::Error> {
let mut buf = [0u8; 8];
self.try_fill_bytes(&mut buf)?;
Ok(u64::from_le_bytes(buf))
}
fn try_fill_bytes(&mut self, dst: &mut [u8]) -> Result<(), Self::Error> {
for byte in dst {
*byte = self.0;
self.0 = self.0.wrapping_add(1);
}
Ok(())
}
}
fn checksum_fix(mut key: [u8; 8]) -> [u8; 8] {
key[3] = key[0].wrapping_add(key[1]).wrapping_add(key[2]);
key[7] = key[4].wrapping_add(key[5]).wrapping_add(key[6]);
key
}
#[test]
fn checksum_bytes_match_csa_formula() {
let mut rng = StepRng(0);
let mut key = [0u8; 8];
CwGenerator::fill_key(&mut key, &mut rng);
assert_eq!(key[3], key[0].wrapping_add(key[1]).wrapping_add(key[2]));
assert_eq!(key[7], key[4].wrapping_add(key[5]).wrapping_add(key[6]));
}
#[test]
fn init_prefills_odd_slot_only() {
let mut rng = StepRng(1);
let generator = CwGenerator::new(&mut rng);
assert_eq!(generator.slots[0], [0u8; 8]);
assert_ne!(generator.slots[1], [0u8; 8]);
assert_eq!(generator.cw_number, 0);
}
#[test]
fn first_advance_writes_even_slot_and_keeps_init_key_as_current() {
let mut rng = StepRng(1);
let mut generator = CwGenerator::new(&mut rng);
let init_odd_key = generator.slots[1];
let step = generator.advance(&mut rng);
assert_eq!(step.cp_number, 0);
assert_eq!(step.parity, Parity::Even); assert_eq!(step.current, init_odd_key); assert_eq!(step.next, generator.slots[0]); assert_eq!(step.active, step.current);
assert_eq!(generator.cw_number, 1);
}
#[test]
fn second_advance_writes_odd_slot_and_keeps_first_advance_key_as_current() {
let mut rng = StepRng(1);
let mut generator = CwGenerator::new(&mut rng);
let first = generator.advance(&mut rng);
let second = generator.advance(&mut rng);
assert_eq!(second.cp_number, 1);
assert_eq!(second.parity, Parity::Odd); assert_eq!(second.current, first.next); assert_eq!(second.next, generator.slots[1]);
assert_eq!(second.active, second.current);
}
#[test]
fn matches_independent_reference_vectors() {
const VECTORS: [(u16, &str, &str); 8] = [
(0, "0102030605060712", "090a0b1e0d0e0f2a"),
(1, "090a0b1e0d0e0f2a", "1112133615161742"),
(2, "1112133615161742", "191a1b4e1d1e1f5a"),
(3, "191a1b4e1d1e1f5a", "2122236625262772"),
(4, "2122236625262772", "292a2b7e2d2e2f8a"),
(5, "292a2b7e2d2e2f8a", "31323396353637a2"),
(6, "31323396353637a2", "393a3bae3d3e3fba"),
(7, "393a3bae3d3e3fba", "414243c6454647d2"),
];
fn hex8(s: &str) -> [u8; 8] {
let mut out = [0u8; 8];
for (i, byte) in out.iter_mut().enumerate() {
*byte = u8::from_str_radix(&s[i * 2 .. i * 2 + 2], 16).unwrap();
}
out
}
let mut rng = StepRng(1);
let mut generator = CwGenerator::new(&mut rng);
for (cp_number, current_hex, next_hex) in VECTORS {
let step = generator.advance(&mut rng);
assert_eq!(step.cp_number, cp_number);
assert_eq!(
step.current,
hex8(current_hex),
"current mismatch at cp={cp_number}"
);
assert_eq!(step.next, hex8(next_hex), "next mismatch at cp={cp_number}");
assert_eq!(
step.active, step.current,
"active must equal current at cp={cp_number}"
);
}
}
#[test]
fn advance_alternates_written_slot_across_many_periods() {
let mut rng = StepRng(7);
let mut generator = CwGenerator::new(&mut rng);
for cw_number in 0 .. 8u16 {
let before = generator.slots;
let step = generator.advance(&mut rng);
let written = (cw_number & 1) as usize;
let kept = 1 - written;
assert_eq!(step.current, checksum_fix(before[kept]));
assert_eq!(step.next, checksum_fix(generator.slots[written]));
assert_ne!(before[written], generator.slots[written]);
assert_eq!(before[kept], generator.slots[kept]);
}
}
}