bwm 0.1.0

Image watermarking over borrowed RGB/RGBA buffers
Documentation
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;
            }
        }
    }
}