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;
}
}