pcap: preserve capture and protocol source history

Port relevant PCAP implementation and regression snapshots from Craft Anything b9ca099903aeef5d4b33a7e83e8e7062ab94c65a.
This commit is contained in:
BFlat authored and Dylan M. Taylor committed 2026-11-17 08:37:48 -05:00
1 parent 8effc0fa3a
commit 7a5c99810f
5 files changed
+445 -44

No files matched your search

+158 -44
View File
@@ -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, &section);
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());
}
+102
View File
@@ -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);
}