1use crate::error::{Error, ErrorCode, Result};
12
13pub const CHALLENGE_LEN: usize = 8;
15
16pub const SYNC_REQ_JITTER_MS: u32 = 500;
20
21pub const SYNC_TIMEOUT_MS: u32 = 2000;
24
25#[derive(Debug, Clone, Copy, PartialEq, Eq)]
27pub struct SyncRequest {
28 pub challenge: [u8; CHALLENGE_LEN],
31}
32
33impl SyncRequest {
34 pub fn encode<'a>(&self, buf: &'a mut [u8]) -> Result<&'a [u8]> {
36 let slot = buf
37 .get_mut(..CHALLENGE_LEN)
38 .ok_or(Error::new(ErrorCode::BufferTooSmall))?;
39 slot.copy_from_slice(&self.challenge);
40 Ok(slot)
41 }
42
43 pub fn decode(payload: &[u8]) -> Result<Self> {
48 let challenge = <[u8; CHALLENGE_LEN]>::try_from(payload)
49 .map_err(|_| Error::new(ErrorCode::MessageTruncated))?;
50 Ok(Self { challenge })
51 }
52}
53
54#[derive(Debug, Clone, Copy, PartialEq, Eq)]
56pub struct SyncResponse {
57 pub counter: u32,
59 pub response: [u8; CHALLENGE_LEN],
62}
63
64impl SyncResponse {
65 pub const LEN: usize = 4 + CHALLENGE_LEN;
67
68 pub fn encode<'a>(&self, buf: &'a mut [u8]) -> Result<&'a [u8]> {
70 let slot = buf
71 .get_mut(..Self::LEN)
72 .ok_or(Error::new(ErrorCode::BufferTooSmall))?;
73 let (counter, response) = slot.split_at_mut(4);
74 counter.copy_from_slice(&self.counter.to_le_bytes());
75 response.copy_from_slice(&self.response);
76 Ok(slot)
77 }
78
79 pub fn decode(payload: &[u8]) -> Result<Self> {
81 let bytes = <[u8; Self::LEN]>::try_from(payload)
82 .map_err(|_| Error::new(ErrorCode::MessageTruncated))?;
83 let (counter, response) = bytes.split_at(4);
84 let counter =
85 <[u8; 4]>::try_from(counter).map_err(|_| Error::new(ErrorCode::MessageTruncated))?;
86 let response = <[u8; CHALLENGE_LEN]>::try_from(response)
87 .map_err(|_| Error::new(ErrorCode::MessageTruncated))?;
88 Ok(Self {
89 counter: u32::from_le_bytes(counter),
90 response,
91 })
92 }
93
94 #[must_use]
102 pub fn answers(&self, request: &SyncRequest) -> bool {
103 crate::crypto::ct_eq(&self.response, &request.challenge)
104 }
105}
106
107#[cfg(test)]
108mod tests {
109 use super::*;
110
111 #[test]
112 fn a_request_is_eight_octets_of_challenge() {
113 let request = SyncRequest {
114 challenge: [1, 2, 3, 4, 5, 6, 7, 8],
115 };
116 let mut buf = [0u8; 16];
117 assert_eq!(request.encode(&mut buf).unwrap(), &[1, 2, 3, 4, 5, 6, 7, 8]);
118 assert_eq!(
119 SyncRequest::decode(&[1, 2, 3, 4, 5, 6, 7, 8]).unwrap(),
120 request
121 );
122 assert!(SyncRequest::decode(&[1, 2, 3]).is_err());
124 assert!(SyncRequest::decode(&[0u8; 9]).is_err());
125 }
126
127 #[test]
128 fn a_response_is_a_counter_then_the_echoed_challenge() {
129 let response = SyncResponse {
130 counter: 0x0102_0304,
131 response: [9, 8, 7, 6, 5, 4, 3, 2],
132 };
133 let mut buf = [0u8; 16];
134 assert_eq!(
135 response.encode(&mut buf).unwrap(),
136 &[0x04, 0x03, 0x02, 0x01, 9, 8, 7, 6, 5, 4, 3, 2]
137 );
138 assert_eq!(
139 SyncResponse::decode(&[0x04, 0x03, 0x02, 0x01, 9, 8, 7, 6, 5, 4, 3, 2]).unwrap(),
140 response
141 );
142 }
143
144 #[test]
145 fn a_response_answers_only_its_own_challenge() {
146 let request = SyncRequest {
147 challenge: [1, 2, 3, 4, 5, 6, 7, 8],
148 };
149 let good = SyncResponse {
150 counter: 7,
151 response: request.challenge,
152 };
153 assert!(good.answers(&request));
154 let mut wrong = good;
155 wrong.response[7] ^= 1;
156 assert!(!wrong.answers(&request));
157 }
158}