mirror of
https://github.com/storytold/craft-libs.git
synced 2026-11-18 08:15:29 +00:00
pcap: preserve capture and protocol source history
Port relevant PCAP implementation and regression snapshots from Craft Anything b9ca099903aeef5d4b33a7e83e8e7062ab94c65a.
This commit is contained in:
1 parent
8effc0fa3a
commit
7a5c99810f
5 files changed
+445
-44
No files matched your search
+158
-44
@@ -224,15 +224,27 @@ impl<'a> Capture<'a> {
|
||||
_ if r.u32_be(p + 8) == Some(NG_BOM) => false,
|
||||
_ => return self.stop(format!("section header at offset {p} has no byte-order mark")),
|
||||
};
|
||||
self.kind = Kind::Ng { le };
|
||||
self.section_base = self.interfaces.len();
|
||||
}
|
||||
let Some(blen) = rd_u32(&r, le, p + 4).and_then(|v| usize::try_from(v).ok()) else {
|
||||
return self.stop(format!("block at offset {p} is cut short"));
|
||||
};
|
||||
if blen < 12 || blen % 4 != 0 || r.slice(p, blen).is_none() {
|
||||
let minimum = match btype {
|
||||
NG_SHB => 28,
|
||||
1 => 20,
|
||||
2 | 6 => 32,
|
||||
3 => 16,
|
||||
_ => 12,
|
||||
};
|
||||
if blen < minimum || blen % 4 != 0 || r.slice(p, blen).is_none() {
|
||||
return self.stop(format!("block at offset {p} has an impossible length {blen}"));
|
||||
}
|
||||
if rd_u32(&r, le, p + blen - 4).and_then(|n| usize::try_from(n).ok()) != Some(blen) {
|
||||
return self.stop(format!("block at offset {p} has an inconsistent trailing length"));
|
||||
}
|
||||
if btype == NG_SHB {
|
||||
self.kind = Kind::Ng { le };
|
||||
self.section_base = self.interfaces.len();
|
||||
}
|
||||
self.pos = p + blen;
|
||||
let body = p + 8;
|
||||
let body_end = p + blen - 4;
|
||||
@@ -652,10 +664,17 @@ fn transport(proto: u8, p: &[u8], d: &mut Decoded) {
|
||||
};
|
||||
d.protocols.push("tcp");
|
||||
let (seq, ack, off, flags, win) = (r.u32_be(4), r.u32_be(8), r.u8(12), r.u8(13), r.u16_be(14));
|
||||
if win.is_none() {
|
||||
d.note = Some("TCP header cut short".into());
|
||||
}
|
||||
let payload = off.map_or(&[][..], |off| p.get(usize::from(off >> 4) * 4..).unwrap_or(&[]));
|
||||
let payload = match off.map(|off| usize::from(off >> 4) * 4) {
|
||||
Some(length) if length < 20 => {
|
||||
d.note = Some("TCP data offset is smaller than its header".into());
|
||||
&[][..]
|
||||
}
|
||||
Some(length) if length <= p.len() => p.get(length..).unwrap_or(&[]),
|
||||
_ => {
|
||||
d.note = Some("TCP header cut short".into());
|
||||
&[][..]
|
||||
}
|
||||
};
|
||||
d.transport = Some(Transport {
|
||||
protocol: "tcp",
|
||||
src_port: Some(sp),
|
||||
@@ -667,8 +686,19 @@ fn transport(proto: u8, p: &[u8], d: &mut Decoded) {
|
||||
payload_len: payload.len(),
|
||||
..empty
|
||||
});
|
||||
if (sp == 53 || dp == 53) && payload.len() > 2 {
|
||||
dns(payload.get(2..).unwrap_or(&[]), d, "dns");
|
||||
if (sp == 53 || dp == 53) && !payload.is_empty() {
|
||||
let framed = Reader::new(payload);
|
||||
match framed.u16_be(0) {
|
||||
Some(length) if length < 12 => d.note = Some("DNS over TCP length is smaller than its header".into()),
|
||||
Some(length) => {
|
||||
if let Some(message) = framed.slice(2, usize::from(length)) {
|
||||
dns(message, d, "dns");
|
||||
} else {
|
||||
d.note = Some("DNS over TCP message cut short".into());
|
||||
}
|
||||
}
|
||||
None => d.note = Some("DNS over TCP length prefix cut short".into()),
|
||||
}
|
||||
} else if !payload.is_empty() {
|
||||
tcp_app(payload, d);
|
||||
}
|
||||
@@ -679,7 +709,19 @@ fn transport(proto: u8, p: &[u8], d: &mut Decoded) {
|
||||
return;
|
||||
};
|
||||
d.protocols.push("udp");
|
||||
let payload = p.get(8..).unwrap_or(&[]);
|
||||
let length = r.u16_be(4).map(usize::from).unwrap_or(0);
|
||||
let payload = if p.len() < 8 {
|
||||
d.note = Some("UDP header cut short".into());
|
||||
&[][..]
|
||||
} else if length < 8 {
|
||||
d.note = Some("UDP length is smaller than its header".into());
|
||||
&[][..]
|
||||
} else {
|
||||
if length > p.len() {
|
||||
d.note = Some("UDP datagram cut short".into());
|
||||
}
|
||||
p.get(8..length.min(p.len())).unwrap_or(&[])
|
||||
};
|
||||
d.transport = Some(Transport { protocol: "udp", src_port: Some(sp), dst_port: Some(dp), payload_len: payload.len(), ..empty });
|
||||
if sp == 53 || dp == 53 {
|
||||
dns(payload, d, "dns");
|
||||
@@ -874,7 +916,11 @@ fn tls(p: &[u8], d: &mut Decoded) {
|
||||
return;
|
||||
}
|
||||
d.protocols.push("tls");
|
||||
if ct != 22 || r.u8(5) != Some(1) {
|
||||
let Some(record_len) = r.u16_be(3) else { return };
|
||||
let record_end = 5 + usize::from(record_len);
|
||||
let record_end_available = record_end.min(p.len());
|
||||
let record = Reader::new(p.get(..record_end_available).unwrap_or(&[]));
|
||||
if ct != 22 || record.u8(5) != Some(1) {
|
||||
return;
|
||||
}
|
||||
let ver = |v: u16| match v {
|
||||
@@ -886,70 +932,138 @@ fn tls(p: &[u8], d: &mut Decoded) {
|
||||
v if v & 0x0f0f == 0x0a0a => "GREASE".into(),
|
||||
v => format!("{v:#06x}"),
|
||||
};
|
||||
let mut hello =
|
||||
TlsHello { record_version: ver(u16::from_be_bytes([major, minor])), sni: None, alpn: Vec::new(), supported_versions: Vec::new(), partial: false };
|
||||
// Record header (5) + handshake header (4) + client_version (2) + random (32).
|
||||
let mut off = 5 + 4 + 2 + 32;
|
||||
let skip8 = |off: usize| r.u8(off).map(|n| off + 1 + usize::from(n));
|
||||
let skip16 = |off: usize| r.u16_be(off).map(|n| off + 2 + usize::from(n));
|
||||
let Some(o) = skip8(off).and_then(skip16).and_then(skip8) else {
|
||||
let mut hello = TlsHello {
|
||||
record_version: ver(u16::from_be_bytes([major, minor])),
|
||||
sni: None,
|
||||
alpn: Vec::new(),
|
||||
supported_versions: Vec::new(),
|
||||
partial: record_end > p.len(),
|
||||
};
|
||||
let Some(handshake_header) = record.u32_be(5) else {
|
||||
hello.partial = true;
|
||||
d.tls = Some(hello);
|
||||
return;
|
||||
};
|
||||
off = o;
|
||||
let handshake_end = 9 + (handshake_header & 0x00ff_ffff) as usize;
|
||||
hello.partial |= handshake_end > record_end_available;
|
||||
let hello_end = handshake_end.min(record_end_available);
|
||||
let r = Reader::new(p.get(..hello_end).unwrap_or(&[]));
|
||||
// Every variable-length field must fit inside this handshake, not merely the packet.
|
||||
let skip8 = |off: usize| {
|
||||
let n = usize::from(r.u8(off)?);
|
||||
r.slice(off + 1, n)?;
|
||||
Some(off + 1 + n)
|
||||
};
|
||||
let skip16 = |off: usize| {
|
||||
let n = usize::from(r.u16_be(off)?);
|
||||
r.slice(off + 2, n)?;
|
||||
Some(off + 2 + n)
|
||||
};
|
||||
// Record header (5) + handshake header (4) + client_version (2) + random (32).
|
||||
let Some(off) = skip8(5 + 4 + 2 + 32).and_then(skip16).and_then(skip8) else {
|
||||
hello.partial = true;
|
||||
d.tls = Some(hello);
|
||||
return;
|
||||
};
|
||||
// Extensions are optional in a complete ClientHello through TLS 1.2.
|
||||
if off == handshake_end && hello_end == handshake_end {
|
||||
d.tls = Some(hello);
|
||||
return;
|
||||
}
|
||||
let Some(ext_len) = r.u16_be(off) else {
|
||||
hello.partial = true;
|
||||
d.tls = Some(hello);
|
||||
return;
|
||||
};
|
||||
let end = off + 2 + usize::from(ext_len);
|
||||
hello.partial = end > p.len();
|
||||
let declared_end = off + 2 + usize::from(ext_len);
|
||||
hello.partial |= declared_end != handshake_end;
|
||||
let end = declared_end.min(hello_end);
|
||||
let extensions = Reader::new(p.get(..end).unwrap_or(&[]));
|
||||
let mut e = off + 2;
|
||||
while e + 4 <= end.min(p.len()) {
|
||||
let (Some(t), Some(l)) = (r.u16_be(e), r.u16_be(e + 2)) else { break };
|
||||
while e + 4 <= end {
|
||||
let (Some(t), Some(l)) = (extensions.u16_be(e), extensions.u16_be(e + 2)) else { break };
|
||||
let body = e + 4;
|
||||
let Some(data) = r.slice(body, usize::from(l)) else {
|
||||
let Some(data) = extensions.slice(body, usize::from(l)) else {
|
||||
hello.partial = true;
|
||||
break;
|
||||
};
|
||||
let dr = Reader::new(data);
|
||||
match t {
|
||||
0 => {
|
||||
if dr.u8(2) == Some(0)
|
||||
&& let Some(n) = dr.u16_be(3).and_then(|n| dr.slice(5, usize::from(n)))
|
||||
{
|
||||
hello.sni = Some(n.iter().map(|&c| if c.is_ascii_graphic() { char::from(c) } else { '?' }).collect());
|
||||
if let Some(len) = dr.u16_be(0) {
|
||||
let list_end = 2 + usize::from(len);
|
||||
hello.partial |= list_end != data.len();
|
||||
let names = Reader::new(data.get(..list_end.min(data.len())).unwrap_or(&[]));
|
||||
let mut a = 2;
|
||||
while a < list_end.min(data.len()) {
|
||||
let (Some(kind), Some(len)) = (names.u8(a), names.u16_be(a + 1)) else {
|
||||
hello.partial = true;
|
||||
break;
|
||||
};
|
||||
let Some(name) = names.slice(a + 3, usize::from(len)) else {
|
||||
hello.partial = true;
|
||||
break;
|
||||
};
|
||||
if kind == 0 {
|
||||
if name.is_empty() {
|
||||
hello.partial = true;
|
||||
} else if hello.sni.is_none() {
|
||||
hello.sni = Some(name.iter().map(|&c| if c.is_ascii_graphic() { char::from(c) } else { '?' }).collect());
|
||||
}
|
||||
}
|
||||
a += 3 + usize::from(len);
|
||||
}
|
||||
} else {
|
||||
hello.partial = true;
|
||||
}
|
||||
}
|
||||
16 => {
|
||||
let mut a = 2usize;
|
||||
while let Some(n) = dr.u8(a) {
|
||||
let Some(proto) = dr.slice(a + 1, usize::from(n)) else { break };
|
||||
hello.alpn.push(String::from_utf8_lossy(proto).into_owned());
|
||||
a += 1 + usize::from(n);
|
||||
if hello.alpn.len() >= 16 {
|
||||
break;
|
||||
if let Some(len) = dr.u16_be(0) {
|
||||
let list_end = 2 + usize::from(len);
|
||||
hello.partial |= list_end != data.len();
|
||||
let protocols = Reader::new(data.get(..list_end.min(data.len())).unwrap_or(&[]));
|
||||
let mut a = 2usize;
|
||||
while a < list_end.min(data.len()) && hello.alpn.len() < 16 {
|
||||
let Some(n) = protocols.u8(a).filter(|&n| n > 0) else {
|
||||
hello.partial = true;
|
||||
break;
|
||||
};
|
||||
let Some(proto) = protocols.slice(a + 1, usize::from(n)) else {
|
||||
hello.partial = true;
|
||||
break;
|
||||
};
|
||||
hello.alpn.push(String::from_utf8_lossy(proto).into_owned());
|
||||
a += 1 + usize::from(n);
|
||||
}
|
||||
} else {
|
||||
hello.partial = true;
|
||||
}
|
||||
}
|
||||
43 => {
|
||||
let mut a = 1usize;
|
||||
while let Some(v) = dr.u16_be(a) {
|
||||
let name = ver(v);
|
||||
if name != "GREASE" {
|
||||
hello.supported_versions.push(name);
|
||||
}
|
||||
a += 2;
|
||||
if hello.supported_versions.len() >= 16 {
|
||||
break;
|
||||
if let Some(len) = dr.u8(0) {
|
||||
let list_end = 1 + usize::from(len);
|
||||
hello.partial |= list_end != data.len() || len % 2 != 0;
|
||||
let versions = Reader::new(data.get(..list_end.min(data.len())).unwrap_or(&[]));
|
||||
let mut a = 1usize;
|
||||
while let Some(v) = versions.u16_be(a) {
|
||||
let name = ver(v);
|
||||
if name != "GREASE" {
|
||||
hello.supported_versions.push(name);
|
||||
}
|
||||
a += 2;
|
||||
if hello.supported_versions.len() >= 16 {
|
||||
break;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
hello.partial = true;
|
||||
}
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
e = body + usize::from(l);
|
||||
}
|
||||
hello.partial |= e != end;
|
||||
d.tls = Some(hello);
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,66 @@
|
||||
use craft_anything_formats::pcap::summarize;
|
||||
use craft_anything_testkit::pcap::{block, pcapng, sample_frames};
|
||||
|
||||
#[test]
|
||||
fn mismatched_block_footers_stop_the_capture_with_a_warning() {
|
||||
let original = pcapng(&sample_frames());
|
||||
for footer in [24, 56] {
|
||||
let mut data = original.clone();
|
||||
data[footer..footer + 4].copy_from_slice(&12u32.to_le_bytes());
|
||||
let result = summarize(&data, &|| false).unwrap();
|
||||
assert!(!result.warnings.is_empty(), "footer at {footer}");
|
||||
assert_eq!(result.packets, 0);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn fixed_block_headers_cannot_borrow_the_next_blocks_bytes() {
|
||||
let header = pcapng(&[]);
|
||||
for (kind, short_body) in [(1, vec![]), (2, vec![0; 16]), (6, vec![0; 16]), (3, vec![])] {
|
||||
let mut data = header[..28].to_vec();
|
||||
if kind != 1 {
|
||||
data.extend(&header[28..]);
|
||||
}
|
||||
data.extend(block(kind, &short_body));
|
||||
data.extend(&pcapng(&sample_frames())[28..]);
|
||||
let result = summarize(&data, &|| false).unwrap();
|
||||
assert!(!result.warnings.is_empty(), "kind {kind}");
|
||||
assert_eq!(result.packets, 0, "kind {kind}");
|
||||
assert_eq!(result.interfaces.len(), usize::from(kind != 1), "kind {kind}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn valid_blocks_and_unknown_blocks_still_work() {
|
||||
let original = pcapng(&sample_frames());
|
||||
let mut data = original[..60].to_vec();
|
||||
data.extend(block(0x0000_1234, b"ignored"));
|
||||
data.extend(&original[60..]);
|
||||
let result = summarize(&data, &|| false).unwrap();
|
||||
assert_eq!(result.packets, 7);
|
||||
assert!(result.warnings.is_empty());
|
||||
assert_eq!(result.interfaces.len(), 1);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn big_endian_block_footers_use_the_sections_byte_order() {
|
||||
let be_block = |kind: u32, body: &[u8]| {
|
||||
let size = (body.len() + 12) as u32;
|
||||
let mut out = kind.to_be_bytes().to_vec();
|
||||
out.extend(size.to_be_bytes());
|
||||
out.extend(body);
|
||||
out.extend(size.to_be_bytes());
|
||||
out
|
||||
};
|
||||
let mut section = 0x1a2b3c4du32.to_be_bytes().to_vec();
|
||||
section.extend([0, 1, 0, 0]);
|
||||
section.extend((-1i64).to_be_bytes());
|
||||
let mut data = be_block(0x0a0d0d0a, §ion);
|
||||
data.extend(be_block(1, &[0, 1, 0, 0, 0, 0, 0, 0]));
|
||||
let result = summarize(&data, &|| false).unwrap();
|
||||
assert!(result.warnings.is_empty());
|
||||
assert_eq!(result.interfaces[0].link_type, 1);
|
||||
let end = data.len();
|
||||
data[end - 4..].copy_from_slice(&20u32.to_le_bytes());
|
||||
assert!(!summarize(&data, &|| false).unwrap().warnings.is_empty());
|
||||
}
|
||||
@@ -0,0 +1,67 @@
|
||||
use craft_anything_formats::pcap::{Decoded, decode};
|
||||
use craft_anything_testkit::pcap::{dns_query, dns_response, ipv4_pkt, tcp};
|
||||
|
||||
fn decoded(payload: &[u8]) -> Decoded {
|
||||
decode(101, &ipv4_pkt(6, [192, 0, 2, 1], [192, 0, 2, 2], &tcp(53, 51000, 0x18, payload)))
|
||||
}
|
||||
|
||||
fn framed(message: &[u8], declared: usize) -> Vec<u8> {
|
||||
let mut payload = (declared as u16).to_be_bytes().to_vec();
|
||||
payload.extend(message);
|
||||
payload
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn an_unfinished_dns_message_is_not_reported_complete() {
|
||||
let message = dns_response();
|
||||
let result = decoded(&framed(&message, message.len() + 1));
|
||||
assert!(result.dns.is_none());
|
||||
assert!(result.note.is_some());
|
||||
assert_eq!(result.transport.unwrap().src_port, Some(53));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn dns_records_cannot_borrow_bytes_past_the_message_length() {
|
||||
let result = decoded(&framed(&dns_response(), 12));
|
||||
let dns = result.dns.unwrap();
|
||||
assert!(dns.questions.is_empty() && dns.answers.is_empty());
|
||||
assert!(dns.incomplete);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_length_smaller_than_the_dns_header_is_rejected() {
|
||||
for length in 0..12 {
|
||||
let result = decoded(&framed(&dns_response(), length));
|
||||
assert!(result.dns.is_none(), "length {length}");
|
||||
assert!(result.note.is_some(), "length {length}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_partial_dns_length_prefix_is_reported() {
|
||||
let result = decoded(&[0]);
|
||||
assert!(result.dns.is_none());
|
||||
assert!(result.note.is_some());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn an_empty_tcp_ack_does_not_claim_a_missing_dns_message() {
|
||||
let result = decoded(&[]);
|
||||
assert!(result.dns.is_none());
|
||||
assert!(result.note.is_none());
|
||||
assert_eq!(result.transport.unwrap().payload_len, 0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_first_complete_dns_message_is_decoded_without_the_next_one() {
|
||||
let first = dns_query();
|
||||
let second = dns_response();
|
||||
let mut payload = framed(&first, first.len());
|
||||
payload.extend(framed(&second, second.len()));
|
||||
let result = decoded(&payload);
|
||||
let dns = result.dns.unwrap();
|
||||
assert!(!dns.response && !dns.incomplete);
|
||||
assert_eq!(dns.questions[0].name, "example.com");
|
||||
assert!(dns.answers.is_empty());
|
||||
assert!(result.note.is_none());
|
||||
}
|
||||
@@ -0,0 +1,52 @@
|
||||
use craft_anything_formats::pcap::{Decoded, decode};
|
||||
use craft_anything_testkit::pcap::{ipv4_pkt, tcp};
|
||||
|
||||
fn decoded(segment: &[u8]) -> Decoded {
|
||||
decode(101, &ipv4_pkt(6, [192, 0, 2, 1], [192, 0, 2, 2], segment))
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_tcp_header_shorter_than_twenty_bytes_is_not_payload() {
|
||||
for words in 0..5u8 {
|
||||
let mut segment = tcp(51000, 80, 0x18, b"GET / HTTP/1.1\r\n\r\n");
|
||||
segment[12] = words << 4;
|
||||
let result = decoded(&segment);
|
||||
let transport = result.transport.unwrap();
|
||||
assert_eq!(transport.payload_len, 0, "offset {words}");
|
||||
assert_eq!((transport.src_port, transport.dst_port), (Some(51000), Some(80)));
|
||||
assert!(result.http.is_none() && result.tls.is_none());
|
||||
assert!(result.note.is_some());
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_cut_tcp_header_keeps_ports_but_reports_the_cut() {
|
||||
let whole = tcp(51000, 80, 0x18, b"request");
|
||||
for end in 4..20 {
|
||||
let result = decoded(&whole[..end]);
|
||||
let transport = result.transport.unwrap();
|
||||
assert_eq!((transport.src_port, transport.dst_port), (Some(51000), Some(80)));
|
||||
assert_eq!(transport.payload_len, 0);
|
||||
assert!(result.note.is_some(), "cut at {end}");
|
||||
}
|
||||
for words in 6..=15u8 {
|
||||
let mut segment = tcp(51000, 80, 0x18, &[]);
|
||||
segment[12] = words << 4;
|
||||
let result = decoded(&segment);
|
||||
assert_eq!(result.transport.unwrap().payload_len, 0);
|
||||
assert!(result.note.is_some(), "missing options for offset {words}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_valid_tcp_header_with_options_finds_its_payload() {
|
||||
let mut segment = tcp(51000, 80, 0x18, &[]);
|
||||
segment[12] = 7 << 4;
|
||||
segment.extend([1; 8]);
|
||||
let payload = b"GET /resource HTTP/1.1\r\nHost: example.test\r\n\r\n";
|
||||
segment.extend(payload);
|
||||
let result = decoded(&segment);
|
||||
assert_eq!(result.transport.unwrap().payload_len, payload.len());
|
||||
assert_eq!(result.http.unwrap().target.as_deref(), Some("/resource"));
|
||||
assert!(result.note.is_none());
|
||||
}
|
||||
@@ -0,0 +1,102 @@
|
||||
use craft_anything_formats::pcap::{Decoded, decode};
|
||||
use craft_anything_testkit::pcap::{client_hello, ipv4_pkt, tcp};
|
||||
|
||||
fn decoded(record: &[u8]) -> Decoded {
|
||||
decode(101, &ipv4_pkt(6, [192, 0, 2, 1], [192, 0, 2, 2], &tcp(51000, 443, 0x18, record)))
|
||||
}
|
||||
|
||||
fn assert_no_complete_sni(record: &[u8]) {
|
||||
let result = decoded(record);
|
||||
assert!(result.protocols.contains(&"tls"));
|
||||
assert!(result.tls.is_none_or(|hello| hello.sni.is_none() && hello.partial));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_client_hello_cannot_read_past_its_tls_record() {
|
||||
let mut record = client_hello("example.test");
|
||||
record[3..5].copy_from_slice(&4u16.to_be_bytes());
|
||||
assert_no_complete_sni(&record);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_client_hello_cannot_read_past_its_handshake() {
|
||||
let mut record = client_hello("example.test");
|
||||
record[6..9].copy_from_slice(&[0, 0, 34]);
|
||||
assert_no_complete_sni(&record);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn extensions_cannot_read_past_the_declared_extension_list() {
|
||||
let mut record = client_hello("example.test");
|
||||
record[50..52].copy_from_slice(&4u16.to_be_bytes());
|
||||
assert_no_complete_sni(&record);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_truncated_record_reports_partial_even_when_the_hello_fields_fit() {
|
||||
let mut record = client_hello("example.test");
|
||||
let larger = (record.len() + 20) as u16;
|
||||
record[3..5].copy_from_slice(&larger.to_be_bytes());
|
||||
assert!(decoded(&record).tls.unwrap().partial);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn server_names_stay_inside_the_name_list() {
|
||||
let mut record = client_hello("example.test");
|
||||
record[56..58].copy_from_slice(&3u16.to_be_bytes());
|
||||
assert_no_complete_sni(&record);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn alpn_names_stay_inside_the_protocol_list() {
|
||||
let mut record = client_hello("example.test");
|
||||
let alpn_list = 52 + 4 + 5 + "example.test".len() + 4;
|
||||
record[alpn_list..alpn_list + 2].copy_from_slice(&3u16.to_be_bytes());
|
||||
let hello = decoded(&record).tls.unwrap();
|
||||
assert_eq!(hello.alpn, ["h2"]);
|
||||
assert!(hello.partial);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn supported_versions_stay_inside_the_version_list() {
|
||||
let mut record = client_hello("example.test");
|
||||
let versions = 52 + 4 + 5 + "example.test".len() + 4 + 14 + 4;
|
||||
record[versions] = 2;
|
||||
let hello = decoded(&record).tls.unwrap();
|
||||
assert_eq!(hello.supported_versions, ["TLS 1.3"]);
|
||||
assert!(hello.partial);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_complete_legacy_hello_can_omit_extensions() {
|
||||
let mut record = client_hello("example.test");
|
||||
record.truncate(50);
|
||||
record[3..5].copy_from_slice(&45u16.to_be_bytes());
|
||||
record[6..9].copy_from_slice(&[0, 0, 41]);
|
||||
record[46..48].copy_from_slice(&0x002fu16.to_be_bytes());
|
||||
let hello = decoded(&record).tls.unwrap();
|
||||
assert!(hello.sni.is_none() && hello.alpn.is_empty() && hello.supported_versions.is_empty());
|
||||
assert!(!hello.partial);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_following_handshake_does_not_extend_the_first_hello() {
|
||||
let mut record = client_hello("example.test");
|
||||
record.extend([14, 0, 0, 0]);
|
||||
let record_len = (record.len() - 5) as u16;
|
||||
record[3..5].copy_from_slice(&record_len.to_be_bytes());
|
||||
let hello = decoded(&record).tls.unwrap();
|
||||
assert_eq!(hello.sni.as_deref(), Some("example.test"));
|
||||
assert_eq!(hello.alpn, ["h2", "http/1.1"]);
|
||||
assert!(!hello.partial);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn complete_hello_metadata_is_unchanged() {
|
||||
let record = client_hello("example.test");
|
||||
let hello = decoded(&record).tls.unwrap();
|
||||
assert_eq!(hello.sni.as_deref(), Some("example.test"));
|
||||
assert_eq!(hello.alpn, ["h2", "http/1.1"]);
|
||||
assert_eq!(hello.supported_versions, ["TLS 1.3", "TLS 1.2"]);
|
||||
assert!(!hello.partial);
|
||||
}
|
||||
Reference in new issue
Block a user