use core::mem::offset_of;
use crate::state::{State, aes_enc};
const MASTER_SEED: u64 = 0x517C_C1B7_2722_0A95;
pub(crate) const M_CTR: u64 = 0xD1B5_4A32_D192_ED03;
pub(crate) const GOLDEN_RATIO: u64 = 0x9E37_79B9_7F4A_7C15;
const fn splitmix(state: &mut u64) -> u64 {
*state = state.wrapping_add(GOLDEN_RATIO);
let mut z = *state;
z = (z ^ (z >> 30)).wrapping_mul(0xBF58_476D_1CE4_E5B9);
z = (z ^ (z >> 27)).wrapping_mul(0x94D0_49BB_1331_11EB);
z ^ (z >> 31)
}
const fn next_state(state: &mut u64) -> State {
let lo = splitmix(state) as u128;
let hi = splitmix(state) as u128;
(lo | (hi << 64)).to_le_bytes()
}
const fn next_state_li<const N: usize>(state: &mut u64) -> [State; N] {
let mut out_li = [[0u8; 16]; N];
let mut i = 0;
while i < N {
out_li[i] = next_state(state);
i += 1;
}
out_li
}
struct ConstSpec {
k_short_li: [u64; 12],
lane_li: [State; 16],
fin_li: [State; 8],
stream_key_li: State,
}
const SPEC: ConstSpec = {
let mut st = MASTER_SEED;
let _ = splitmix(&mut st);
let mut k_short_li = [0u64; 12];
let mut i = 0;
while i < 12 {
k_short_li[i] = splitmix(&mut st) | 1;
i += 1;
}
let lane_li = next_state_li::<16>(&mut st);
let fin_li = next_state_li::<8>(&mut st);
let stream_key_li = next_state(&mut st);
ConstSpec {
k_short_li,
lane_li,
fin_li,
stream_key_li,
}
};
const fn xor_state_const(a: State, b: State) -> State {
let mut out_li = [0u8; 16];
let mut i = 0;
while i < 16 {
out_li[i] = a[i] ^ b[i];
i += 1;
}
out_li
}
#[repr(C, align(64))]
pub(crate) struct ConstTable {
pub(crate) sv0: State,
pub(crate) fin_li: [State; 7],
pub(crate) lane_sv0_li: [State; 16],
pub(crate) lane_li: [State; 16],
}
pub(crate) const K_SHORT_LI: [u64; 12] = SPEC.k_short_li;
pub(crate) static TBL: ConstTable = {
let sv0 = aes_enc(SPEC.fin_li[6], [0u8; 16]);
let mut lane_sv0_li = [[0u8; 16]; 16];
let mut i = 0;
while i < 16 {
lane_sv0_li[i] = xor_state_const(SPEC.lane_li[i], sv0);
i += 1;
}
ConstTable {
sv0,
fin_li: [
SPEC.fin_li[0],
SPEC.fin_li[1],
SPEC.fin_li[2],
SPEC.fin_li[3],
SPEC.fin_li[4],
SPEC.fin_li[5],
SPEC.fin_li[6],
],
lane_sv0_li,
lane_li: SPEC.lane_li,
}
};
pub(crate) const STREAM_KEY_LI: State = SPEC.stream_key_li;
pub(crate) const STREAM_FIN_LI: State = SPEC.fin_li[7];
#[inline(always)]
pub(crate) fn lane_ptr<const SEED0: bool>() -> *const u8 {
if SEED0 {
TBL.lane_sv0_li.as_ptr()
} else {
TBL.lane_li.as_ptr()
}
.cast()
}
pub(crate) const CTR_STEP_LI: [State; 17] = {
let mut step_li = [[0u8; 16]; 17];
let mut k = 0;
while k < 17 {
let lo = k as u128;
let hi = ((k as u64).wrapping_mul(M_CTR) as u128) << 64;
step_li[k] = (hi | lo).to_le_bytes();
k += 1;
}
step_li
};
const fn state_eq(a: &State, b: &State) -> bool {
let mut i = 0;
while i < 16 {
if a[i] != b[i] {
return false;
}
i += 1;
}
true
}
const fn all_distinct(state_li: &[State]) -> bool {
let mut i = 0;
while i < state_li.len() {
let mut j = i + 1;
while j < state_li.len() {
if state_eq(&state_li[i], &state_li[j]) {
return false;
}
j += 1;
}
i += 1;
}
true
}
const _: () = {
assert!(M_CTR & 1 == 1);
assert!(CTR_STEP_LI[1][0] == 1);
assert!(offset_of!(ConstTable, lane_sv0_li) == 128);
assert!(all_distinct(&SPEC.lane_li));
assert!(all_distinct(&SPEC.fin_li));
assert!(!state_eq(&SPEC.fin_li[0], &[0u8; 16]));
};
const fn mul2(x: u8) -> u8 {
(x << 1) ^ if x & 0x80 != 0 { 0x1B } else { 0 }
}
pub(crate) const SBOX_LI: [u8; 256] = {
let mut sbox_li = [0x63; 256];
let (mut p, mut q) = (1u8, 1u8);
loop {
p ^= mul2(p);
q ^= q << 1;
q ^= q << 2;
q ^= q << 4;
if q & 0x80 != 0 {
q ^= 0x09;
}
sbox_li[p as usize] =
0x63 ^ q ^ q.rotate_left(1) ^ q.rotate_left(2) ^ q.rotate_left(3) ^ q.rotate_left(4);
if p == 1 {
break sbox_li;
}
}
};
const MIX_LI: [u32; 256] = {
let mut mix_li = [0u32; 256];
let mut i = 0;
while i < 256 {
let s = SBOX_LI[i];
mix_li[i] = u32::from_le_bytes([mul2(s), s, s, mul2(s) ^ s]);
i += 1;
}
mix_li
};
const fn make_rot_tbl(rot: u32) -> [u32; 256] {
let mut tbl_li = [0u32; 256];
let mut i = 0;
while i < 256 {
tbl_li[i] = MIX_LI[i].rotate_left(rot);
i += 1;
}
tbl_li
}
pub(crate) const T0_LI: [u32; 256] = MIX_LI;
pub(crate) const T1_LI: [u32; 256] = make_rot_tbl(8);
pub(crate) const T2_LI: [u32; 256] = make_rot_tbl(16);
pub(crate) const T3_LI: [u32; 256] = make_rot_tbl(24);