use crate::{
backend::{
aes128::Aes128,
ctr::{ctr_1x128, split_root},
},
const_fn::{CTR_STEP_LI, M_CTR},
state::BLOCK_LEN,
};
#[inline(always)]
unsafe fn ctr_step_n<L: Aes128, const N: usize, const XOR: bool>(
ctx: L,
rk_li: &[L::V; 4],
mut x_li: [L::V; N],
ptr: *mut u8,
) {
unsafe {
for x in &mut x_li {
*x = ctx.ctr_prep_1(*x, rk_li[0]);
}
for rk in [rk_li[1], rk_li[2]] {
for x in &mut x_li {
*x = ctx.ctr_mid_1(*x, rk);
}
}
for (i, x) in x_li.into_iter().enumerate() {
let k = ctx.ctr_fin_1(x, rk_li[3], rk_li[0]);
let p = ptr.add(i * BLOCK_LEN);
if XOR {
ctx.st(p, ctx.xor(ctx.ld(p), k));
} else {
ctx.st(p, k);
}
}
}
}
#[inline(always)]
unsafe fn ctr_quad<L: Aes128>(ctx: L, c0: L::V, step1: L::V, step2: L::V) -> [L::V; 4] {
unsafe {
let c1 = ctx.add_u64(c0, step1);
let c2 = ctx.add_u64(c0, step2);
let c3 = ctx.add_u64(c1, step2);
[c0, c1, c2, c3]
}
}
#[inline(always)]
pub(crate) unsafe fn ctr_8x128<L: Aes128, const XOR: bool>(
ctx: L,
root: &[u8; 32],
mut blk: u64,
buf: &mut [u8],
) {
debug_assert!(buf.len().is_multiple_of(BLOCK_LEN));
unsafe {
let rk_li = split_root(ctx, root);
let mut ptr = buf.as_mut_ptr();
let mut rem = buf.len();
if rem >= 32 {
let step1 = ctx.ld(CTR_STEP_LI[1].as_ptr());
let mut c0 = ctx.pair_v(blk, blk.wrapping_mul(M_CTR));
if rem >= 64 {
let step2 = ctx.ld(CTR_STEP_LI[2].as_ptr());
let step4 = ctx.ld(CTR_STEP_LI[4].as_ptr());
if rem >= 128 {
let step8 = ctx.ld(CTR_STEP_LI[8].as_ptr());
let [q0, q1, q2, q3] = ctr_quad(ctx, c0, step1, step2);
let mut c_li = [
q0,
q1,
q2,
q3,
ctx.add_u64(q0, step4),
ctx.add_u64(q1, step4),
ctx.add_u64(q2, step4),
ctx.add_u64(q3, step4),
];
while rem >= 128 {
ctr_step_n::<L, 8, XOR>(ctx, &rk_li, c_li, ptr);
for c in &mut c_li {
*c = ctx.add_u64(*c, step8);
}
ptr = ptr.add(128);
rem -= 128;
blk = blk.wrapping_add(8);
}
c0 = c_li[0];
}
if rem >= 64 {
ctr_step_n::<L, 4, XOR>(ctx, &rk_li, ctr_quad(ctx, c0, step1, step2), ptr);
c0 = ctx.add_u64(c0, step4);
ptr = ptr.add(64);
rem -= 64;
blk = blk.wrapping_add(4);
}
}
if rem >= 32 {
let c1 = ctx.add_u64(c0, step1);
ctr_step_n::<L, 2, XOR>(ctx, &rk_li, [c0, c1], ptr);
ptr = ptr.add(32);
rem -= 32;
blk = blk.wrapping_add(2);
}
}
ctr_1x128::<L, XOR>(ctx, rk_li, blk, ptr, rem);
}
}