From 7a5c99810f0b5f3b07085494fe2d780859a8742e Mon Sep 17 00:00:00 2001 From: BFlat Date: Tue, 17 Nov 2026 08:37:48 -0500 Subject: [PATCH] pcap: preserve capture and protocol source history Port relevant PCAP implementation and regression snapshots from Craft Anything b9ca099903aeef5d4b33a7e83e8e7062ab94c65a. --- crates/pcap/src/lib.rs | 202 ++++++++++++++---- .../pcap/tests/regression_pcapng_framing.rs | 66 ++++++ .../pcap/tests/regression_tcp_dns_framing.rs | 67 ++++++ .../tests/regression_tcp_header_length.rs | 52 +++++ crates/pcap/tests/regression_tls_bounds.rs | 102 +++++++++ 5 files changed, 445 insertions(+), 44 deletions(-) create mode 100644 crates/pcap/tests/regression_pcapng_framing.rs create mode 100644 crates/pcap/tests/regression_tcp_dns_framing.rs create mode 100644 crates/pcap/tests/regression_tcp_header_length.rs create mode 100644 crates/pcap/tests/regression_tls_bounds.rs diff --git a/crates/pcap/src/lib.rs b/crates/pcap/src/lib.rs index 5b9aee530..809908396 100644 --- a/crates/pcap/src/lib.rs +++ b/crates/pcap/src/lib.rs @@ -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); } diff --git a/crates/pcap/tests/regression_pcapng_framing.rs b/crates/pcap/tests/regression_pcapng_framing.rs new file mode 100644 index 000000000..69a58a6b3 --- /dev/null +++ b/crates/pcap/tests/regression_pcapng_framing.rs @@ -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()); +} diff --git a/crates/pcap/tests/regression_tcp_dns_framing.rs b/crates/pcap/tests/regression_tcp_dns_framing.rs new file mode 100644 index 000000000..4dad459bb --- /dev/null +++ b/crates/pcap/tests/regression_tcp_dns_framing.rs @@ -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 { + 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()); +} diff --git a/crates/pcap/tests/regression_tcp_header_length.rs b/crates/pcap/tests/regression_tcp_header_length.rs new file mode 100644 index 000000000..189318116 --- /dev/null +++ b/crates/pcap/tests/regression_tcp_header_length.rs @@ -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()); +} diff --git a/crates/pcap/tests/regression_tls_bounds.rs b/crates/pcap/tests/regression_tls_bounds.rs new file mode 100644 index 000000000..674ff7942 --- /dev/null +++ b/crates/pcap/tests/regression_tls_bounds.rs @@ -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); +}