136 lines
3.7 KiB
Rust
136 lines
3.7 KiB
Rust
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,
|
|
};
|
|
|
|
const KEY: &[u8] = b"testkey";
|
|
const TOKEN: u64 = 0x7896_b6ab_8771_5213;
|
|
|
|
#[test]
|
|
fn authenticated_open_reply_encoder_sets_hmac_from_key() {
|
|
let reply = OpenReply {
|
|
flags: FLAG_OPEN | FLAG_REPLY,
|
|
token: TOKEN,
|
|
params: Params {
|
|
protocol_version: 1,
|
|
..Params::default()
|
|
},
|
|
};
|
|
let packet = encode_open_reply(&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
|
|
})
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn rejected_open_reply_round_trips_and_zero_token_requires_close() {
|
|
let rejected = OpenReply {
|
|
flags: FLAG_OPEN | FLAG_REPLY | FLAG_CLOSE,
|
|
token: 0,
|
|
params: Params {
|
|
protocol_version: 1,
|
|
..Params::default()
|
|
},
|
|
};
|
|
let packet = encode_open_reply(&rejected, None).unwrap();
|
|
assert_eq!(decode_open_reply(&packet, None), Ok(rejected.clone()));
|
|
|
|
assert_eq!(
|
|
encode_open_reply(
|
|
&OpenReply {
|
|
flags: FLAG_OPEN | FLAG_REPLY,
|
|
..rejected
|
|
},
|
|
None,
|
|
),
|
|
Err(ProtoError::ZeroToken)
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn open_and_close_codecs_enforce_directional_flags() {
|
|
let params = Params::default();
|
|
let open_reply_packet = encode_open_reply(
|
|
&OpenReply {
|
|
flags: FLAG_OPEN | FLAG_REPLY,
|
|
token: TOKEN,
|
|
params: params.clone(),
|
|
},
|
|
None,
|
|
)
|
|
.unwrap();
|
|
assert_eq!(
|
|
decode_open_request(&open_reply_packet, None),
|
|
Err(ProtoError::UnexpectedFlag(FLAG_REPLY))
|
|
);
|
|
assert_eq!(
|
|
encode_open_reply(
|
|
&OpenReply {
|
|
flags: FLAG_REPLY,
|
|
token: TOKEN,
|
|
params: params.clone(),
|
|
},
|
|
None,
|
|
),
|
|
Err(ProtoError::MissingFlag(FLAG_OPEN))
|
|
);
|
|
|
|
let no_test_packet = encode_open_request(
|
|
&OpenRequest {
|
|
params,
|
|
close: true,
|
|
},
|
|
None,
|
|
)
|
|
.unwrap();
|
|
assert_eq!(
|
|
decode_close_request(&no_test_packet, None),
|
|
Err(ProtoError::UnexpectedFlag(FLAG_OPEN))
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn open_and_close_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]);
|
|
assert_eq!(
|
|
decode_open_request(&malformed_open_request, None),
|
|
Err(ProtoError::TruncatedVarint)
|
|
);
|
|
|
|
let mut malformed_open_reply = MAGIC.to_vec();
|
|
malformed_open_reply.push(FLAG_OPEN | FLAG_REPLY);
|
|
malformed_open_reply.extend_from_slice(&TOKEN.to_le_bytes());
|
|
malformed_open_reply.extend_from_slice(&[1, 0x80]);
|
|
assert_eq!(
|
|
decode_open_reply(&malformed_open_reply, None),
|
|
Err(ProtoError::TruncatedVarint)
|
|
);
|
|
|
|
let close_packet = encode_close_request(&CloseRequest { token: TOKEN }, None).unwrap();
|
|
assert_eq!(
|
|
decode_close_request(&close_packet[..11], None),
|
|
Err(ProtoError::PacketLengthMismatch {
|
|
expected: 12,
|
|
actual: 11,
|
|
})
|
|
);
|
|
let mut long_close_packet = close_packet;
|
|
long_close_packet.push(0);
|
|
assert_eq!(
|
|
decode_close_request(&long_close_packet, None),
|
|
Err(ProtoError::PacketLengthMismatch {
|
|
expected: 12,
|
|
actual: 13,
|
|
})
|
|
);
|
|
}
|