#[cfg(feature = "zeroize")]
use zeroize::Zeroize;
use crate::common::{BLOCK_SIZE, WORDS};
use crate::memory::compress::{bytes_to_words, compress, words_to_bytes};
pub fn fill(v: &mut [u8], q: usize, t: usize) {
let mut words = vec![0u64; q * WORDS];
for i in 0..q {
#[cfg_attr(not(feature = "zeroize"), allow(unused_mut))]
let mut block_bytes: [u8; BLOCK_SIZE] = v
[i * BLOCK_SIZE..(i + 1) * BLOCK_SIZE]
.try_into()
.expect("v is laid out in fixed BLOCK_SIZE blocks");
#[cfg_attr(not(feature = "zeroize"), allow(unused_mut))]
let mut block_words = bytes_to_words(&block_bytes);
words[i * WORDS..(i + 1) * WORDS].copy_from_slice(&block_words);
#[cfg(feature = "zeroize")]
{
block_bytes.zeroize();
block_words.zeroize();
}
}
for pass in 0..t {
let start = if pass == 0 { 2 } else { 0 };
for j in start..q {
fill_block(&mut words, q, pass, j);
}
}
for i in 0..q {
#[cfg_attr(not(feature = "zeroize"), allow(unused_mut))]
let mut block_words: [u64; WORDS] = words[i * WORDS..(i + 1) * WORDS]
.try_into()
.expect("words is laid out in fixed WORDS-sized blocks");
#[cfg_attr(not(feature = "zeroize"), allow(unused_mut))]
let mut block_bytes = words_to_bytes(&block_words);
v[i * BLOCK_SIZE..(i + 1) * BLOCK_SIZE].copy_from_slice(&block_bytes);
#[cfg(feature = "zeroize")]
{
block_words.zeroize();
block_bytes.zeroize();
}
}
#[cfg(feature = "zeroize")]
words.zeroize();
}
fn fill_block(v: &mut [u64], q: usize, pass: usize, j: usize) {
let prev = prev_index(pass, j, q);
#[cfg_attr(not(feature = "zeroize"), allow(unused_mut))]
let mut prev_words: [u64; WORDS] = v[prev * WORDS..(prev + 1) * WORDS]
.try_into()
.expect("v is laid out in fixed WORDS-sized blocks");
let len = w_len(pass, j, q);
let z = reference_index(prev, len, &prev_words);
#[cfg_attr(not(feature = "zeroize"), allow(unused_mut))]
let mut ref_words: [u64; WORDS] = v[z * WORDS..(z + 1) * WORDS]
.try_into()
.expect("v is laid out in fixed WORDS-sized blocks");
#[cfg_attr(not(feature = "zeroize"), allow(unused_mut))]
let mut result = compress(&prev_words, &ref_words);
v[j * WORDS..(j + 1) * WORDS].copy_from_slice(&result);
#[cfg(feature = "zeroize")]
{
prev_words.zeroize();
ref_words.zeroize();
result.zeroize();
}
}
fn prev_index(pass: usize, j: usize, q: usize) -> usize {
if pass > 0 && j == 0 { q - 1 } else { j - 1 }
}
fn w_len(pass: usize, j: usize, q: usize) -> usize {
if pass == 0 { j - 1 } else { q - 1 }
}
fn reference_index(
prev: usize,
len: usize,
prev_words: &[u64; WORDS],
) -> usize {
let pos = select(len, j1(prev_words));
w_index(prev, pos)
}
fn j1(prev: &[u64; WORDS]) -> u32 {
prev[0] as u32
}
fn select(w_len: usize, j1: u32) -> usize {
let x = (u64::from(j1) * u64::from(j1)) >> 32;
let y = (w_len as u64 * x) >> 32;
w_len - 1 - y as usize
}
fn w_index(prev: usize, pos: usize) -> usize {
if pos < prev { pos } else { pos + 1 }
}