bwm 0.1.0

Image watermarking over borrowed RGB/RGBA buffers
Documentation
use crate::{prng, WatermarkError, WatermarkKey};

pub(crate) const MAGIC: &[u8; 4] = b"BWMK";
pub(crate) const VERSION: u8 = 1;
pub(crate) const HEADER_LEN: usize = 28;
pub(crate) const TYPE_TEXT_UTF8: u8 = 1;
pub(crate) const TYPE_BINARY: u8 = 2;

#[derive(Clone, Debug, PartialEq, Eq)]
pub(crate) struct DecodedPayload {
    pub kind: u8,
    pub bytes: Vec<u8>,
}

pub(crate) fn build_frame(
    payload: &[u8],
    kind: u8,
    key: &WatermarkKey,
) -> Result<Vec<u8>, WatermarkError> {
    let payload_len =
        u32::try_from(payload.len()).map_err(|_| WatermarkError::CapacityExceeded {
            required_bits: usize::MAX,
            available_bits: 0,
        })?;

    let schedule = prng::KeySchedule::derive(key);
    let mut frame = Vec::with_capacity(HEADER_LEN + payload.len());
    frame.extend_from_slice(MAGIC);
    frame.push(VERSION);
    frame.extend_from_slice(&0u16.to_be_bytes());
    frame.extend_from_slice(&payload_len.to_be_bytes());
    frame.push(kind);
    frame.extend_from_slice(&[0u8; 16]);
    frame.extend_from_slice(payload);

    let mac = frame_mac(&schedule.mac, &frame[0..12], payload);
    frame[12..28].copy_from_slice(&mac);
    prng::xor_keystream(&mut frame, &schedule.whitening, b"payload-frame-v1");

    Ok(frame)
}

pub(crate) fn decode_frame(
    encoded: &[u8],
    key: &WatermarkKey,
) -> Result<DecodedPayload, WatermarkError> {
    if encoded.len() < HEADER_LEN {
        return Err(WatermarkError::NoWatermarkFound);
    }

    let schedule = prng::KeySchedule::derive(key);
    let mut frame = encoded.to_vec();
    prng::xor_keystream(&mut frame, &schedule.whitening, b"payload-frame-v1");

    if &frame[0..4] != MAGIC {
        return Err(WatermarkError::NoWatermarkFound);
    }

    let version = frame[4];
    if version != VERSION {
        return Err(WatermarkError::UnsupportedVersion(version));
    }

    let payload_len = u32::from_be_bytes([frame[7], frame[8], frame[9], frame[10]]) as usize;
    let kind = frame[11];
    let end = HEADER_LEN
        .checked_add(payload_len)
        .ok_or(WatermarkError::WrongKeyOrCorrupted)?;

    if end > frame.len() {
        return Err(WatermarkError::WrongKeyOrCorrupted);
    }

    let expected = frame_mac(&schedule.mac, &frame[0..12], &frame[HEADER_LEN..end]);
    if !constant_time_eq(&frame[12..28], &expected) {
        return Err(WatermarkError::WrongKeyOrCorrupted);
    }

    Ok(DecodedPayload {
        kind,
        bytes: frame[HEADER_LEN..end].to_vec(),
    })
}

fn frame_mac(mac_key: &[u8; 32], header_prefix: &[u8], payload: &[u8]) -> [u8; 16] {
    let mut hasher = blake3::Hasher::new_keyed(mac_key);
    hasher.update(header_prefix);
    hasher.update(payload);
    let full = hasher.finalize();
    let mut truncated = [0u8; 16];
    truncated.copy_from_slice(&full.as_bytes()[0..16]);
    truncated
}

fn constant_time_eq(left: &[u8], right: &[u8]) -> bool {
    if left.len() != right.len() {
        return false;
    }

    let mut diff = 0u8;
    for (left, right) in left.iter().zip(right) {
        diff |= left ^ right;
    }
    diff == 0
}

pub(crate) fn byte_bit(bytes: &[u8], bit_index: usize) -> bool {
    let byte = bytes[bit_index / 8];
    let shift = 7 - (bit_index % 8);
    ((byte >> shift) & 1) == 1
}

pub(crate) fn set_byte_bit(bytes: &mut [u8], bit_index: usize, value: bool) {
    if value {
        let shift = 7 - (bit_index % 8);
        bytes[bit_index / 8] |= 1 << shift;
    }
}