use thiserror::Error;
pub const DESEDE_BLOCK_BITS: usize = 64;
pub const AES_BLOCK_BITS: usize = 128;
#[derive(Debug, Error, PartialEq, Eq)]
pub enum SscError {
#[error("bit_size ({0}) must be a multiple of 8")]
BitSizeNotMultipleOf8(usize),
#[error("bit_size ({0}) exceeds the maximum supported width of 128 bits")]
BitSizeTooLarge(usize),
#[error(
"initial SSC value ({value_bits} bits) exceeds the declared bit_size ({bit_size} bits)"
)]
ValueTooLarge { value_bits: usize, bit_size: usize },
}
#[derive(Debug, Clone)]
pub struct Ssc {
value: u128,
bit_size: usize,
}
impl Ssc {
pub fn new(ssc: &[u8], bit_size: usize) -> Result<Self, SscError> {
if !bit_size.is_multiple_of(8) {
return Err(SscError::BitSizeNotMultipleOf8(bit_size));
}
if bit_size > 128 {
return Err(SscError::BitSizeTooLarge(bit_size));
}
let mut value: u128 = 0;
for &b in ssc {
if value > (u128::MAX >> 8) {
return Err(SscError::ValueTooLarge {
value_bits: 129,
bit_size,
});
}
value = (value << 8) | b as u128;
}
let value_bits = (128 - value.leading_zeros()) as usize;
if value_bits > bit_size {
return Err(SscError::ValueTooLarge {
value_bits,
bit_size,
});
}
Ok(Self { value, bit_size })
}
pub fn zeroed(bit_size: usize) -> Self {
assert!(
bit_size.is_multiple_of(8),
"zeroed SSC: bit_size must be a multiple of 8"
);
assert!(
bit_size <= 128,
"zeroed SSC: bit_size must be at most 128 bits"
);
Self::new(&vec![0u8; bit_size / 8], bit_size)
.expect("zeroed SSC with a validated bit_size is always constructible")
}
pub fn increment(&mut self) {
self.value = self.value.wrapping_add(1);
if self.bit_size < 128 {
let mask = (1u128 << self.bit_size) - 1;
self.value &= mask;
}
}
pub fn to_bytes(&self) -> Vec<u8> {
let byte_len = self.bit_size / 8;
self.value.to_be_bytes()[16 - byte_len..].to_vec()
}
pub fn bit_size(&self) -> usize {
self.bit_size
}
}
#[derive(Debug, Clone)]
pub struct DesedeSSC(pub Ssc);
impl DesedeSSC {
pub fn new(ssc: &[u8]) -> Result<Self, SscError> {
Ok(Self(Ssc::new(ssc, DESEDE_BLOCK_BITS)?))
}
pub fn increment(&mut self) {
self.0.increment();
}
pub fn to_bytes(&self) -> Vec<u8> {
self.0.to_bytes()
}
pub fn bit_size(&self) -> usize {
self.0.bit_size()
}
}
#[derive(Debug, Clone)]
pub struct DesedePaceSSC(pub Ssc);
impl DesedePaceSSC {
pub fn new() -> Self {
Self(Ssc::zeroed(DESEDE_BLOCK_BITS))
}
pub fn increment(&mut self) {
self.0.increment();
}
pub fn to_bytes(&self) -> Vec<u8> {
self.0.to_bytes()
}
}
impl Default for DesedePaceSSC {
fn default() -> Self {
Self::new()
}
}
#[derive(Debug, Clone)]
pub struct AesSSC(pub Ssc);
impl AesSSC {
pub fn new() -> Self {
Self(Ssc::zeroed(AES_BLOCK_BITS))
}
pub fn increment(&mut self) {
self.0.increment();
}
pub fn to_bytes(&self) -> Vec<u8> {
self.0.to_bytes()
}
}
impl Default for AesSSC {
fn default() -> Self {
Self::new()
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn error_bit_size_not_multiple_of_8() {
assert!(matches!(
Ssc::new(&[0x00], 7),
Err(SscError::BitSizeNotMultipleOf8(7))
));
}
#[test]
fn error_value_too_large() {
let result = Ssc::new(&[0x01, 0x00], 8);
assert!(matches!(result, Err(SscError::ValueTooLarge { .. })));
}
#[test]
fn valid_value_just_fitting() {
assert!(Ssc::new(&[0xFF], 8).is_ok());
}
#[test]
fn tc1_8bit_zero() {
let ssc = Ssc::new(&[0x00], 8).unwrap();
assert_eq!(ssc.to_bytes(), vec![0x00]);
}
#[test]
fn tc2_16bit_one() {
let ssc = Ssc::new(&[0x01], 16).unwrap();
assert_eq!(ssc.to_bytes(), vec![0x00, 0x01]);
}
#[test]
fn tc3_16bit_ff_then_100() {
let mut ssc = Ssc::new(&[0xFF], 16).unwrap();
assert_eq!(ssc.to_bytes(), vec![0x00, 0xFF]);
ssc.increment();
assert_eq!(ssc.to_bytes(), vec![0x01, 0x00]);
}
#[test]
fn tc4_16bit_overflow() {
let mut ssc = Ssc::new(&[0xFF, 0xFF], 16).unwrap();
ssc.increment();
assert_eq!(ssc.to_bytes(), vec![0x00, 0x00]);
}
#[test]
fn tc5_64bit_increment() {
let bytes = hex::decode("02FFFFFFFFFFFF01").unwrap();
let mut ssc = Ssc::new(&bytes, 64).unwrap();
assert_eq!(ssc.to_bytes(), bytes);
ssc.increment();
let expected = hex::decode("02FFFFFFFFFFFF02").unwrap();
assert_eq!(ssc.to_bytes(), expected);
}
#[test]
fn tc6_64bit_overflow() {
let bytes = hex::decode("FFFFFFFFFFFFFFFE").unwrap();
let mut ssc = Ssc::new(&bytes, 64).unwrap();
ssc.increment(); ssc.increment(); assert_eq!(ssc.to_bytes(), vec![0x00; 8]);
}
#[test]
fn tc7_128bit_two_increments() {
let init = hex::decode("0102030405060708090A0B0C0D0E0FFE").unwrap();
let mut ssc = Ssc::new(&init, 128).unwrap();
assert_eq!(ssc.to_bytes(), init);
ssc.increment();
let expected = hex::decode("0102030405060708090A0B0C0D0E0FFF").unwrap();
assert_eq!(ssc.to_bytes(), expected);
ssc.increment();
let expected2 = hex::decode("0102030405060708090A0B0C0D0E1000").unwrap();
assert_eq!(ssc.to_bytes(), expected2);
}
#[test]
fn tc8_128bit_carry() {
let init = hex::decode("01FFFFFFFFFFFFFFFFFFFFFFFFFFFFFF").unwrap();
let mut ssc = Ssc::new(&init, 128).unwrap();
assert_eq!(ssc.to_bytes(), init);
ssc.increment();
let expected = hex::decode("02000000000000000000000000000000").unwrap();
assert_eq!(ssc.to_bytes(), expected);
}
#[test]
fn tc9_128bit_overflow() {
let init = hex::decode("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF").unwrap();
let mut ssc = Ssc::new(&init, 128).unwrap();
assert_eq!(ssc.to_bytes(), init);
ssc.increment();
assert_eq!(ssc.to_bytes(), vec![0x00; 16]);
}
#[test]
fn tc10_leading_zeros_accepted() {
let bytes = hex::decode("0000000000000000000000000001").unwrap();
let ssc = Ssc::new(&bytes, 8).unwrap();
assert_eq!(ssc.to_bytes(), vec![0x01]);
}
#[test]
fn tc11_desede_ssc_icao_d4() {
let init = hex::decode("887022120C06C226").unwrap();
let mut ssc = DesedeSSC::new(&init).unwrap();
assert_eq!(ssc.to_bytes(), init);
ssc.increment();
assert_eq!(ssc.to_bytes(), hex::decode("887022120C06C227").unwrap());
ssc.increment();
assert_eq!(ssc.to_bytes(), hex::decode("887022120C06C228").unwrap());
ssc.increment();
assert_eq!(ssc.to_bytes(), hex::decode("887022120C06C229").unwrap());
ssc.increment();
assert_eq!(ssc.to_bytes(), hex::decode("887022120C06C22A").unwrap());
ssc.increment();
assert_eq!(ssc.to_bytes(), hex::decode("887022120C06C22B").unwrap());
ssc.increment();
assert_eq!(ssc.to_bytes(), hex::decode("887022120C06C22C").unwrap());
}
#[test]
fn desede_ssc_is_64_bits() {
let ssc = DesedeSSC::new(&[0x00; 8]).unwrap();
assert_eq!(ssc.bit_size(), 64);
assert_eq!(ssc.to_bytes().len(), 8);
}
#[test]
fn desede_pace_ssc_starts_at_zero() {
let ssc = DesedePaceSSC::new();
assert_eq!(ssc.to_bytes(), vec![0x00; 8]);
}
#[test]
fn desede_pace_ssc_increment() {
let mut ssc = DesedePaceSSC::new();
ssc.increment();
let mut expected = vec![0x00; 7];
expected.push(0x01);
assert_eq!(ssc.to_bytes(), expected);
}
#[test]
fn aes_ssc_starts_at_zero() {
let ssc = AesSSC::new();
assert_eq!(ssc.to_bytes(), vec![0x00; 16]);
}
#[test]
fn aes_ssc_increment() {
let mut ssc = AesSSC::new();
ssc.increment();
let mut expected = vec![0x00; 15];
expected.push(0x01);
assert_eq!(ssc.to_bytes(), expected);
}
#[test]
fn aes_ssc_overflow() {
let max = vec![0xFFu8; 16];
let inner = Ssc::new(&max, 128).unwrap();
let mut ssc = AesSSC(inner);
ssc.increment();
assert_eq!(ssc.to_bytes(), vec![0x00; 16]);
}
#[test]
fn zeroed_produces_all_zero_bytes() {
let ssc = Ssc::zeroed(64);
assert_eq!(ssc.to_bytes(), vec![0x00; 8]);
}
#[test]
#[should_panic(expected = "at most 128")]
fn zeroed_rejects_absurd_bit_size_before_allocating() {
let _ = Ssc::zeroed(usize::MAX - 7);
}
#[test]
fn to_bytes_always_fixed_width() {
let ssc = Ssc::new(&[0x01], 128).unwrap();
assert_eq!(ssc.to_bytes().len(), 16);
assert_eq!(&ssc.to_bytes()[..15], &[0x00; 15]);
assert_eq!(ssc.to_bytes()[15], 0x01);
}
}