diff --git a/crates/irtt-client/src/session/machine.rs b/crates/irtt-client/src/session/machine.rs index 6ac80aa..86d862b 100644 --- a/crates/irtt-client/src/session/machine.rs +++ b/crates/irtt-client/src/session/machine.rs @@ -218,10 +218,9 @@ impl SessionMachine { let request = EchoRequest { token: session.token, sequence: wire_seq, - params: session.negotiated.params.clone(), payload: vec![], }; - let packet = encode_echo_request(&request, hmac_key)?; + let packet = encode_echo_request(&request, &session.negotiated.params, hmac_key)?; let send_result = send(&packet)?; let pending = PendingProbe { diff --git a/crates/irtt-proto/src/echo.rs b/crates/irtt-proto/src/echo.rs index 56983e3..c924551 100644 --- a/crates/irtt-proto/src/echo.rs +++ b/crates/irtt-proto/src/echo.rs @@ -10,7 +10,6 @@ use crate::{ pub struct EchoRequest { pub token: u64, pub sequence: u32, - pub params: Params, pub payload: Vec, } @@ -35,9 +34,13 @@ pub struct TimestampFields { pub send_mono: Option, } -pub fn encode_echo_request(request: &EchoRequest, hmac_key: Option<&[u8]>) -> Result> { - let layout = PacketLayout::echo(hmac_key.is_some(), &request.params); - let len = echo_packet_len(hmac_key.is_some(), &request.params)?; +pub fn encode_echo_request( + request: &EchoRequest, + params: &Params, + hmac_key: Option<&[u8]>, +) -> Result> { + let layout = PacketLayout::echo(hmac_key.is_some(), params); + let len = echo_packet_len(hmac_key.is_some(), params)?; let payload_offset = layout.header_len(); let available_payload_len = len.saturating_sub(payload_offset); if request.payload.len() > available_payload_len { @@ -65,6 +68,66 @@ pub fn encode_echo_request(request: &EchoRequest, hmac_key: Option<&[u8]>) -> Re envelope::finish(out, hmac_key) } +pub fn decode_echo_request( + packet: &[u8], + params: &Params, + hmac_key: Option<&[u8]>, +) -> Result { + let envelope = envelope::decode( + packet, + hmac_key, + &[ + FlagRule::Reject(FLAG_OPEN), + FlagRule::Reject(FLAG_REPLY), + FlagRule::Reject(FLAG_CLOSE), + ], + )?; + let layout = PacketLayout::echo(hmac_key.is_some(), params); + validate_echo_length(packet, params, layout)?; + envelope::verify(packet, hmac_key)?; + + let mut pos = envelope.body_offset; + let token = read_u64(packet, &mut pos); + let sequence = read_u32(packet, &mut pos); + + Ok(EchoRequest { + token, + sequence, + payload: packet[layout.header_len()..].to_vec(), + }) +} + +pub fn encode_echo_reply( + reply: &EchoReply, + params: &Params, + hmac_key: Option<&[u8]>, +) -> Result> { + let layout = PacketLayout::echo(hmac_key.is_some(), params); + let len = echo_packet_len(hmac_key.is_some(), params)?; + let payload_offset = layout.header_len(); + let available_payload_len = len.saturating_sub(payload_offset); + if reply.payload.len() > available_payload_len { + return Err(ProtoError::PayloadTooLarge { + available: available_payload_len, + provided: reply.payload.len(), + }); + } + + let mut out = envelope::begin( + reply.flags, + hmac_key, + &[FlagRule::Reject(FLAG_OPEN), FlagRule::Require(FLAG_REPLY)], + len, + )?; + out.extend_from_slice(&reply.token.to_le_bytes()); + out.extend_from_slice(&reply.sequence.to_le_bytes()); + push_echo_reply_tail(reply, layout, &mut out)?; + out.resize(len, 0); + out[payload_offset..payload_offset + reply.payload.len()].copy_from_slice(&reply.payload); + + envelope::finish(out, hmac_key) +} + pub fn decode_echo_reply( packet: &[u8], params: &Params, @@ -135,6 +198,47 @@ fn push_zeroed_layout_tail(layout: PacketLayout, out: &mut Vec) { } } +fn push_echo_reply_tail(reply: &EchoReply, layout: PacketLayout, out: &mut Vec) -> Result<()> { + if let Some(value) = field_value(layout.recv_count, reply.recv_count, "recv_count")? { + out.extend_from_slice(&value.to_le_bytes()); + } + if let Some(value) = field_value(layout.recv_window, reply.recv_window, "recv_window")? { + out.extend_from_slice(&value.to_le_bytes()); + } + + let timestamps = &reply.timestamps; + for (present, value, name) in [ + (layout.recv_wall, timestamps.recv_wall, "recv_wall"), + (layout.recv_mono, timestamps.recv_mono, "recv_mono"), + ( + layout.midpoint_wall, + timestamps.midpoint_wall, + "midpoint_wall", + ), + ( + layout.midpoint_mono, + timestamps.midpoint_mono, + "midpoint_mono", + ), + (layout.send_wall, timestamps.send_wall, "send_wall"), + (layout.send_mono, timestamps.send_mono, "send_mono"), + ] { + if let Some(value) = field_value(present, value, name)? { + out.extend_from_slice(&value.to_le_bytes()); + } + } + Ok(()) +} + +fn field_value(present: bool, value: Option, name: &'static str) -> Result> { + match (present, value) { + (true, Some(value)) => Ok(Some(value)), + (true, None) => Err(ProtoError::MissingField(name)), + (false, Some(_)) => Err(ProtoError::UnexpectedField(name)), + (false, None) => Ok(None), + } +} + fn read_u32(packet: &[u8], pos: &mut usize) -> u32 { let value = u32::from_le_bytes(packet[*pos..*pos + SEQ_SIZE].try_into().unwrap()); *pos += SEQ_SIZE; @@ -179,24 +283,24 @@ mod tests { } } - fn echo_request_with_payload(payload_space: usize, payload: Vec) -> EchoRequest { + fn echo_request_with_payload(payload: Vec) -> EchoRequest { EchoRequest { token: 0x7896_b6ab_8771_5213, sequence: 9, - params: params_with_payload_space(payload_space), payload, } } #[test] fn echo_request_encodes_default_placeholders() { + let params = default_params(); let packet = encode_echo_request( &EchoRequest { token: 0x7896_b6ab_8771_5213, sequence: 0, - params: default_params(), payload: Vec::new(), }, + ¶ms, None, ) .unwrap(); @@ -208,29 +312,32 @@ mod tests { #[test] fn echo_request_encodes_exact_fit_payload() { - let request = echo_request_with_payload(4, vec![1, 2, 3, 4]); - let packet = encode_echo_request(&request, None).unwrap(); - let payload_offset = PacketLayout::echo(false, &request.params).header_len(); + let params = params_with_payload_space(4); + let request = echo_request_with_payload(vec![1, 2, 3, 4]); + let packet = encode_echo_request(&request, ¶ms, None).unwrap(); + let payload_offset = PacketLayout::echo(false, ¶ms).header_len(); assert_eq!(&packet[payload_offset..], &[1, 2, 3, 4]); } #[test] fn echo_request_encodes_shorter_payload_and_zero_fills_remainder() { - let request = echo_request_with_payload(4, vec![1, 2]); - let packet = encode_echo_request(&request, None).unwrap(); - let payload_offset = PacketLayout::echo(false, &request.params).header_len(); + let params = params_with_payload_space(4); + let request = echo_request_with_payload(vec![1, 2]); + let packet = encode_echo_request(&request, ¶ms, None).unwrap(); + let payload_offset = PacketLayout::echo(false, ¶ms).header_len(); assert_eq!(&packet[payload_offset..], &[1, 2, 0, 0]); } #[test] fn echo_request_rejects_oversized_payload() { - let request = echo_request_with_payload(4, vec![1, 2, 3, 4, 5]); + let params = params_with_payload_space(4); + let request = echo_request_with_payload(vec![1, 2, 3, 4, 5]); let original = request.clone(); assert_eq!( - encode_echo_request(&request, None), + encode_echo_request(&request, ¶ms, None), Err(ProtoError::PayloadTooLarge { available: 4, provided: 5, @@ -241,24 +348,28 @@ mod tests { #[test] fn echo_request_rejects_negative_requested_length() { - let mut request = echo_request_with_payload(0, Vec::new()); - request.params.length = -1; + let request = echo_request_with_payload(Vec::new()); + let params = Params { + length: -1, + ..Params::default() + }; assert_eq!( - encode_echo_request(&request, None), + encode_echo_request(&request, ¶ms, None), Err(ProtoError::NegativePacketLength { length: -1 }) ); } #[test] fn hmac_echo_request_places_token_and_sequence_after_hmac() { + let params = default_params(); let packet = encode_echo_request( &EchoRequest { token: 0x7896_b6ab_8771_5213, sequence: 9, - params: default_params(), payload: Vec::new(), }, + ¶ms, Some(b"testkey"), ) .unwrap(); diff --git a/crates/irtt-proto/src/error.rs b/crates/irtt-proto/src/error.rs index cd30a0e..1e69546 100644 --- a/crates/irtt-proto/src/error.rs +++ b/crates/irtt-proto/src/error.rs @@ -40,4 +40,8 @@ pub enum ProtoError { MalformedParams, #[error("payload is too large: {provided} bytes provided, {available} bytes available")] PayloadTooLarge { available: usize, provided: usize }, + #[error("required packet field {0} is missing")] + MissingField(&'static str), + #[error("packet field {0} is not present in the negotiated layout")] + UnexpectedField(&'static str), } diff --git a/crates/irtt-proto/src/lib.rs b/crates/irtt-proto/src/lib.rs index a4d007c..5922929 100644 --- a/crates/irtt-proto/src/lib.rs +++ b/crates/irtt-proto/src/lib.rs @@ -32,7 +32,10 @@ pub mod params; pub mod varint; pub use close::{decode_close_request, encode_close_request, CloseRequest}; -pub use echo::{decode_echo_reply, encode_echo_request, EchoReply, EchoRequest, TimestampFields}; +pub use echo::{ + decode_echo_reply, decode_echo_request, encode_echo_reply, encode_echo_request, EchoReply, + EchoRequest, TimestampFields, +}; pub use error::{ProtoError, Result}; pub use flags::*; pub use hmac::{compute_hmac, compute_hmac_in_place, verify_hmac}; diff --git a/crates/irtt-proto/tests/directional_codecs.rs b/crates/irtt-proto/tests/directional_codecs.rs index cf985c6..c8828e6 100644 --- a/crates/irtt-proto/tests/directional_codecs.rs +++ b/crates/irtt-proto/tests/directional_codecs.rs @@ -1,30 +1,80 @@ use irtt_proto::{ - decode_close_request, decode_open_reply, decode_open_request, encode_close_request, - encode_open_reply, encode_open_request, CloseRequest, OpenReply, OpenRequest, Params, - ProtoError, FLAG_CLOSE, FLAG_HMAC, FLAG_OPEN, FLAG_REPLY, MAGIC, + decode_close_request, decode_echo_reply, decode_echo_request, decode_open_reply, + decode_open_request, encode_close_request, encode_echo_reply, encode_echo_request, + encode_open_reply, encode_open_request, Clock, CloseRequest, EchoReply, EchoRequest, OpenReply, + OpenRequest, PacketLayout, Params, ProtoError, ReceivedStats, StampAt, TimestampFields, + FLAG_CLOSE, FLAG_HMAC, FLAG_OPEN, FLAG_REPLY, MAGIC, }; const KEY: &[u8] = b"testkey"; const TOKEN: u64 = 0x7896_b6ab_8771_5213; +fn params() -> Params { + Params { + protocol_version: 1, + duration_ns: 3_000_000_000, + interval_ns: 1_000_000_000, + received_stats: ReceivedStats::Both, + stamp_at: StampAt::Both, + clock: Clock::Both, + ..Params::default() + } +} + +fn echo_request(payload: Vec) -> EchoRequest { + EchoRequest { + token: TOKEN, + sequence: 17, + payload, + } +} + +fn echo_reply(params: &Params, flags: u8) -> EchoReply { + let layout = PacketLayout::echo(false, params); + EchoReply { + flags, + token: TOKEN, + sequence: u32::MAX, + recv_count: layout.recv_count.then_some(u32::MAX), + recv_window: layout.recv_window.then_some(u64::MAX), + timestamps: TimestampFields { + recv_wall: layout.recv_wall.then_some(i64::MIN), + recv_mono: layout.recv_mono.then_some(-2), + midpoint_wall: layout.midpoint_wall.then_some(-1), + midpoint_mono: layout.midpoint_mono.then_some(0), + send_wall: layout.send_wall.then_some(1), + send_mono: layout.send_mono.then_some(i64::MAX), + }, + payload: Vec::new(), + } +} + #[test] -fn authenticated_open_reply_encoder_sets_hmac_from_key() { - let reply = OpenReply { +fn authenticated_reply_encoders_set_hmac_from_key() { + let params = params(); + let open_reply = OpenReply { flags: FLAG_OPEN | FLAG_REPLY, token: TOKEN, - params: Params { - protocol_version: 1, - ..Params::default() - }, + params: params.clone(), }; - let packet = encode_open_reply(&reply, Some(KEY)).unwrap(); - + let packet = encode_open_reply(&open_reply, Some(KEY)).unwrap(); assert_eq!(packet[3], FLAG_OPEN | FLAG_REPLY | FLAG_HMAC); assert_eq!( decode_open_reply(&packet, Some(KEY)), Ok(OpenReply { flags: FLAG_OPEN | FLAG_REPLY | FLAG_HMAC, - ..reply + ..open_reply + }) + ); + + let echo_reply = echo_reply(¶ms, FLAG_REPLY); + let packet = encode_echo_reply(&echo_reply, ¶ms, Some(KEY)).unwrap(); + assert_eq!(packet[3], FLAG_REPLY | FLAG_HMAC); + assert_eq!( + decode_echo_reply(&packet, ¶ms, Some(KEY)), + Ok(EchoReply { + flags: FLAG_REPLY | FLAG_HMAC, + ..echo_reply }) ); } @@ -55,7 +105,17 @@ fn rejected_open_reply_round_trips_and_zero_token_requires_close() { } #[test] -fn open_and_close_codecs_enforce_directional_flags() { +fn peer_close_echo_reply_round_trips_without_a_close_reply_codec() { + let params = Params::default(); + let reply = echo_reply(¶ms, FLAG_REPLY | FLAG_CLOSE); + let packet = encode_echo_reply(&reply, ¶ms, None).unwrap(); + + assert_eq!(packet[3], FLAG_REPLY | FLAG_CLOSE); + assert_eq!(decode_echo_reply(&packet, ¶ms, None), Ok(reply)); +} + +#[test] +fn inverse_codecs_supply_their_packet_type_rules() { let params = Params::default(); let open_reply_packet = encode_open_reply( &OpenReply { @@ -82,6 +142,30 @@ fn open_and_close_codecs_enforce_directional_flags() { Err(ProtoError::MissingFlag(FLAG_OPEN)) ); + let echo_reply_packet = + encode_echo_reply(&echo_reply(¶ms, FLAG_REPLY), ¶ms, None).unwrap(); + assert_eq!( + decode_echo_request(&echo_reply_packet, ¶ms, None), + Err(ProtoError::UnexpectedFlag(FLAG_REPLY)) + ); + assert_eq!( + encode_echo_reply( + &EchoReply { + flags: 0, + ..echo_reply(¶ms, FLAG_REPLY) + }, + ¶ms, + None, + ), + Err(ProtoError::MissingFlag(FLAG_REPLY)) + ); + + let close_packet = encode_close_request(&CloseRequest { token: TOKEN }, None).unwrap(); + assert_eq!( + decode_echo_request(&close_packet, ¶ms, None), + Err(ProtoError::UnexpectedFlag(FLAG_CLOSE)) + ); + let no_test_packet = encode_open_request( &OpenRequest { params, @@ -97,7 +181,7 @@ fn open_and_close_codecs_enforce_directional_flags() { } #[test] -fn open_and_close_malformed_bodies_and_exact_lengths_are_rejected() { +fn codec_specific_malformed_bodies_and_exact_lengths_are_rejected() { let mut malformed_open_request = MAGIC.to_vec(); malformed_open_request.push(FLAG_OPEN); malformed_open_request.extend_from_slice(&[1, 0x80]); @@ -115,6 +199,28 @@ fn open_and_close_malformed_bodies_and_exact_lengths_are_rejected() { Err(ProtoError::TruncatedVarint) ); + let params = Params { + length: 20, + ..Params::default() + }; + let echo_packet = encode_echo_request(&echo_request(Vec::new()), ¶ms, None).unwrap(); + assert_eq!( + decode_echo_request(&echo_packet[..19], ¶ms, None), + Err(ProtoError::PacketLengthMismatch { + expected: 20, + actual: 19, + }) + ); + let mut long_echo_packet = echo_packet; + long_echo_packet.push(0); + assert_eq!( + decode_echo_request(&long_echo_packet, ¶ms, None), + Err(ProtoError::PacketLengthMismatch { + expected: 20, + actual: 21, + }) + ); + let close_packet = encode_close_request(&CloseRequest { token: TOKEN }, None).unwrap(); assert_eq!( decode_close_request(&close_packet[..11], None), @@ -133,3 +239,123 @@ fn open_and_close_malformed_bodies_and_exact_lengths_are_rejected() { }) ); } + +#[test] +fn echo_layout_combinations_round_trip() { + for received_stats in [ + ReceivedStats::None, + ReceivedStats::Count, + ReceivedStats::Window, + ReceivedStats::Both, + ] { + for stamp_at in [ + StampAt::None, + StampAt::Send, + StampAt::Receive, + StampAt::Both, + StampAt::Midpoint, + ] { + for clock in [Clock::Wall, Clock::Monotonic, Clock::Both] { + for key in [None, Some(KEY)] { + let params = Params { + protocol_version: 1, + received_stats, + stamp_at, + clock, + ..Params::default() + }; + let reply = echo_reply(¶ms, FLAG_REPLY); + let packet = encode_echo_reply(&reply, ¶ms, key).unwrap(); + let decoded = decode_echo_reply(&packet, ¶ms, key).unwrap(); + + assert_eq!(decoded.token, reply.token); + assert_eq!(decoded.sequence, reply.sequence); + assert_eq!(decoded.recv_count, reply.recv_count); + assert_eq!(decoded.recv_window, reply.recv_window); + assert_eq!(decoded.timestamps, reply.timestamps); + assert_eq!(decoded.payload, reply.payload); + } + } + } + } +} + +#[test] +fn echo_reply_requires_exact_negotiated_optional_fields() { + let params = Params { + received_stats: ReceivedStats::Count, + stamp_at: StampAt::Send, + clock: Clock::Wall, + ..Params::default() + }; + let missing_count = EchoReply { + recv_count: None, + ..echo_reply(¶ms, FLAG_REPLY) + }; + assert_eq!( + encode_echo_reply(&missing_count, ¶ms, None), + Err(ProtoError::MissingField("recv_count")) + ); + + let no_optional_params = Params::default(); + let unexpected_timestamp = EchoReply { + timestamps: TimestampFields { + send_wall: Some(1), + ..TimestampFields::default() + }, + ..echo_reply(&no_optional_params, FLAG_REPLY) + }; + assert_eq!( + encode_echo_reply(&unexpected_timestamp, &no_optional_params, None), + Err(ProtoError::UnexpectedField("send_wall")) + ); +} + +#[test] +fn echo_payload_is_copied_zero_filled_and_bounded_in_both_directions() { + let params = Params { + length: 20, + ..Params::default() + }; + + let request = echo_request(vec![1, 2]); + let packet = encode_echo_request(&request, ¶ms, None).unwrap(); + assert_eq!(&packet[16..], &[1, 2, 0, 0]); + let decoded = decode_echo_request(&packet, ¶ms, None).unwrap(); + assert_eq!(decoded.payload, vec![1, 2, 0, 0]); + assert_eq!( + encode_echo_request(&decoded, ¶ms, None).unwrap(), + packet + ); + assert_eq!( + encode_echo_request(&echo_request(vec![0; 5]), ¶ms, None), + Err(ProtoError::PayloadTooLarge { + available: 4, + provided: 5, + }) + ); + + let reply = EchoReply { + payload: vec![3, 4], + ..echo_reply(¶ms, FLAG_REPLY) + }; + let packet = encode_echo_reply(&reply, ¶ms, None).unwrap(); + assert_eq!(&packet[16..], &[3, 4, 0, 0]); + let decoded = decode_echo_reply(&packet, ¶ms, None).unwrap(); + assert_eq!(decoded.payload, vec![3, 4, 0, 0]); + assert_eq!(encode_echo_reply(&decoded, ¶ms, None).unwrap(), packet); + assert_eq!( + encode_echo_reply( + &EchoReply { + payload: vec![0; 5], + ..echo_reply(¶ms, FLAG_REPLY) + }, + ¶ms, + None, + ), + Err(ProtoError::PayloadTooLarge { + available: 4, + provided: 5, + }) + ); +} diff --git a/crates/irtt-proto/tests/vectors.rs b/crates/irtt-proto/tests/vectors.rs index 8d5dea9..e97f2bf 100644 --- a/crates/irtt-proto/tests/vectors.rs +++ b/crates/irtt-proto/tests/vectors.rs @@ -1,7 +1,8 @@ use irtt_proto::{ - decode_close_request, decode_echo_reply, decode_open_reply, decode_open_request, - encode_close_request, encode_echo_request, encode_open_reply, encode_open_request, verify_hmac, - Clock, CloseRequest, EchoRequest, OpenRequest, Params, ReceivedStats, StampAt, + decode_close_request, decode_echo_reply, decode_echo_request, decode_open_reply, + decode_open_request, encode_close_request, encode_echo_reply, encode_echo_request, + encode_open_reply, encode_open_request, verify_hmac, Clock, CloseRequest, EchoRequest, + OpenRequest, Params, ProtoError, ReceivedStats, StampAt, FLAG_REPLY, }; fn hex(input: &str) -> Vec { @@ -79,13 +80,21 @@ fn vector_3_echo_request_no_hmac() { &EchoRequest { token: 0x7896_b6ab_8771_5213, sequence: 0, - params: default_params_3s(), payload: Vec::new(), }, + &default_params_3s(), None, ) .unwrap(); assert_eq!(packet, expected); + assert_eq!( + decode_echo_request(&expected, &default_params_3s(), None), + Ok(EchoRequest { + token: 0x7896_b6ab_8771_5213, + sequence: 0, + payload: Vec::new(), + }) + ); } #[test] @@ -98,6 +107,10 @@ fn vector_4_echo_reply_no_hmac() { assert_eq!(reply.sequence, 2); assert_eq!(reply.recv_count, Some(3)); assert_eq!(reply.recv_window, Some(7)); + assert_eq!( + encode_echo_reply(&reply, &default_params_3s(), None).unwrap(), + packet + ); } #[test] @@ -154,13 +167,21 @@ fn vector_7_hmac_echo_request() { &EchoRequest { token: 0x4387_e9eb_5d3f_ca59, sequence: 0, - params: default_params_3s(), payload: Vec::new(), }, + &default_params_3s(), Some(b"testkey"), ) .unwrap(); assert_eq!(packet, expected); + assert_eq!( + decode_echo_request(&expected, &default_params_3s(), Some(b"testkey")), + Ok(EchoRequest { + token: 0x4387_e9eb_5d3f_ca59, + sequence: 0, + payload: Vec::new(), + }) + ); } #[test] @@ -223,13 +244,21 @@ fn vector_11_minimal_echo_packet() { &EchoRequest { token: 0xa031_6fa2_5c61_154e, sequence: 0, - params: Params::default(), payload: Vec::new(), }, + &Params::default(), None, ) .unwrap(); assert_eq!(packet, expected); + assert_eq!( + decode_echo_request(&expected, &Params::default(), None), + Ok(EchoRequest { + token: 0xa031_6fa2_5c61_154e, + sequence: 0, + payload: Vec::new(), + }) + ); } #[test] @@ -249,6 +278,7 @@ fn vector_12_midpoint_reply() { assert!(reply.timestamps.midpoint_wall.is_some()); assert!(reply.timestamps.recv_wall.is_none()); assert!(reply.timestamps.send_wall.is_none()); + assert_eq!(encode_echo_reply(&reply, ¶ms, None).unwrap(), packet); } #[test] @@ -270,27 +300,51 @@ fn spec_18_1_hmac_echo_request_fixture() { &EchoRequest { token: 0x886b_c9a7_22b3_3eea, sequence: 0x6fe2_a1bb, - params, payload: [0xff, 0xfe, 0xfd, 0xfc].repeat(4), }, + ¶ms, Some(&[0x3c, 0x68, 0x1d, 0x39, 0x41, 0x1d, 0x72, 0x43]), ) .unwrap(); assert_eq!(packet, expected); + assert_eq!( + decode_echo_request( + &expected, + &Params { + length: 92, + received_stats: ReceivedStats::Both, + stamp_at: StampAt::Both, + clock: Clock::Both, + ..Params::default() + }, + Some(&[0x3c, 0x68, 0x1d, 0x39, 0x41, 0x1d, 0x72, 0x43]), + ) + .unwrap() + .payload, + [0xff, 0xfe, 0xfd, 0xfc].repeat(4) + ); } #[test] -fn spec_18_2_hmac_echo_reply_fixture() { +fn spec_18_2_ambiguous_hmac_fixture_omits_reply_flag() { let packet = hex("14 a7 5b 08 d2 98 a3 4a 6a 13 41 02 68 b2 67 a8 d6 7e 28 25 c3 cb 6f 76 b6 ce 66 e6 06 07 3b 1d 19 9f bc a3 9b 3b f8 86 e5 39 e9 d7 a1 75 2a ee 3d f1 5a 52 9a c6 4a 3e 22 62 55 2d 69 3f 29 46 d4 05 97 58 66 50 2c dd 2f f1 1d 46 ff fe fd fc ff fe fd fc ff fe fd fc ff fe fd fc"); - verify_hmac( - &[0xda, 0xb3, 0xe9, 0x04, 0xa6, 0x87, 0x92, 0x49], - &packet, - 4, - ) - .unwrap(); + let key = [0xda, 0xb3, 0xe9, 0x04, 0xa6, 0x87, 0x92, 0x49]; + verify_hmac(&key, &packet, 4).unwrap(); + + let params = Params { + length: 92, + received_stats: ReceivedStats::Both, + stamp_at: StampAt::Both, + clock: Clock::Both, + ..Params::default() + }; + assert_eq!( + decode_echo_reply(&packet, ¶ms, Some(&key)), + Err(ProtoError::MissingFlag(FLAG_REPLY)) + ); }