use crate::error::{Error, ErrorCode, Result};
pub const CHALLENGE_LEN: usize = 8;
pub const SYNC_REQ_JITTER_MS: u32 = 500;
pub const SYNC_TIMEOUT_MS: u32 = 2000;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct SyncRequest {
pub challenge: [u8; CHALLENGE_LEN],
}
impl SyncRequest {
pub fn encode<'a>(&self, buf: &'a mut [u8]) -> Result<&'a [u8]> {
let slot = buf
.get_mut(..CHALLENGE_LEN)
.ok_or(Error::new(ErrorCode::BufferTooSmall))?;
slot.copy_from_slice(&self.challenge);
Ok(slot)
}
pub fn decode(payload: &[u8]) -> Result<Self> {
let challenge = <[u8; CHALLENGE_LEN]>::try_from(payload)
.map_err(|_| Error::new(ErrorCode::MessageTruncated))?;
Ok(Self { challenge })
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct SyncResponse {
pub counter: u32,
pub response: [u8; CHALLENGE_LEN],
}
impl SyncResponse {
pub const LEN: usize = 4 + CHALLENGE_LEN;
pub fn encode<'a>(&self, buf: &'a mut [u8]) -> Result<&'a [u8]> {
let slot = buf
.get_mut(..Self::LEN)
.ok_or(Error::new(ErrorCode::BufferTooSmall))?;
let (counter, response) = slot.split_at_mut(4);
counter.copy_from_slice(&self.counter.to_le_bytes());
response.copy_from_slice(&self.response);
Ok(slot)
}
pub fn decode(payload: &[u8]) -> Result<Self> {
let bytes = <[u8; Self::LEN]>::try_from(payload)
.map_err(|_| Error::new(ErrorCode::MessageTruncated))?;
let (counter, response) = bytes.split_at(4);
let counter =
<[u8; 4]>::try_from(counter).map_err(|_| Error::new(ErrorCode::MessageTruncated))?;
let response = <[u8; CHALLENGE_LEN]>::try_from(response)
.map_err(|_| Error::new(ErrorCode::MessageTruncated))?;
Ok(Self {
counter: u32::from_le_bytes(counter),
response,
})
}
#[must_use]
pub fn answers(&self, request: &SyncRequest) -> bool {
crate::crypto::ct_eq(&self.response, &request.challenge)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn a_request_is_eight_octets_of_challenge() {
let request = SyncRequest {
challenge: [1, 2, 3, 4, 5, 6, 7, 8],
};
let mut buf = [0u8; 16];
assert_eq!(request.encode(&mut buf).unwrap(), &[1, 2, 3, 4, 5, 6, 7, 8]);
assert_eq!(
SyncRequest::decode(&[1, 2, 3, 4, 5, 6, 7, 8]).unwrap(),
request
);
assert!(SyncRequest::decode(&[1, 2, 3]).is_err());
assert!(SyncRequest::decode(&[0u8; 9]).is_err());
}
#[test]
fn a_response_is_a_counter_then_the_echoed_challenge() {
let response = SyncResponse {
counter: 0x0102_0304,
response: [9, 8, 7, 6, 5, 4, 3, 2],
};
let mut buf = [0u8; 16];
assert_eq!(
response.encode(&mut buf).unwrap(),
&[0x04, 0x03, 0x02, 0x01, 9, 8, 7, 6, 5, 4, 3, 2]
);
assert_eq!(
SyncResponse::decode(&[0x04, 0x03, 0x02, 0x01, 9, 8, 7, 6, 5, 4, 3, 2]).unwrap(),
response
);
}
#[test]
fn a_response_answers_only_its_own_challenge() {
let request = SyncRequest {
challenge: [1, 2, 3, 4, 5, 6, 7, 8],
};
let good = SyncResponse {
counter: 7,
response: request.challenge,
};
assert!(good.answers(&request));
let mut wrong = good;
wrong.response[7] ^= 1;
assert!(!wrong.answers(&request));
}
}