pcap: preserve capture and protocol source history

Port relevant PCAP implementation and regression snapshots from Craft Anything 60409b684c805482cfa3965fbc368bcc26de106d.
This commit is contained in:
BFlat authored and Dylan M. Taylor committed 2026-11-17 08:37:49 -05:00
1 parent 7a5c99810f
commit 9ecd830f68
11 files changed
+1061 -45

No files matched your search

+203 -45
View File
@@ -12,7 +12,7 @@ use serde::Serialize;
use std::collections::{BTreeMap, BTreeSet, HashMap};
use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
/// Most frames read from one capture.
/// Most frames and rejected simple packet blocks read from one capture.
pub const MAX_PACKETS: u64 = 5_000_000;
/// Most flows tracked; later flows are counted but get no id.
pub const MAX_FLOWS: usize = 100_000;
@@ -89,6 +89,8 @@ pub struct Capture<'a> {
/// The walk stopped at `MAX_PACKETS`.
pub truncated: bool,
count: u64,
rejected_simple_blocks: u64,
rejected_simple_reported: bool,
}
fn rd_u16(r: &Reader<'_>, le: bool, off: usize) -> Option<u16> {
@@ -126,6 +128,8 @@ impl<'a> Capture<'a> {
warnings: Vec::new(),
truncated: false,
count: 0,
rejected_simple_blocks: 0,
rejected_simple_reported: false,
};
let classic = |le: bool, nanos: bool| -> Result<(Kind, String, Interface), FormatError> {
let major = rd_u16(&r, le, 4).ok_or_else(|| FormatError::Truncated("pcap header".into()))?;
@@ -168,6 +172,26 @@ impl<'a> Capture<'a> {
None
}
fn packet_limit_reached(&mut self) -> bool {
if self.count.saturating_add(self.rejected_simple_blocks) < MAX_PACKETS {
return false;
}
if !self.truncated && self.pos < self.data.len() {
self.truncated = true;
self.warnings.push(format!("stopped after {MAX_PACKETS} packet records"));
}
true
}
fn report_rejected_simple_blocks(&mut self) {
if self.rejected_simple_blocks > 0 && !self.rejected_simple_reported {
let n = self.rejected_simple_blocks;
let suffix = if n == 1 { "" } else { "s" };
self.warnings.push(format!("skipped {n} simple packet block{suffix} with inconsistent captured lengths"));
self.rejected_simple_reported = true;
}
}
fn ts(&self, iface: usize, units: u64) -> Option<u64> {
let (base, exp) = self.interfaces.get(iface).map(|i| i.tsresol).unwrap_or((10, 6));
let offset_s = self.interfaces.get(iface).map(|i| i.tsoffset).unwrap_or(0);
@@ -211,6 +235,9 @@ impl<'a> Capture<'a> {
fn next_ng(&mut self, mut le: bool) -> Option<Frame<'a>> {
loop {
if self.packet_limit_reached() {
return None;
}
let r = Reader::new(self.data);
let p = self.pos;
if p >= self.data.len() {
@@ -312,7 +339,11 @@ impl<'a> Capture<'a> {
let iface = self.section_base;
let snap = self.interfaces.get(iface).map(|i| i.snaplen).filter(|&s| s > 0).unwrap_or(u32::MAX);
let room = body_end.saturating_sub(body + 4);
let cap = (orig.min(snap) as usize).min(room);
let cap = orig.min(snap) as usize;
if cap.checked_add(3).map(|n| n & !3) != Some(room) {
self.rejected_simple_blocks += 1;
continue;
}
let Some(data) = r.slice(body + 4, cap) else { continue };
if iface >= self.interfaces.len() {
continue;
@@ -338,17 +369,18 @@ impl<'a> Iterator for Capture<'a> {
type Item = Frame<'a>;
fn next(&mut self) -> Option<Frame<'a>> {
if self.count >= MAX_PACKETS {
if !self.truncated && self.pos < self.data.len() {
self.truncated = true;
self.warnings.push(format!("stopped after {MAX_PACKETS} frames"));
let frame = if self.packet_limit_reached() {
None
} else {
match self.kind {
Kind::Classic { le, nanos } => self.next_classic(le, nanos),
Kind::Ng { le } => self.next_ng(le),
}
return None;
}
match self.kind {
Kind::Classic { le, nanos } => self.next_classic(le, nanos),
Kind::Ng { le } => self.next_ng(le),
};
if frame.is_none() {
self.report_rejected_simple_blocks();
}
frame
}
}
@@ -535,7 +567,12 @@ pub fn decode(link_type: u32, data: &[u8]) -> Decoded {
}
12 | 14 | 101 | 228 | 229 => {
d.protocols.push("raw");
(r.u8(0).map(|b| if b >> 4 == 6 { 0x86dd } else { 0x0800 }), 0)
let ethertype = match link_type {
228 => Some(0x0800),
229 => Some(0x86dd),
_ => r.u8(0).map(|b| if b >> 4 == 6 { 0x86dd } else { 0x0800 }),
};
(ethertype, 0)
}
_ => {
d.note = Some(format!("link type {link_type} ({}) is not decoded", link_name(link_type)));
@@ -560,11 +597,15 @@ fn ipv4(p: &[u8], d: &mut Decoded) {
return;
};
let ihl = usize::from(vihl & 0x0f) * 4;
let (Some(src), Some(dst)) = (r.slice(12, 4), r.slice(16, 4)) else { return };
if vihl >> 4 != 4 || ihl < 20 {
if vihl >> 4 != 4 || ihl < 20 || usize::from(total) < ihl {
d.note = Some("not a valid IPv4 header".into());
return;
}
if r.slice(0, ihl).is_none() {
d.note = Some("IPv4 header cut short".into());
return;
}
let (Some(src), Some(dst)) = (r.slice(12, 4), r.slice(16, 4)) else { return };
d.protocols.push("ipv4");
let ip4 = |b: &[u8]| {
IpAddr::V4(Ipv4Addr::new(
@@ -576,7 +617,7 @@ fn ipv4(p: &[u8], d: &mut Decoded) {
};
let fragment = frag & 0x1fff != 0;
d.ip = Some(IpInfo { version: 4, src: ip4(src), dst: ip4(dst), protocol: proto, ttl, fragment });
let end = usize::from(total).clamp(ihl, p.len().max(ihl));
let end = usize::from(total).min(p.len());
let body = p.get(ihl..end).unwrap_or(&[]);
if fragment {
d.note = Some("IPv4 fragment (transport header is in the first fragment)".into());
@@ -591,6 +632,10 @@ fn ipv6(p: &[u8], d: &mut Decoded) {
d.note = Some("IPv6 header cut short".into());
return;
};
if r.u8(0).is_none_or(|version| version >> 4 != 6) {
d.note = Some("not a valid IPv6 header".into());
return;
}
d.protocols.push("ipv6");
let ip6 = |b: &[u8]| IpAddr::V6(Ipv6Addr::from(<[u8; 16]>::try_from(b).unwrap_or([0; 16])));
let end = (40 + usize::from(plen)).min(p.len());
@@ -616,6 +661,9 @@ fn ipv6(p: &[u8], d: &mut Decoded) {
next = n;
fragment = fo & 0xfff8 != 0;
off += 8;
if fragment {
break;
}
}
51 => {
let (Some(n), Some(l)) = (payload_reader.u8(off), payload_reader.u8(off + 1)) else { break };
@@ -756,14 +804,29 @@ pub fn qtype_name(t: u16) -> String {
}
}
/// A (possibly compressed) DNS name at `off`; returns the name and the offset after it.
fn dns_name(msg: &[u8], mut off: usize) -> Option<(String, usize)> {
fn dns_sd_service_label(label: &[u8]) -> bool {
let Some(name) = label.strip_prefix(b"_") else { return false };
// RFC 6763 §7 / RFC 6335 §5.1, excluding the leading underscore.
(1..=15).contains(&name.len())
&& name.first().is_some_and(u8::is_ascii_alphanumeric)
&& name.last().is_some_and(u8::is_ascii_alphanumeric)
&& name.iter().all(|c| c.is_ascii_alphanumeric() || *c == b'-')
&& name.iter().any(u8::is_ascii_alphabetic)
&& !name.windows(2).any(|pair| pair == b"--")
}
/// A DNS name, the offset after it, and whether its wire labels name a DNS-SD instance.
fn dns_name(msg: &[u8], mut off: usize) -> Option<(String, usize, bool)> {
let mut out = String::new();
// Count the expanded wire name, including label lengths and the terminating root.
let mut wire_len = 1usize;
let mut after: Option<usize> = None;
let mut labels = 0;
let mut service_instance = false;
for _ in 0..128 {
let len = *msg.get(off)?;
match len {
0 => return Some((if out.is_empty() { ".".into() } else { out }, after.unwrap_or(off + 1))),
0 => return Some((if out.is_empty() { ".".into() } else { out }, after.unwrap_or(off + 1), labels >= 4 && service_instance)),
l if l & 0xc0 == 0xc0 => {
let ptr = usize::from(u16::from_be_bytes([l & 0x3f, *msg.get(off + 1)?]));
after.get_or_insert(off + 2);
@@ -774,13 +837,22 @@ fn dns_name(msg: &[u8], mut off: usize) -> Option<(String, usize)> {
}
l if l < 64 => {
let label = msg.get(off + 1..off + 1 + usize::from(l))?;
wire_len += 1 + label.len();
if wire_len > 255 {
return None;
}
// Match Instance / _service / _tcp|_udp / Domain before rendering:
// a literal dot inside one wire label is not a label boundary.
match labels {
1 => service_instance = dns_sd_service_label(label),
2 => service_instance &= label.eq_ignore_ascii_case(b"_tcp") || label.eq_ignore_ascii_case(b"_udp"),
_ => {}
}
labels += 1;
if !out.is_empty() {
out.push('.');
}
out.extend(label.iter().map(|&c| if c.is_ascii_graphic() { char::from(c) } else { '?' }));
if out.len() > 255 {
return None;
}
off += 1 + usize::from(l);
}
_ => return None,
@@ -789,22 +861,26 @@ fn dns_name(msg: &[u8], mut off: usize) -> Option<(String, usize)> {
None
}
/// Decode a bounded set of DNS questions and answer/prerequisite records from one message.
/// Preserve complete entries before malformed data and mark the message incomplete.
fn dns(msg: &[u8], d: &mut Decoded, label: &'static str) {
let r = Reader::new(msg);
let (Some(id), Some(flags), Some(qd), Some(an)) = (r.u16_be(0), r.u16_be(2), r.u16_be(4), r.u16_be(6)) else { return };
let opcode = (flags >> 11) & 0xf;
// Sanity: opcode 0–6 and no absurd counts, so random payload on port 53 isn't misread.
if (flags >> 11) & 0xf > 6 || qd > 64 || qd == 0 && an == 0 {
if opcode > 6 || qd > 64 || qd == 0 && an == 0 {
return;
}
d.protocols.push(label);
let mut out = Dns { id, response: flags & 0x8000 != 0, rcode: (flags & 0xf) as u8, questions: Vec::new(), answers: Vec::new(), incomplete: false };
let mut off = 12usize;
for _ in 0..qd {
let Some((name, next)) = dns_name(msg, off) else {
let Some((name, next, _)) = dns_name(msg, off) else {
out.incomplete = true;
break;
};
let Some(qt) = r.u16_be(next) else {
// The class is not displayed, but both two-byte fields must be present.
let (Some(qt), Some(_class)) = (r.u16_be(next), r.u16_be(next + 2)) else {
out.incomplete = true;
break;
};
@@ -813,11 +889,11 @@ fn dns(msg: &[u8], d: &mut Decoded, label: &'static str) {
}
if !out.incomplete {
for _ in 0..an.min(64) {
let Some((name, next)) = dns_name(msg, off) else {
let Some((name, next, service_instance)) = dns_name(msg, off) else {
out.incomplete = true;
break;
};
let (Some(rt), Some(ttl), Some(rdlen)) = (r.u16_be(next), r.u32_be(next + 4), r.u16_be(next + 8)) else {
let (Some(rt), Some(class), Some(ttl), Some(rdlen)) = (r.u16_be(next), r.u16_be(next + 2), r.u32_be(next + 4), r.u16_be(next + 8)) else {
out.incomplete = true;
break;
};
@@ -835,31 +911,54 @@ fn dns(msg: &[u8], d: &mut Decoded, label: &'static str) {
)
.to_string(),
(28, 16) => Ipv6Addr::from(<[u8; 16]>::try_from(rd).unwrap_or([0; 16])).to_string(),
(2 | 5 | 12, _) => dns_name(msg, rd_off).map(|(n, _)| n).unwrap_or_default(),
(15, _) => dns_name(msg, rd_off + 2).map(|(n, _)| n).unwrap_or_default(),
(2 | 5 | 12 | 15, _) => {
// RFC 2136 prerequisites can name an RRset without carrying its value.
if rd.is_empty() && opcode == 5 && matches!(class, 254 | 255) && ttl == 0 {
String::new()
} else {
let end = rd_off + rd.len();
let start = rd_off + if rt == 15 { 2 } else { 0 };
// Keep earlier bytes available to compression pointers, but the encoded
// name itself must fit the record and account for all of its RDATA.
let Some((name, _, _)) = dns_name(msg.get(..end).unwrap_or(&[]), start).filter(|(_, after, _)| *after == end) else {
out.incomplete = true;
break;
};
name
}
}
(16, _) => {
// RFC 1035 §3.3.14: one TXT RDATA holds any number of
// RFC 1035 §3.3.14: one TXT RDATA holds one or more
// length-prefixed character strings, and a zero-length
// string does not end the record. Consumers join them all
// (RFC 7208 §3.3), so keep every string instead of the
// first one and skip the rest of the RDATA.
let mut txt = String::new();
let mut pos = 0;
// UPDATE's answer section holds prerequisites. ANY/NONE
// prerequisites use empty RDATA and zero TTL (RFC 2136 §2.4).
let empty_prerequisite = opcode == 5 && matches!(class, 254 | 255) && ttl == 0;
// DNS-SD receivers treat empty RDATA as an empty string
// (RFC 6763 §6.1), for both multicast and unicast DNS.
let empty_service_txt = opcode == 0 && service_instance;
out.incomplete |= rd.is_empty() && !empty_prerequisite && !empty_service_txt;
while let Some(&len) = rd.get(pos) {
let len = usize::from(len);
let end = (pos + 1).saturating_add(len).min(rd.len());
match rd.get(pos + 1..end) {
Some(part) => {
txt.push_str(&String::from_utf8_lossy(part));
pos = end;
}
None => break,
}
let end = pos + 1 + len;
let Some(part) = rd.get(pos + 1..end) else {
out.incomplete = true;
break;
};
txt.push_str(&String::from_utf8_lossy(part));
pos = end;
}
txt
}
(_, n) => format!("<{n} bytes>"),
};
if out.incomplete {
break;
}
out.answers.push(DnsAnswer { name, rtype: qtype_name(rt), ttl, value });
off = rd_off + usize::from(rdlen);
}
@@ -896,12 +995,21 @@ fn tcp_app(p: &[u8], d: &mut Decoded) {
&& METHODS.contains(&m)
&& v.starts_with("HTTP/1.")
{
let lower = String::from_utf8_lossy(head).to_ascii_lowercase();
let host = lower.find("\r\nhost:").and_then(|i| {
let start = i + 7;
let raw = String::from_utf8_lossy(head.get(start..)?).into_owned();
Some(raw.split("\r\n").next().unwrap_or("").trim().to_string())
});
let mut remaining = head.get(line_end + 2..).unwrap_or(&[]);
let mut host = None;
while let Some(end) = remaining.windows(2).position(|w| w == b"\r\n") {
let field = remaining.get(..end).unwrap_or(&[]);
if field.is_empty() {
break;
}
if let Some(colon) = field.iter().position(|&b| b == b':')
&& field.get(..colon).is_some_and(|name| name.eq_ignore_ascii_case(b"host"))
{
host = field.get(colon + 1..).map(|value| String::from_utf8_lossy(value).trim().to_string());
break;
}
remaining = remaining.get(end + 2..).unwrap_or(&[]);
}
d.protocols.push("http");
d.http = Some(Http { kind: "request", method: Some(m.to_string()), target: Some(strip_userinfo(t)), status: None, version: v.to_string(), host });
return;
@@ -1270,8 +1378,9 @@ pub fn summarize(data: &[u8], cancelled: &dyn Fn() -> bool) -> Result<Summary, F
row.packets_b_to_a += 1;
row.bytes_b_to_a += u64::from(f.original_len);
}
if f.ts_ns.is_some() {
row.last_ts_ns = f.ts_ns;
if let Some(t) = f.ts_ns {
row.first_ts_ns = Some(row.first_ts_ns.map_or(t, |first| first.min(t)));
row.last_ts_ns = Some(row.last_ts_ns.map_or(t, |last| last.max(t)));
}
for app in d.protocols.iter().skip_while(|p| !matches!(**p, "tcp" | "udp")).skip(1) {
row.applications.insert(app);
@@ -1352,6 +1461,55 @@ mod tests {
use super::*;
use craft_anything_testkit::pcap::{dns_query, eth, ipv4_pkt, pcap, pcapng, sample_frames, udp};
#[test]
fn rejected_simple_packets_count_toward_the_scan_limit() {
let mut data = pcapng(&[]);
let rejected = craft_anything_testkit::pcap::block(3, &1u32.to_le_bytes());
for _ in 0..3 {
data.extend(&rejected);
}
let mut cap = Capture::new(&data).unwrap();
// Reach the boundary without allocating millions of preceding valid frames.
cap.count = MAX_PACKETS - 2;
assert!(cap.next().is_none());
assert!(cap.truncated);
assert_eq!(cap.pos, data.len() - rejected.len());
assert_eq!(cap.warnings.len(), 2);
assert!(cap.warnings.iter().any(|w| w.contains("2 simple packet blocks")));
assert!(cap.next().is_none());
assert_eq!(cap.warnings.len(), 2);
}
#[test]
fn rejected_simple_packets_at_eof_do_not_report_a_truncated_scan() {
let mut data = pcapng(&[]);
let rejected = craft_anything_testkit::pcap::block(3, &1u32.to_le_bytes());
for _ in 0..2 {
data.extend(&rejected);
}
let mut cap = Capture::new(&data).unwrap();
cap.count = MAX_PACKETS - 2;
assert!(cap.next().is_none());
assert!(!cap.truncated);
assert_eq!(cap.warnings.len(), 1);
assert!(cap.warnings[0].contains("2 simple packet blocks"));
}
#[test]
fn valid_and_rejected_simple_packets_share_the_scan_limit() {
let mut data = pcapng(&[]);
data.extend(craft_anything_testkit::pcap::block(3, &1u32.to_le_bytes()));
let valid = craft_anything_testkit::pcap::block(3, &0u32.to_le_bytes());
data.extend(&valid);
data.extend(&valid);
let mut cap = Capture::new(&data).unwrap();
cap.count = MAX_PACKETS - 2;
assert_eq!(cap.next().unwrap().number, MAX_PACKETS - 1);
assert!(cap.next().is_none());
assert!(cap.truncated);
assert_eq!(cap.pos, data.len() - valid.len());
}
#[test]
fn tcp_cut_inside_header_keeps_ports() {
// Ports sit in the first 4 bytes; a cut later in the header must not drop them (as UDP).
+55
View File
@@ -0,0 +1,55 @@
use craft_anything_formats::pcap::{decode, summarize};
use craft_anything_testkit::pcap::{dns_query, eth, ipv4_pkt, pcap, udp};
fn packet(message: &[u8]) -> Vec<u8> {
eth(0x0800, &ipv4_pkt(17, [192, 0, 2, 1], [192, 0, 2, 2], &udp(51000, 53, message)))
}
/// Neither a missing class nor a one-byte class can complete a DNS question.
#[test]
fn a_question_missing_any_class_byte_is_incomplete() {
let complete = dns_query();
for missing in [1, 2] {
let message = &complete[..complete.len() - missing];
let dns = decode(1, &packet(message)).dns.unwrap();
assert!(dns.incomplete, "missing {missing} class bytes");
assert!(dns.questions.is_empty(), "a question needs both type and class");
}
}
#[test]
fn complete_questions_survive_before_a_truncated_question() {
let mut message = dns_query();
message[4..6].copy_from_slice(&2u16.to_be_bytes());
message.extend([0xc0, 12, 0, 28, 0]); // compressed name, AAAA, one class byte
let dns = decode(1, &packet(&message)).dns.unwrap();
assert!(dns.incomplete);
assert_eq!(dns.questions.len(), 1);
assert_eq!(dns.questions[0].name, "example.com");
assert_eq!(dns.questions[0].qtype, "A");
}
#[test]
fn incomplete_questions_do_not_enter_the_query_inventory() {
let mut message = dns_query();
message.pop();
let summary = summarize(&pcap(&[packet(&message)]), &|| false).unwrap();
assert_eq!(summary.packets, 1);
assert!(summary.dns_queries.is_empty());
}
/// Class validation requires both bytes without restricting valid class values.
#[test]
fn complete_class_fields_are_accepted() {
for class in [1u16, 3, 255] {
let mut message = dns_query();
message.truncate(message.len() - 2);
message.extend(class.to_be_bytes());
let dns = decode(1, &packet(&message)).dns.unwrap();
assert!(!dns.incomplete);
assert_eq!(dns.questions.len(), 1);
assert_eq!(dns.questions[0].name, "example.com");
assert_eq!(dns.questions[0].qtype, "A");
}
}
+184
View File
@@ -0,0 +1,184 @@
use craft_anything_formats::pcap::{decode, summarize};
use craft_anything_testkit::pcap::{dns_query, eth, ipv4_pkt, pcap, udp};
fn response(record_type: u16, rdata: &[u8], declared_length: usize) -> Vec<u8> {
let mut message = dns_query();
message[2..4].copy_from_slice(&0x8180u16.to_be_bytes());
message[6..8].copy_from_slice(&1u16.to_be_bytes());
message.extend([0xc0, 12]); // owner points to the question's name
message.extend(record_type.to_be_bytes());
message.extend(1u16.to_be_bytes());
message.extend(60u32.to_be_bytes());
message.extend((declared_length as u16).to_be_bytes());
message.extend(rdata);
message
}
fn packet(message: &[u8]) -> Vec<u8> {
eth(0x0800, &ipv4_pkt(17, [192, 0, 2, 2], [192, 0, 2, 1], &udp(53, 51000, message)))
}
/// Truncated literal names and compression pointers must stay inside RDLENGTH.
#[test]
fn answer_names_cannot_borrow_bytes_past_rdata() {
for record_type in [2, 5, 12, 15] {
for name in [b"\x04fake\x07example\x00".as_slice(), &[0xc0, 12]] {
let mut rdata = if record_type == 15 { vec![0, 10] } else { Vec::new() };
let prefix = rdata.len();
rdata.extend(name);
for declared in [prefix, prefix + name.len() - 1] {
let dns = decode(1, &packet(&response(record_type, &rdata, declared))).dns.unwrap();
assert!(dns.incomplete, "type {record_type}, declared length {declared}");
assert!(dns.answers.is_empty(), "a name must be wholly encoded in its record");
}
}
}
}
/// An incomplete pointer is malformed, rather than a successful empty answer.
#[test]
fn malformed_name_rdata_is_not_reported_as_an_empty_answer() {
for record_type in [2, 5, 12, 15] {
let rdata = if record_type == 15 { vec![0, 10, 0xc0] } else { vec![0xc0] };
let dns = decode(1, &packet(&response(record_type, &rdata, rdata.len()))).dns.unwrap();
assert!(dns.incomplete);
assert!(dns.answers.is_empty());
}
}
/// An MX name cannot borrow either of its required preference bytes from trailing data.
#[test]
fn an_mx_exchange_cannot_skip_a_missing_preference() {
for declared in [0, 1] {
let dns = decode(1, &packet(&response(15, &[0, 10, 0xc0, 12], declared))).dns.unwrap();
assert!(dns.incomplete);
assert!(dns.answers.is_empty());
}
}
/// A terminator before the declared boundary must not hide unused RDATA bytes.
#[test]
fn a_name_must_account_for_all_of_its_rdata() {
for record_type in [2, 5, 12, 15] {
let rdata = if record_type == 15 { vec![0, 10, 0, 0xaa] } else { vec![0, 0xaa] };
let dns = decode(1, &packet(&response(record_type, &rdata, rdata.len()))).dns.unwrap();
assert!(dns.incomplete);
assert!(dns.answers.is_empty());
}
}
/// Literal, root, backward-pointer and label-plus-pointer names remain valid controls.
#[test]
fn complete_and_compressed_names_remain_supported() {
for record_type in [2, 5, 12, 15] {
for (name, expected) in [
(b"\x04mail\x07example\x00".as_slice(), "mail.example"),
(&[0xc0, 12], "example.com"),
(b"\x03www\xc0\x0c".as_slice(), "www.example.com"),
(&[0], "."),
] {
let mut rdata = if record_type == 15 { vec![0, 10] } else { Vec::new() };
rdata.extend(name);
let dns = decode(1, &packet(&response(record_type, &rdata, rdata.len()))).dns.unwrap();
assert!(!dns.incomplete, "type {record_type}, name {expected}");
assert_eq!(dns.answers.len(), 1);
assert_eq!(dns.answers[0].value, expected);
}
}
}
#[test]
fn names_outside_rdata_do_not_enter_the_answer_inventory() {
let message = response(5, b"\x04fake\x07example\x00", 0);
let summary = summarize(&pcap(&[packet(&message)]), &|| false).unwrap();
assert_eq!(summary.packets, 1);
assert!(summary.dns_answers.is_empty());
}
#[test]
fn earlier_answers_survive_before_a_malformed_name() {
let mut message = response(1, &[192, 0, 2, 3], 4);
message[6..8].copy_from_slice(&2u16.to_be_bytes());
let malformed = response(5, b"\x04fake\x07example\x00", 0);
message.extend(&malformed[dns_query().len()..]);
let dns = decode(1, &packet(&message)).dns.unwrap();
assert!(dns.incomplete);
assert_eq!(dns.answers.len(), 1);
assert_eq!(dns.answers[0].rtype, "A");
assert_eq!(dns.answers[0].value, "192.0.2.3");
}
fn prerequisite_message(flags: u16, record_type: u16, class: u16, ttl: u32, rdata: &[u8]) -> Vec<u8> {
let mut message = vec![0, 1];
message.extend(flags.to_be_bytes());
message.extend([0, 1, 0, 2, 0, 0, 0, 0]);
message.extend(b"\x07example\x04test\0");
message.extend([0, 6, 0, 1]); // One Zone record, SOA/IN.
message.extend(b"\x05first\xc0\x0c");
message.extend(record_type.to_be_bytes());
message.extend(class.to_be_bytes());
message.extend(ttl.to_be_bytes());
message.extend((rdata.len() as u16).to_be_bytes());
message.extend(rdata);
// A different owner lets this value-dependent prerequisite coexist with CLASS NONE above.
message.extend(b"\x05after\xc0\x0c");
message.extend([0, 1, 0, 1, 0, 0, 0, 0, 0, 4, 192, 0, 2, 4]);
message
}
#[test]
fn empty_update_name_prerequisites_preserve_the_following_record() {
for record_type in [2, 5, 12, 15] {
for class in [254, 255] {
let dns = decode(1, &packet(&prerequisite_message(0x2800, record_type, class, 0, &[]))).dns.unwrap();
assert!(!dns.incomplete, "type {record_type}, class {class}");
assert_eq!(dns.answers.len(), 2);
assert_eq!(dns.answers[0].value, "");
assert_eq!(dns.answers[1].name, "after.example.test");
assert_eq!(dns.answers[1].value, "192.0.2.4");
}
}
}
#[test]
fn empty_name_rdata_is_rejected_outside_legal_update_prerequisites() {
let cases = [(0x8180, 254, 0), (0x8180, 255, 0), (0x2000, 254, 0), (0x2000, 255, 0), (0x2800, 1, 0), (0x2800, 254, 1), (0x2800, 255, 1)];
for record_type in [2, 5, 12, 15] {
for (flags, class, ttl) in cases {
let dns = decode(1, &packet(&prerequisite_message(flags, record_type, class, ttl, &[]))).dns.unwrap();
assert!(dns.incomplete, "type {record_type}, flags {flags:#x}, class {class}, TTL {ttl}");
assert!(dns.answers.is_empty());
}
}
}
#[test]
fn update_name_rdata_still_requires_complete_exact_encoding() {
for record_type in [2, 5, 12, 15] {
for class in [1, 254, 255] {
for name in [&[0xc0][..], &[0, 0xaa]] {
let mut rdata = if record_type == 15 { vec![0, 10] } else { Vec::new() };
rdata.extend(name);
let dns = decode(1, &packet(&prerequisite_message(0x2800, record_type, class, 0, &rdata))).dns.unwrap();
assert!(dns.incomplete, "type {record_type}, class {class}, name {name:?}");
assert!(dns.answers.is_empty());
}
}
}
}
#[test]
fn value_dependent_update_name_prerequisites_keep_their_values() {
for record_type in [2, 5, 12, 15] {
for (name, expected) in [(&[0][..], "."), (&[0xc0, 12], "example.test")] {
let mut rdata = if record_type == 15 { vec![0, 0] } else { Vec::new() };
rdata.extend(name);
let dns = decode(1, &packet(&prerequisite_message(0x2800, record_type, 1, 0, &rdata))).dns.unwrap();
assert!(!dns.incomplete, "type {record_type}, name {expected}");
assert_eq!(dns.answers.len(), 2);
assert_eq!(dns.answers[0].value, expected);
assert_eq!(dns.answers[1].value, "192.0.2.4");
}
}
}
+151
View File
@@ -0,0 +1,151 @@
use craft_anything_formats::pcap::{Dns, decode};
use craft_anything_testkit::pcap::{ipv4_pkt, udp};
fn query(last: usize, compressed: bool) -> Dns {
let mut msg = vec![0, 1, 1, 0, 0, if compressed { 2 } else { 1 }, 0, 0, 0, 0, 0, 0];
for len in [63, 63, 63, last] {
msg.push(len as u8);
msg.extend(vec![b'a'; len]);
}
msg.extend([0, 0, 1, 0, 1]);
if compressed {
msg.extend([0xc0, 12, 0, 1, 0, 1]);
}
decode(101, &ipv4_pkt(17, [1; 4], [2; 4], &udp(100, 53, &msg))).dns.unwrap()
}
#[test]
fn label_lengths_and_the_root_octet_count_towards_the_dns_limit() {
for last in [62, 63] {
let dns = query(last, false);
assert!(dns.incomplete);
assert!(dns.questions.is_empty());
}
}
#[test]
fn a_255_octet_name_is_valid_in_plain_and_compressed_form() {
for compressed in [false, true] {
let dns = query(61, compressed);
assert!(!dns.incomplete);
assert_eq!(dns.questions.len(), if compressed { 2 } else { 1 });
assert_eq!(dns.questions[0].name.len(), 253);
}
}
fn prefixed_pointer(last: usize, answer_type: Option<u16>) -> Dns {
let mut msg = vec![0, 1, 0x81, 0x80, 0, if answer_type.is_some() { 1 } else { 2 }, 0, u8::from(answer_type.is_some()), 0, 0, 0, 0];
for len in [63, 63, 63, last] {
msg.push(len as u8);
msg.extend(vec![b'a'; len]);
}
msg.extend([0, 0, 1, 0, 1]);
if let Some(rtype) = answer_type {
msg.extend([0xc0, 12]);
msg.extend(rtype.to_be_bytes());
msg.extend([0, 1, 0, 0, 0, 0, 0, if rtype == 15 { 6 } else { 4 }]);
if rtype == 15 {
msg.extend([0, 10]);
}
}
msg.extend([1, b'x', 0xc0, 12]);
if answer_type.is_none() {
msg.extend([0, 1, 0, 1]);
}
decode(101, &ipv4_pkt(17, [1; 4], [2; 4], &udp(100, 53, &msg))).dns.unwrap()
}
#[test]
fn a_literal_prefix_and_pointer_cannot_exceed_the_question_name_limit() {
let dns = prefixed_pointer(61, None);
assert!(dns.incomplete);
assert_eq!(dns.questions.len(), 1);
}
#[test]
fn invalid_name_rdata_is_incomplete_instead_of_an_empty_answer() {
for rtype in [2, 5, 12, 15] {
let dns = prefixed_pointer(61, Some(rtype));
assert!(dns.incomplete, "record type {rtype}");
assert_eq!(dns.questions.len(), 1);
assert!(dns.answers.is_empty(), "record type {rtype}");
}
}
#[test]
fn a_prefixed_pointer_at_255_octets_remains_valid() {
let dns = prefixed_pointer(59, None);
assert!(!dns.incomplete);
assert_eq!(dns.questions.len(), 2);
for rtype in [2, 5, 12, 15] {
let dns = prefixed_pointer(59, Some(rtype));
assert!(!dns.incomplete, "record type {rtype}");
assert_eq!(dns.answers.len(), 1);
assert_eq!(dns.answers[0].value.len(), 253);
}
}
fn name_rdata_then_a(flags: u16, class: u16, ttl: u32, rtype: u16, rdata: &[u8]) -> Dns {
let mut msg = vec![0, 1];
msg.extend(flags.to_be_bytes());
msg.extend([0, 1, 0, 2, 0, 0, 0, 0]);
msg.extend(b"\x07example\x04test\0");
msg.extend([0, 6, 0, 1]); // Zone: SOA/IN for UPDATE requests.
msg.extend([3, b'o', b'n', b'e', 0xc0, 12]);
msg.extend(rtype.to_be_bytes());
msg.extend(class.to_be_bytes());
msg.extend(ttl.to_be_bytes());
msg.extend((rdata.len() as u16).to_be_bytes());
msg.extend(rdata);
// A different owner keeps the two UPDATE prerequisites independent.
msg.extend([4, b'n', b'e', b'x', b't', 0xc0, 12, 0, 1, 0, 1, 0, 0, 0, 0, 0, 4, 203, 0, 113, 1]);
decode(101, &ipv4_pkt(17, [1; 4], [2; 4], &udp(100, 53, &msg))).dns.unwrap()
}
#[test]
fn empty_update_name_prerequisites_preserve_the_following_record() {
for rtype in [2, 5, 12, 15] {
for class in [254, 255] {
let dns = name_rdata_then_a(0x2800, class, 0, rtype, &[]);
assert!(!dns.incomplete, "type {rtype}, class {class}");
assert_eq!(dns.answers.len(), 2);
assert_eq!(dns.answers[0].value, "");
assert_eq!(dns.answers[1].value, "203.0.113.1");
}
}
}
#[test]
fn empty_name_rdata_is_rejected_outside_legal_update_prerequisites() {
let cases = [(0x8180, 254, 0), (0x8180, 255, 0), (0x2000, 254, 0), (0x2000, 255, 0), (0x2800, 1, 0), (0x2800, 254, 1), (0x2800, 255, 1)];
for rtype in [2, 5, 12, 15] {
for (flags, class, ttl) in cases {
let dns = name_rdata_then_a(flags, class, ttl, rtype, &[]);
assert!(dns.incomplete, "type {rtype}, flags {flags:#x}, class {class}, TTL {ttl}");
assert!(dns.answers.is_empty());
}
}
}
#[test]
fn a_cut_rdata_pointer_cannot_borrow_the_following_owner() {
for rtype in [2, 5, 12, 15] {
let mut rdata = if rtype == 15 { vec![0, 10] } else { Vec::new() };
rdata.push(0xc0); // The next owner's length would complete a pointer to the header's zero byte.
let dns = name_rdata_then_a(0x8180, 1, 0, rtype, &rdata);
assert!(dns.incomplete, "type {rtype}");
assert!(dns.answers.is_empty());
}
}
#[test]
fn root_name_rdata_remains_valid() {
for rtype in [2, 5, 12, 15] {
let rdata = if rtype == 15 { vec![0, 0, 0] } else { vec![0] };
let dns = name_rdata_then_a(0x8180, 1, 0, rtype, &rdata);
assert!(!dns.incomplete, "type {rtype}");
assert_eq!(dns.answers.len(), 2);
assert_eq!(dns.answers[0].value, ".");
assert_eq!(dns.answers[1].value, "203.0.113.1");
}
}
+196
View File
@@ -0,0 +1,196 @@
use craft_anything_formats::pcap::{Dns, decode};
use craft_anything_testkit::pcap::{ipv4_pkt, udp};
fn response(data: &[u8]) -> Dns {
let mut msg = vec![0, 1, 0x81, 0x80, 0, 0, 0, 1, 0, 0, 0, 0];
msg.extend([0, 0, 16, 0, 1, 0, 0, 0, 60]);
msg.extend((data.len() as u16).to_be_bytes());
msg.extend(data);
decode(101, &ipv4_pkt(17, [1; 4], [2; 4], &udp(53, 100, &msg))).dns.unwrap()
}
fn prerequisites(flags: u16, class: u16, ttl: u32, data: &[u8]) -> Dns {
let mut msg = vec![0, 1];
msg.extend(flags.to_be_bytes());
msg.extend([0, 1, 0, 2, 0, 0, 0, 0]);
// UPDATE's zone section has the question layout: example.test, SOA, IN.
msg.extend(b"\x07example\x04test\x00\x00\x06\x00\x01");
msg.extend([0xc0, 12, 0, 16]);
msg.extend(class.to_be_bytes());
msg.extend(ttl.to_be_bytes());
msg.extend((data.len() as u16).to_be_bytes());
msg.extend(data);
// Different owners let NONE and value-dependent prerequisites hold together.
// The following TXT record must also survive.
msg.extend(b"\x05after");
msg.extend([0xc0, 12, 0, 16, 0, 1, 0, 0, 0, 0, 0, 3, 2, b'o', b'k']);
decode(101, &ipv4_pkt(17, [1; 4], [2; 4], &udp(100, 53, &msg))).dns.unwrap()
}
fn named_txt(owner: &[&[u8]], data: &[u8], port: u16, flags: u16, class: u16, ttl: u32, compressed: bool) -> Dns {
let mut name = Vec::new();
for label in owner {
name.push(u8::try_from(label.len()).unwrap());
name.extend(*label);
}
name.push(0);
let mut msg = vec![0, 1];
msg.extend(flags.to_be_bytes());
msg.extend([0, 1, 0, 2, 0, 0, 0, 0]);
msg.extend(&name);
msg.extend([0, 16, 0, 1]);
if compressed {
msg.extend([0xc0, 12]);
} else {
msg.extend(&name);
}
msg.extend([0, 16]);
msg.extend(class.to_be_bytes());
msg.extend(ttl.to_be_bytes());
msg.extend(u16::try_from(data.len()).unwrap().to_be_bytes());
msg.extend(data);
// The next answer must survive an empty DNS-SD TXT record.
msg.extend([0xc0, 12, 0, 1, 0, 1, 0, 0, 0, 60, 0, 4, 127, 0, 0, 1]);
decode(101, &ipv4_pkt(17, [1; 4], [2; 4], &udp(port, 100, &msg))).dns.unwrap()
}
fn assert_empty_txt_and_following_answer(dns: Dns) {
assert!(!dns.incomplete);
assert_eq!(dns.answers.len(), 2);
assert_eq!(dns.answers[0].rtype, "TXT");
assert_eq!(dns.answers[0].value, "");
assert_eq!(dns.answers[1].value, "127.0.0.1");
}
#[test]
fn empty_dns_sd_txt_preserves_following_answers() {
let multicast: &[&[u8]] = &[b"Printer", b"_ipp", b"_tcp", b"local"];
let unicast: &[&[u8]] = &[b"Printer", b"_ipp", b"_tcp", b"example", b"test"];
for (port, owner) in [(5353, multicast), (53, unicast)] {
assert_empty_txt_and_following_answer(named_txt(owner, &[], port, 0x8400, 1, 60, false));
}
}
#[test]
fn empty_dns_sd_txt_is_valid_in_mdns_known_answers_and_cache_flush_records() {
let owner: &[&[u8]] = &[b"Printer", b"_ipp", b"_tcp", b"local"];
// Queries may contain known answers; the cache-flush bit belongs to CLASS.
for (flags, class) in [(0, 1), (0x8400, 0x8001)] {
assert_empty_txt_and_following_answer(named_txt(owner, &[], 5353, flags, class, 60, false));
}
}
#[test]
fn dns_sd_owner_preserves_wire_labels_case_and_compression() {
let owner: &[&[u8]] = &[b"Printer.with dots", b"_Ab-12", b"_UdP", b"example", b"test"];
for compressed in [false, true] {
assert_empty_txt_and_following_answer(named_txt(owner, &[], 53, 0x8180, 1, 60, compressed));
}
}
#[test]
fn other_empty_txt_owners_are_not_dns_sd_instances() {
let owners: &[&[&[u8]]] = &[
&[b"Printer", b"local"],
&[b"Printer._ipp._tcp", b"local"],
&[b"Printer", b"_ipp._tcp", b"_tcp", b"local"],
&[b"_ipp", b"_tcp", b"local"],
&[b"Printer", b"_ipp", b"_tcp"],
&[b"Printer", b"_ipp", b"_other", b"local"],
&[b"Printer", b"_123", b"_tcp", b"local"],
&[b"Printer", b"_bad--name", b"_tcp", b"local"],
];
for owner in owners {
let dns = named_txt(owner, &[], 5353, 0x8400, 1, 60, false);
assert!(dns.incomplete, "owner {owner:?}");
assert!(dns.answers.is_empty());
}
}
#[test]
fn dns_sd_txt_still_rejects_truncated_nonempty_strings() {
let owner: &[&[u8]] = &[b"Printer", b"_ipp", b"_tcp", b"local"];
for data in [&b"\x02x"[..], &b"\x00\x04x"[..]] {
let dns = named_txt(owner, data, 5353, 0x8400, 0x8001, 60, true);
assert!(dns.incomplete);
assert!(dns.answers.is_empty());
}
}
#[test]
fn dns_sd_owner_does_not_relax_update_prerequisite_classes() {
let owner: &[&[u8]] = &[b"Printer", b"_ipp", b"_tcp", b"example", b"test"];
let dns = named_txt(owner, &[], 53, 5 << 11, 1, 0, true);
assert!(dns.incomplete);
assert!(dns.answers.is_empty());
for class in [254, 255] {
assert_empty_txt_and_following_answer(named_txt(owner, &[], 53, 5 << 11, class, 0, true));
}
}
#[test]
fn empty_update_prerequisites_preserve_following_records() {
for class in [254, 255] {
let dns = prerequisites(5 << 11, class, 0, &[]);
assert!(!dns.incomplete, "class {class}");
assert_eq!(dns.answers.len(), 2);
assert_eq!(dns.answers[0].name, "example.test");
assert_eq!(dns.answers[0].value, "");
assert_eq!(dns.answers[1].name, "after.example.test");
assert_eq!(dns.answers[1].value, "ok");
}
}
#[test]
fn empty_txt_rdata_requires_update_and_a_prerequisite_class() {
assert!(response(&[]).incomplete);
for (flags, class, ttl) in [(0x8180, 254, 0), (0x8180, 255, 0), (5 << 11, 1, 0), (5 << 11, 254, 60), (5 << 11, 255, 60)] {
let dns = prerequisites(flags, class, ttl, &[]);
assert!(dns.incomplete, "flags {flags:#x}, class {class}, ttl {ttl}");
assert!(dns.answers.is_empty());
}
for opcode in [1, 2, 3, 4, 6] {
for class in [254, 255] {
let dns = prerequisites(opcode << 11, class, 0, &[]);
assert!(dns.incomplete, "opcode {opcode}, class {class}");
assert!(dns.answers.is_empty());
}
}
}
#[test]
fn update_prerequisite_classes_do_not_allow_truncated_strings() {
for class in [254, 255] {
let dns = prerequisites(5 << 11, class, 0, b"\x02x");
assert!(dns.incomplete);
assert!(dns.answers.is_empty());
}
}
#[test]
fn truncated_txt_strings_are_not_complete_answers() {
for data in [&b"\x05abc"[..], &b"\x02ok\x04x"[..], &b"\x01"[..]] {
let dns = response(data);
assert!(dns.incomplete);
assert!(dns.answers.is_empty());
}
}
#[test]
fn empty_and_multiple_complete_strings_remain_valid() {
for (data, expected) in [(&b"\x00"[..], ""), (&b"\x00\x02ok\x01!"[..], "ok!")] {
let dns = response(data);
assert!(!dns.incomplete);
assert_eq!(dns.answers[0].value, expected);
}
}
#[test]
fn value_dependent_update_accepts_an_empty_character_string() {
let dns = prerequisites(5 << 11, 1, 0, b"\x00");
assert!(!dns.incomplete);
assert_eq!(dns.answers.len(), 2);
assert_eq!(dns.answers[0].value, "");
assert_eq!(dns.answers[1].name, "after.example.test");
assert_eq!(dns.answers[1].value, "ok");
}
+36
View File
@@ -0,0 +1,36 @@
use craft_anything_formats::pcap::summarize;
use craft_anything_testkit::pcap::{block, eth, ipv4_pkt, pcap, pcapng, udp};
fn frame() -> Vec<u8> {
eth(0x0800, &ipv4_pkt(17, [1; 4], [2; 4], &udp(100, 200, b"body")))
}
#[test]
fn out_of_order_flow_packets_keep_the_earliest_and_latest_timestamps() {
let f = frame();
let mut capture = pcap(&[f.clone(), f.clone(), f.clone()]);
for (i, seconds) in [30u32, 10, 20].into_iter().enumerate() {
let at = 24 + i * (16 + f.len());
capture[at..at + 4].copy_from_slice(&seconds.to_le_bytes());
}
let summary = summarize(&capture, &|| false).unwrap();
let flow = &summary.flows[0];
assert_eq!(flow.first_ts_ns, summary.first_ts_ns);
assert_eq!(flow.last_ts_ns, summary.last_ts_ns);
assert_eq!(flow.first_frame, 1);
}
#[test]
fn a_timestamped_packet_fills_a_flow_started_by_a_simple_packet() {
let f = frame();
let headers = pcapng(&[]);
let mut simple = (f.len() as u32).to_le_bytes().to_vec();
simple.extend(&f);
let mut capture = headers.clone();
capture.extend(block(3, &simple));
capture.extend(&pcapng(&[f])[headers.len()..]);
let summary = summarize(&capture, &|| false).unwrap();
assert!(summary.first_ts_ns.is_some());
assert_eq!(summary.flows[0].first_ts_ns, summary.first_ts_ns);
assert_eq!(summary.flows[0].last_ts_ns, summary.last_ts_ns);
}
@@ -0,0 +1,24 @@
use craft_anything_formats::pcap::{Http, decode};
use craft_anything_testkit::pcap::{ipv4_pkt, tcp};
fn request(data: &[u8]) -> Http {
decode(101, &ipv4_pkt(6, [1; 4], [2; 4], &tcp(100, 80, 0x18, data))).http.unwrap()
}
#[test]
fn a_host_shaped_line_in_the_body_is_not_a_request_header() {
let http = request(b"POST / HTTP/1.1\r\nContent-Length: 22\r\n\r\nbody\r\nHost: forged.test\r\n");
assert!(http.host.is_none());
}
#[test]
fn invalid_utf8_before_host_does_not_shift_header_byte_offsets() {
let http = request(b"GET / HTTP/1.1\r\nX-Data: \xff\r\nHoSt:\tReal.test \t\r\n\r\n");
assert_eq!(http.host.as_deref(), Some("Real.test"));
}
#[test]
fn host_requires_a_complete_header_line_and_keeps_its_spelling() {
assert!(request(b"GET / HTTP/1.1\r\nHost: cut").host.is_none());
assert_eq!(request(b"GET / HTTP/1.1\r\nHost: Real.test\r\n\r\n").host.as_deref(), Some("Real.test"));
}
+57
View File
@@ -0,0 +1,57 @@
use craft_anything_formats::pcap::decode;
use craft_anything_testkit::pcap::{ipv4_pkt, udp};
#[test]
fn incomplete_ipv4_base_headers_explain_why_decoding_stopped() {
let packet = ipv4_pkt(17, [1; 4], [2; 4], &[]);
for captured in 10..20 {
let decoded = decode(101, &packet[..captured]);
assert!(decoded.ip.is_none(), "captured {captured} bytes");
assert!(decoded.transport.is_none(), "captured {captured} bytes");
assert_eq!(decoded.note.as_deref(), Some("IPv4 header cut short"), "captured {captured} bytes");
}
}
#[test]
fn an_ipv4_total_length_cannot_be_shorter_than_its_header() {
for total in [0u16, 19, 23] {
let mut packet = ipv4_pkt(17, [1, 2, 3, 4], [5, 6, 7, 8], &udp(100, 200, b"body"));
packet[0] = 0x46;
packet[2..4].copy_from_slice(&total.to_be_bytes());
let decoded = decode(101, &packet);
assert!(decoded.ip.is_none());
assert!(decoded.transport.is_none());
assert!(decoded.note.is_some());
}
}
#[test]
fn missing_ipv4_options_do_not_form_a_complete_ip_header() {
let mut packet = ipv4_pkt(17, [1; 4], [2; 4], &[]);
packet[0] = 0x46;
packet[2..4].copy_from_slice(&24u16.to_be_bytes());
let decoded = decode(101, &packet);
assert!(decoded.ip.is_none());
assert!(decoded.note.is_some());
}
#[test]
fn complete_options_and_truncated_transport_keep_their_valid_fields() {
let body = udp(100, 200, b"body");
let mut payload = vec![0; 4];
payload.extend(body);
let mut packet = ipv4_pkt(17, [1; 4], [2; 4], &payload);
packet[0] = 0x46;
assert_eq!(decode(101, &packet).transport.unwrap().payload_len, 4);
packet.truncate(34);
let decoded = decode(101, &packet);
assert!(decoded.ip.is_some());
let transport = decoded.transport.unwrap();
assert_eq!(transport.src_port, Some(100));
assert_eq!(transport.dst_port, Some(200));
assert_eq!(transport.payload_len, 2);
packet.truncate(28);
let decoded = decode(101, &packet);
assert!(decoded.ip.is_some());
assert_eq!(decoded.transport.unwrap().src_port, Some(100));
}
+40
View File
@@ -0,0 +1,40 @@
use craft_anything_formats::pcap::decode;
use craft_anything_testkit::pcap::{eth, udp};
fn packet(offset: u16, next: u8, payload: &[u8]) -> Vec<u8> {
let mut ip = vec![0u8; 40];
ip[0] = 0x60;
ip[4..6].copy_from_slice(&((8 + payload.len()) as u16).to_be_bytes());
ip[6] = 44;
ip.extend([next, 0]);
ip.extend(offset.to_be_bytes());
ip.extend([0; 4]);
ip.extend(payload);
eth(0x86dd, &ip)
}
#[test]
fn a_noninitial_fragment_cannot_reset_its_offset_from_payload_bytes() {
let mut payload = vec![17, 0, 0, 0, 0, 0, 0, 0];
payload.extend(udp(100, 200, b"body"));
let decoded = decode(1, &packet(8, 44, &payload));
assert!(decoded.ip.unwrap().fragment);
assert!(decoded.transport.is_none());
assert!(!decoded.protocols.contains(&"udp"));
}
#[test]
fn noninitial_fragment_bytes_cannot_change_the_recorded_protocol() {
let decoded = decode(1, &packet(8, 60, &[17, 0, 0, 0, 0, 0, 0, 0]));
assert_eq!(decoded.ip.unwrap().protocol, 60);
assert!(decoded.transport.is_none());
}
#[test]
fn initial_and_atomic_fragments_still_decode_transport_headers() {
for offset in [0, 1] {
let decoded = decode(1, &packet(offset, 17, &udp(100, 200, b"body")));
assert!(!decoded.ip.unwrap().fragment);
assert_eq!(decoded.transport.unwrap().payload_len, 4);
}
}
+53
View File
@@ -0,0 +1,53 @@
use craft_anything_formats::pcap::decode;
use craft_anything_testkit::pcap::{eth, ipv4_pkt};
fn raw_packets() -> (Vec<u8>, Vec<u8>) {
let ipv4 = ipv4_pkt(17, [1; 4], [2; 4], &[0; 20]);
let mut ipv6 = vec![0u8; 40];
ipv6[0] = 0x60;
ipv6[6] = 59;
(ipv4, ipv6)
}
#[test]
fn explicit_raw_link_types_reject_the_other_ip_version() {
let (ipv4, ipv6) = raw_packets();
for (link_type, packet) in [(228, &ipv6), (229, &ipv4)] {
let decoded = decode(link_type, packet);
assert!(decoded.ip.is_none(), "link type {link_type}");
assert!(decoded.transport.is_none(), "link type {link_type}");
assert!(decoded.note.is_some(), "link type {link_type}");
}
}
#[test]
fn matching_raw_link_types_and_generic_raw_packets_remain_readable() {
let (ipv4, ipv6) = raw_packets();
assert_eq!(decode(228, &ipv4).ip.unwrap().version, 4);
assert_eq!(decode(229, &ipv6).ip.unwrap().version, 6);
for link_type in [12, 14, 101] {
assert_eq!(decode(link_type, &ipv4).ip.unwrap().version, 4);
assert_eq!(decode(link_type, &ipv6).ip.unwrap().version, 6);
}
}
#[test]
fn an_ethernet_type_does_not_replace_the_ipv6_version_check() {
for version in [0, 4, 5, 7, 15] {
let mut packet = [0u8; 40];
packet[0] = version << 4;
packet[6] = 59;
let decoded = decode(1, &eth(0x86dd, &packet));
assert!(decoded.ip.is_none(), "version {version}");
assert!(decoded.transport.is_none());
assert!(decoded.note.is_some());
}
}
#[test]
fn ipv6_version_keeps_traffic_class_bits() {
let mut packet = [0u8; 40];
packet[0] = 0x6f;
packet[6] = 59;
assert_eq!(decode(1, &eth(0x86dd, &packet)).ip.unwrap().version, 6);
}
@@ -0,0 +1,62 @@
use craft_anything_formats::pcap::Capture;
use craft_anything_testkit::pcap::{block, pcapng};
fn capture(original: u32, snaplen: u32, payload: &[u8]) -> Vec<u8> {
let mut out = pcapng(&[]);
out[40..44].copy_from_slice(&snaplen.to_le_bytes());
let mut body = original.to_le_bytes().to_vec();
body.extend(payload);
out.extend(block(3, &body));
out
}
#[test]
fn a_simple_packet_cannot_silently_shorten_its_declared_capture() {
let data = capture(10, 0, &[1, 2, 3, 4]);
let mut cap = Capture::new(&data).unwrap();
assert!(cap.next().is_none());
assert!(!cap.warnings.is_empty());
}
#[test]
fn a_simple_packet_cannot_have_unexplained_extra_payload() {
let data = capture(1, 0, &[1; 8]);
let mut cap = Capture::new(&data).unwrap();
assert!(cap.next().is_none());
assert!(!cap.warnings.is_empty());
}
#[test]
fn snaplen_truncation_and_alignment_padding_are_preserved() {
for (original, snaplen) in [(3, 0), (10, 3)] {
let data = capture(original, snaplen, &[1, 2, 3]);
let mut cap = Capture::new(&data).unwrap();
let packet = cap.next().unwrap();
assert_eq!(packet.data, [1, 2, 3]);
assert_eq!(packet.original_len, original);
assert!(cap.next().is_none());
assert!(cap.warnings.is_empty());
}
}
#[test]
fn rejected_simple_packets_share_one_warning_and_preserve_later_frames() {
let mut data = pcapng(&[]);
let rejected = block(3, &1u32.to_le_bytes());
for _ in 0..128 {
data.extend(&rejected);
}
let mut valid = 3u32.to_le_bytes().to_vec();
valid.extend([1, 2, 3]);
data.extend(block(3, &valid));
let mut cap = Capture::new(&data).unwrap();
let frame = cap.next().unwrap();
assert_eq!(frame.number, 1);
assert_eq!(frame.data, [1, 2, 3]);
assert!(cap.next().is_none());
assert!(!cap.truncated);
assert_eq!(cap.warnings.len(), 1);
assert!(cap.warnings[0].contains("128 simple packet blocks"));
assert!(cap.next().is_none());
assert_eq!(cap.warnings.len(), 1);
}