use crate::WatermarkKey;
#[derive(Clone, Debug)]
pub(crate) struct KeySchedule {
pub placement: [u8; 32],
pub whitening: [u8; 32],
pub mac: [u8; 32],
}
impl KeySchedule {
pub fn derive(key: &WatermarkKey) -> Self {
Self {
placement: blake3::derive_key("bwm v1 block permutation", &key.bytes),
whitening: blake3::derive_key("bwm v1 payload whitening", &key.bytes),
mac: blake3::derive_key("bwm v1 payload mac", &key.bytes),
}
}
}
pub(crate) fn shuffled_indices(len: usize, key: &[u8; 32], domain: &'static [u8]) -> Vec<usize> {
let mut indices: Vec<usize> = (0..len).collect();
if len <= 1 {
return indices;
}
let mut stream = Blake3Stream::new(key, domain);
for i in (1..len).rev() {
let j = stream.below(i + 1);
indices.swap(i, j);
}
indices
}
pub(crate) fn xor_keystream(data: &mut [u8], key: &[u8; 32], domain: &'static [u8]) {
let mut stream = Blake3Stream::new(key, domain);
for byte in data {
*byte ^= stream.next_u8();
}
}
#[derive(Clone, Debug)]
struct Blake3Stream {
key: [u8; 32],
domain: &'static [u8],
counter: u64,
buffer: [u8; 32],
offset: usize,
}
impl Blake3Stream {
fn new(key: &[u8; 32], domain: &'static [u8]) -> Self {
Self {
key: *key,
domain,
counter: 0,
buffer: [0; 32],
offset: 32,
}
}
fn refill(&mut self) {
let mut input = Vec::with_capacity(self.domain.len() + 8);
input.extend_from_slice(self.domain);
input.extend_from_slice(&self.counter.to_le_bytes());
self.buffer = *blake3::keyed_hash(&self.key, &input).as_bytes();
self.counter = self.counter.wrapping_add(1);
self.offset = 0;
}
fn next_u8(&mut self) -> u8 {
if self.offset >= self.buffer.len() {
self.refill();
}
let byte = self.buffer[self.offset];
self.offset += 1;
byte
}
fn next_u64(&mut self) -> u64 {
let mut bytes = [0u8; 8];
for byte in &mut bytes {
*byte = self.next_u8();
}
u64::from_le_bytes(bytes)
}
fn below(&mut self, upper: usize) -> usize {
debug_assert!(upper > 0);
let upper = upper as u64;
let zone = u64::MAX - (u64::MAX % upper);
loop {
let value = self.next_u64();
if value < zone {
return (value % upper) as usize;
}
}
}
}