diff --git a/ATTRIBUTION.md b/ATTRIBUTION.md index f772eede2..58d8077e7 100644 --- a/ATTRIBUTION.md +++ b/ATTRIBUTION.md @@ -138,6 +138,9 @@ Sanitization, animation fitting and numeric output policy remain caller-owned. `crates/jsonc` is extracted from Craft Anything `crates/formats/src/jsonc.rs` at `e5c9c94106747ed44b9a3fb0decce867c2285f93` (MIT OR Apache-2.0). The original implementation and hardening by BFlat, newline preservation by NetterSilver, and subsequent RRFZ/Afloat correctness fixes retain separate primary-author port commits with immutable source revisions. Shared API wiring and optional input-byte admission are subsequent changes. Compatibility parsing and all existing formatting/editing tests are retained; application file I/O and policy are not imported. +## Packet capture and protocol inspection + +`crates/pcap` extracts Craft Anything `crates/formats/src/pcap.rs`, its checked byte reader primitives and synthetic packet fixtures/regressions at `5979f9b13f16dcf1df3c7ae7f8e7735f452866f2` (MIT OR Apache-2.0). Brandon Thomas introduced the implementation, byte reader and fixtures in `f64ae3bf3c8863a982af1304e06de20653803968`. Subsequent fixes by phatloi0010, GGWA, BFlat, Afloat, NetterSilver, Max Mittelstädt and RRFZ retain separate primary-author source-history commits with immutable source revisions. Shared error/API wiring and chrono-based timestamp formatting with exhaustive day-boundary parity tests are subsequent Dylan M. Taylor changes. No packet reassembly, decryption, live capture or app analysis policy is imported. ## HTTP Archive reader `crates/har` preserves Craft Anything `crates/formats/src/har.rs` from `5979f9b13f16dcf1df3c7ae7f8e7735f452866f2` (MIT OR Apache-2.0). Brandon Thomas introduced the typed reader in `f64ae3bf3c8863a982af1304e06de20653803968`; BFlat added UTF-8 BOM compatibility in `cb0bb9d8fa4536ba44ef2c86f5ed759b879cc2d3`. Both source snapshots retain primary author attribution. Shared wiring, explicit byte admission and its tests are subsequent Dylan M. Taylor changes. Redaction and analysis remain app-owned. diff --git a/Cargo.lock b/Cargo.lock index f8aa4e9d5..6412bd28a 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2153,13 +2153,6 @@ dependencies = [ "flate2", ] -[[package]] -name = "craft-hdr" -version = "0.1.0" -dependencies = [ - "thiserror 2.0.21", -] - [[package]] name = "craft-har" version = "0.1.0" @@ -2168,6 +2161,13 @@ dependencies = [ "thiserror 2.0.21", ] +[[package]] +name = "craft-hdr" +version = "0.1.0" +dependencies = [ + "thiserror 2.0.21", +] + [[package]] name = "craft-heif" version = "0.1.0" @@ -2642,6 +2642,16 @@ dependencies = [ name = "craft-palette" version = "0.1.0" +[[package]] +name = "craft-pcap" +version = "0.1.0" +dependencies = [ + "chrono", + "serde", + "serde_json", + "thiserror 2.0.21", +] + [[package]] name = "craft-pcraft-bundle" version = "0.1.0" diff --git a/Cargo.toml b/Cargo.toml index a394f3ad0..6dad17db6 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -11,6 +11,7 @@ rust-version = "1.95" repository = "https://github.com/storytold/craft-libs" [workspace.dependencies] +craft-pcap = { path = "crates/pcap" } craft-har = { path = "crates/har" } craft-jsonc = { path = "crates/jsonc" } craft-palette = { path = "crates/palette" } diff --git a/crates/pcap/Cargo.toml b/crates/pcap/Cargo.toml new file mode 100644 index 000000000..ea644cdf3 --- /dev/null +++ b/crates/pcap/Cargo.toml @@ -0,0 +1,17 @@ +[package] +name = "craft-pcap" +description = "Read-only PCAP/PCAPNG and per-frame protocol inspection" +version.workspace = true +edition.workspace = true +license.workspace = true +rust-version.workspace = true +repository.workspace = true +[lints] +workspace = true +[dependencies] +serde = { workspace = true } +thiserror = { workspace = true } +chrono = { workspace = true } + +[dev-dependencies] +serde_json = { workspace = true } diff --git a/crates/pcap/src/bytes.rs b/crates/pcap/src/bytes.rs new file mode 100644 index 000000000..238b5b6b8 --- /dev/null +++ b/crates/pcap/src/bytes.rs @@ -0,0 +1,49 @@ +//! Checked little/big-endian reads over untrusted bytes. Every read returns `None` when out of range. + +#[derive(Debug, Clone, Copy)] +pub struct Reader<'a> { + data: &'a [u8], +} + +impl<'a> Reader<'a> { + pub fn new(data: &'a [u8]) -> Self { + Reader { data } + } + + pub fn slice(&self, off: usize, len: usize) -> Option<&'a [u8]> { + let end = off.checked_add(len)?; + self.data.get(off..end) + } + + pub fn u8(&self, off: usize) -> Option { + self.data.get(off).copied() + } + + fn arr(&self, off: usize) -> Option<[u8; N]> { + self.slice(off, N)?.try_into().ok() + } + + pub fn u16_le(&self, off: usize) -> Option { + self.arr(off).map(u16::from_le_bytes) + } + + pub fn u32_le(&self, off: usize) -> Option { + self.arr(off).map(u32::from_le_bytes) + } + + pub fn u64_le(&self, off: usize) -> Option { + self.arr(off).map(u64::from_le_bytes) + } + + pub fn u16_be(&self, off: usize) -> Option { + self.arr(off).map(u16::from_be_bytes) + } + + pub fn u32_be(&self, off: usize) -> Option { + self.arr(off).map(u32::from_be_bytes) + } + + pub fn u64_be(&self, off: usize) -> Option { + self.arr(off).map(u64::from_be_bytes) + } +} diff --git a/crates/pcap/src/lib.rs b/crates/pcap/src/lib.rs new file mode 100644 index 000000000..bc05c1f77 --- /dev/null +++ b/crates/pcap/src/lib.rs @@ -0,0 +1,2183 @@ +#![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)] +#![forbid(unsafe_code)] + +//! Saved packet captures: classic pcap (microsecond and nanosecond, either byte order) and pcapng +//! (section, interface, enhanced/simple/obsolete packet blocks). Frames are decoded from Ethernet +//! (with VLAN tags), raw IP, Linux cooked (SLL/SLL2) and BSD loopback links into IPv4/IPv6, +//! TCP/UDP/ICMP, and the application facts most people ask about: DNS questions and answers, +//! HTTP/1.x request and status lines with the Host header, and the TLS ClientHello server name +//! (SNI) and ALPN. Each frame is decoded on its own: no TCP reassembly, no decryption. Pure, no I/O, +//! every length checked. Input bytes remain caller-owned and must be admitted to a caller budget. +//! Packet, flow and inventory caps below are retained; they are not a total allocator-byte guarantee. + +mod bytes; +#[cfg(test)] +#[path = "../tests/support/mod.rs"] +mod test_support; + +/// Why capture inspection could not start or finish. +#[derive(Debug, Clone, PartialEq, Eq, thiserror::Error)] +pub enum PcapError { + #[error("the file ends early ({0})")] + Truncated(String), + #[error("the file is malformed ({0})")] + Malformed(String), + #[error("not supported: {0}")] + Unsupported(String), +} + +use crate::PcapError as FormatError; +use crate::bytes::Reader; +use serde::Serialize; +use std::collections::{BTreeMap, BTreeSet, HashMap}; +use std::fmt::Write as _; +use std::net::{IpAddr, Ipv4Addr, Ipv6Addr}; + +/// Most accepted and rejected packet records 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; +/// Most distinct values kept per inventory (endpoints, DNS names, hosts…). +pub const MAX_INVENTORY: usize = 10_000; + +const CLASSIC_US: u32 = 0xa1b2_c3d4; +const CLASSIC_NS: u32 = 0xa1b2_3c4d; +const NG_SHB: u32 = 0x0a0d_0d0a; +const NG_BOM: u32 = 0x1a2b_3c4d; + +/// One capture interface (a pcap file has exactly one). +#[derive(Debug, Clone, PartialEq, Eq, Serialize)] +pub struct Interface { + pub link_type: u32, + pub link_name: &'static str, + pub snaplen: u32, + /// Timestamp units per second, as a power: (base 10 or 2, exponent). + #[serde(skip)] + tsresol: (u8, u8), + /// Signed offset in seconds added to timestamps on this interface (`if_tsoffset`). + #[serde(skip)] + tsoffset: i64, +} + +/// The plain name of a link-layer type. +pub fn link_name(link: u32) -> &'static str { + match link { + 0 => "BSD loopback", + 1 => "Ethernet", + 12 | 14 | 101 => "raw IP", + 108 => "OpenBSD loopback", + 113 => "Linux cooked (SLL)", + 228 => "raw IPv4", + 229 => "raw IPv6", + 276 => "Linux cooked v2 (SLL2)", + 105 => "IEEE 802.11", + 127 => "802.11 radiotap", + _ => "other", + } +} + +/// One captured frame. +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct Frame<'a> { + /// 1-based frame number, as capture tools show it. + pub number: u64, + /// Nanoseconds since the Unix epoch, when representable. + pub ts_ns: Option, + pub interface: usize, + pub link_type: u32, + pub original_len: u32, + pub data: &'a [u8], +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +enum Kind { + Classic { le: bool, nanos: bool }, + Ng { le: bool }, +} + +/// Walks the frames of a capture. Malformed data stops the walk with a warning, never a panic. +#[derive(Debug, Clone)] +pub struct Capture<'a> { + data: &'a [u8], + pos: usize, + kind: Kind, + /// Interfaces of the current pcapng section start here in `interfaces`. + section_base: usize, + pub format: &'static str, + pub version: String, + pub interfaces: Vec, + pub warnings: Vec, + /// The walk stopped at `MAX_PACKETS`. + pub truncated: bool, + count: u64, + rejected_simple_blocks: u64, + rejected_short_blocks: u64, + rejected_interfaces: u64, + invalid_fractions: u64, + warnings_reported: bool, +} + +fn rd_u16(r: &Reader<'_>, le: bool, off: usize) -> Option { + if le { r.u16_le(off) } else { r.u16_be(off) } +} + +fn rd_u32(r: &Reader<'_>, le: bool, off: usize) -> Option { + if le { r.u32_le(off) } else { r.u32_be(off) } +} + +fn rd_i64(r: &Reader<'_>, le: bool, off: usize) -> Option { + if le { r.u64_le(off) } else { r.u64_be(off) }.map(|v| v as i64) +} + +/// True when the bytes start like a pcap or pcapng file. +pub fn is_capture(data: &[u8]) -> bool { + let r = Reader::new(data); + matches!(r.u32_le(0), Some(CLASSIC_US | CLASSIC_NS | NG_SHB)) || matches!(r.u32_be(0), Some(CLASSIC_US | CLASSIC_NS)) +} + +impl<'a> Capture<'a> { + /// Read the file header. + pub fn new(data: &'a [u8]) -> Result { + let r = Reader::new(data); + let magic_le = r.u32_le(0).ok_or_else(|| FormatError::Truncated("no capture header".into()))?; + let magic_be = r.u32_be(0).unwrap_or(0); + let mut cap = Capture { + data, + pos: 0, + kind: Kind::Ng { le: true }, + section_base: 0, + format: "pcapng", + version: String::new(), + interfaces: Vec::new(), + warnings: Vec::new(), + truncated: false, + count: 0, + rejected_simple_blocks: 0, + rejected_short_blocks: 0, + rejected_interfaces: 0, + invalid_fractions: 0, + warnings_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()))?; + let minor = rd_u16(&r, le, 6).unwrap_or(0); + let snaplen = rd_u32(&r, le, 16).ok_or_else(|| FormatError::Truncated("pcap header".into()))?; + // Link type: bits 0–15; reserved: 16–25 and 27; FCS-present: 26; FCS length in 16-bit words: 28–31. + let link = rd_u32(&r, le, 20).ok_or_else(|| FormatError::Truncated("pcap header".into()))? & 0xffff; + let res = if nanos { (10, 9) } else { (10, 6) }; + let iface = Interface { link_type: link, link_name: link_name(link), snaplen, tsresol: res, tsoffset: 0 }; + Ok((Kind::Classic { le, nanos }, format!("{major}.{minor}"), iface)) + }; + match (magic_le, magic_be) { + (CLASSIC_US, _) | (_, CLASSIC_US) | (CLASSIC_NS, _) | (_, CLASSIC_NS) => { + let le = magic_le == CLASSIC_US || magic_le == CLASSIC_NS; + let nanos = (if le { magic_le } else { magic_be }) == CLASSIC_NS; + let (kind, version, iface) = classic(le, nanos)?; + cap.kind = kind; + cap.format = "pcap"; + cap.version = version; + cap.interfaces.push(iface); + cap.pos = 24; + } + (NG_SHB, _) => { + let le = match r.u32_le(8) { + Some(NG_BOM) => true, + _ if r.u32_be(8) == Some(NG_BOM) => false, + _ => return Err(FormatError::Malformed("pcapng section header without a byte-order mark".into())), + }; + cap.kind = Kind::Ng { le }; + cap.version = format!("{}.{}", rd_u16(&r, le, 12).unwrap_or(0), rd_u16(&r, le, 14).unwrap_or(0)); + } + _ => return Err(FormatError::Unsupported("not a pcap or pcapng capture".into())), + } + Ok(cap) + } + + fn stop(&mut self, why: impl Into) -> Option> { + self.warnings.push(why.into()); + self.pos = self.data.len(); + None + } + + fn packet_limit_reached(&mut self) -> bool { + if self.count + self.rejected_simple_blocks + self.rejected_short_blocks + self.rejected_interfaces < 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_packet_warnings(&mut self) { + if self.warnings_reported { + return; + } + self.warnings_reported = true; + if self.rejected_short_blocks > 0 { + self.warnings.push(format!("skipped {} packet block(s) with captured data past the end", self.rejected_short_blocks)); + } + if self.rejected_interfaces > 0 { + self.warnings.push(format!("skipped {} packet block(s) naming an undeclared interface", self.rejected_interfaces)); + } + if self.invalid_fractions > 0 { + self.warnings.push(format!("ignored {} timestamp(s) with a fraction outside its second", self.invalid_fractions)); + } + if self.rejected_simple_blocks > 0 { + 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")); + } + } + + fn ts(&self, iface: usize, units: u64) -> Option { + 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); + let ns = if base == 10 { + if exp <= 9 { + u128::from(units) * 10u128.pow(u32::from(9 - exp)) + } else { + 10u128.checked_pow(u32::from(exp - 9)).map_or(0, |scale| u128::from(units) / scale) + } + } else { + (u128::from(units) * 1_000_000_000) >> exp.min(127) + }; + let adjusted = i128::try_from(ns).ok()?.checked_add(i128::from(offset_s) * 1_000_000_000)?; + u64::try_from(adjusted).ok() + } + + fn frame(&mut self, iface: usize, ts_units: u64, data: &'a [u8], original_len: u32) -> Frame<'a> { + self.count += 1; + Frame { + number: self.count, + ts_ns: self.ts(iface, ts_units), + interface: iface, + link_type: self.interfaces.get(iface).map(|i| i.link_type).unwrap_or(u32::MAX), + original_len, + data, + } + } + + fn next_classic(&mut self, le: bool, nanos: bool) -> Option> { + let r = Reader::new(self.data); + let p = self.pos; + if p >= self.data.len() { + return None; + } + let (Some(sec), Some(frac), Some(incl), Some(orig)) = + (rd_u32(&r, le, p), rd_u32(&r, le, p + 4), rd_u32(&r, le, p + 8), rd_u32(&r, le, p + 12)) + else { + return self.stop(format!("record header at offset {p} is cut short")); + }; + let Some(body) = usize::try_from(incl).ok().and_then(|n| r.slice(p + 16, n)) else { + return self.stop(format!("record at offset {p} claims {incl} bytes past the end of the file")); + }; + self.pos = p + 16 + body.len(); + let per_second = if nanos { 1_000_000_000 } else { 1_000_000 }; + let units = u64::from(sec) * u64::from(per_second) + u64::from(frac); + let mut frame = self.frame(0, units, body, orig); + if frac >= per_second { + self.invalid_fractions += 1; + frame.ts_ns = None; + } + Some(frame) + } + + fn next_ng(&mut self, mut le: bool) -> Option> { + loop { + if self.packet_limit_reached() { + return None; + } + let r = Reader::new(self.data); + let p = self.pos; + if p >= self.data.len() { + return None; + } + let Some(btype) = rd_u32(&r, le, p) else { return self.stop(format!("block header at offset {p} is cut short")) }; + if btype == NG_SHB { + // A new section can switch byte order. + le = match r.u32_le(p + 8) { + Some(NG_BOM) => true, + _ if r.u32_be(p + 8) == Some(NG_BOM) => false, + _ => return self.stop(format!("section header at offset {p} has no byte-order mark")), + }; + } + 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")); + }; + 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; + match btype { + 1 => { + let link = u32::from(rd_u16(&r, le, body).unwrap_or(u16::MAX)); + let snaplen = rd_u32(&r, le, body + 4).unwrap_or(0); + let mut tsresol = (10u8, 6u8); + let mut tsoffset = 0i64; + let mut o = body + 8; + while o + 4 <= body_end { + let (Some(code), Some(len)) = (rd_u16(&r, le, o), rd_u16(&r, le, o + 2)) else { break }; + if code == 0 { + break; + } + if code == 9 + && len == 1 + && o + 5 <= body_end + && let Some(v) = r.u8(o + 4) + { + tsresol = if v & 0x80 == 0 { (10, v) } else { (2, v & 0x7f) }; + } else if code == 14 + && len == 8 + && o + 12 <= body_end + && let Some(v) = rd_i64(&r, le, o + 4) + { + tsoffset = v; + } + o += 4 + usize::from(len).div_ceil(4) * 4; + } + self.interfaces.push(Interface { link_type: link, link_name: link_name(link), snaplen, tsresol, tsoffset }); + } + 6 | 2 => { + let (iface, hi, lo, cap, orig) = if btype == 6 { + ( + rd_u32(&r, le, body).map(|v| v as usize), + rd_u32(&r, le, body + 4), + rd_u32(&r, le, body + 8), + rd_u32(&r, le, body + 12), + rd_u32(&r, le, body + 16), + ) + } else { + ( + rd_u16(&r, le, body).map(usize::from), + rd_u32(&r, le, body + 4), + rd_u32(&r, le, body + 8), + rd_u32(&r, le, body + 12), + rd_u32(&r, le, body + 16), + ) + }; + let (Some(iface), Some(hi), Some(lo), Some(cap), Some(orig)) = (iface, hi, lo, cap, orig) else { continue }; + let Some(data) = usize::try_from(cap).ok().filter(|&c| c <= body_end - (body + 20)).and_then(|c| r.slice(body + 20, c)) else { + self.rejected_short_blocks += 1; + continue; + }; + let Some(iface) = self.section_base.checked_add(iface).filter(|&id| id < self.interfaces.len()) else { + self.rejected_interfaces += 1; + continue; + }; + return Some(self.frame(iface, (u64::from(hi) << 32) | u64::from(lo), data, orig)); + } + 3 => { + let Some(orig) = rd_u32(&r, le, body) else { continue }; + 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; + 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() { + self.rejected_interfaces += 1; + continue; + } + // Simple packet blocks carry no timestamp. + self.count += 1; + return Some(Frame { + number: self.count, + ts_ns: None, + interface: iface, + link_type: self.interfaces.get(iface).map(|i| i.link_type).unwrap_or(u32::MAX), + original_len: orig, + data, + }); + } + _ => {} + } + } + } +} + +impl<'a> Iterator for Capture<'a> { + type Item = Frame<'a>; + + fn next(&mut self) -> Option> { + 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), + } + }; + if frame.is_none() { + self.report_packet_warnings(); + } + frame + } +} + +// --------------------------------------------------------------------------------------------- +// Decoding + +#[derive(Debug, Clone, PartialEq, Eq, Serialize)] +pub struct IpInfo { + pub version: u8, + pub src: IpAddr, + pub dst: IpAddr, + /// IP protocol number of the payload (6 TCP, 17 UDP, 1 ICMP, 58 ICMPv6…). + pub protocol: u8, + /// TTL or hop limit. + pub ttl: u8, + /// A non-first fragment: the transport header is in another frame. + pub fragment: bool, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize)] +pub struct Transport { + /// tcp, udp, icmp, icmpv6 or other + pub protocol: &'static str, + #[serde(skip_serializing_if = "Option::is_none")] + pub src_port: Option, + #[serde(skip_serializing_if = "Option::is_none")] + pub dst_port: Option, + #[serde(skip_serializing_if = "Option::is_none")] + pub tcp_flags: Option, + #[serde(skip_serializing_if = "Option::is_none")] + pub seq: Option, + #[serde(skip_serializing_if = "Option::is_none")] + pub ack: Option, + #[serde(skip_serializing_if = "Option::is_none")] + pub window: Option, + #[serde(skip_serializing_if = "Option::is_none")] + pub icmp_type: Option, + #[serde(skip_serializing_if = "Option::is_none")] + pub icmp_code: Option, + pub payload_len: usize, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize)] +pub struct DnsQuestion { + pub name: String, + pub qtype: String, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize)] +pub struct DnsAnswer { + pub name: String, + pub rtype: String, + pub ttl: u32, + pub value: String, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize)] +pub struct Dns { + pub id: u16, + pub response: bool, + pub rcode: u8, + pub questions: Vec, + pub answers: Vec, + /// The message was cut short or malformed part-way. + pub incomplete: bool, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize)] +pub struct Http { + /// request or response + pub kind: &'static str, + #[serde(skip_serializing_if = "Option::is_none")] + pub method: Option, + /// Request target with any user:password removed. + #[serde(skip_serializing_if = "Option::is_none")] + pub target: Option, + #[serde(skip_serializing_if = "Option::is_none")] + pub status: Option, + pub version: String, + #[serde(skip_serializing_if = "Option::is_none")] + pub host: Option, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize)] +pub struct TlsHello { + pub record_version: String, + #[serde(skip_serializing_if = "Option::is_none")] + pub sni: Option, + pub alpn: Vec, + pub supported_versions: Vec, + /// The ClientHello continues in a later segment; extensions may be missing. + pub partial: bool, +} + +/// What one frame says. +#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize)] +pub struct Decoded { + /// Protocol stack, outermost first: eth, vlan, sll, ipv4, ipv6, arp, tcp, udp, icmp, dns, http, tls… + pub protocols: Vec<&'static str>, + #[serde(skip_serializing_if = "Option::is_none")] + pub ip: Option, + #[serde(skip_serializing_if = "Option::is_none")] + pub transport: Option, + #[serde(skip_serializing_if = "Option::is_none")] + pub dns: Option, + #[serde(skip_serializing_if = "Option::is_none")] + pub http: Option, + #[serde(skip_serializing_if = "Option::is_none")] + pub tls: Option, + /// Where decoding stopped early, when it did. + #[serde(skip_serializing_if = "Option::is_none")] + pub note: Option, +} + +impl Decoded { + /// The protocol stack joined with `:`. + pub fn stack(&self) -> String { + self.protocols.join(":") + } + + /// The direction-independent conversation this frame belongs to, and whether it travels a→b. + pub fn flow_key(&self) -> Option<(FlowKey, bool)> { + let ip = self.ip.as_ref()?; + let t = self.transport.as_ref(); + let sp = t.and_then(|t| t.src_port).unwrap_or(0); + let dp = t.and_then(|t| t.dst_port).unwrap_or(0); + let (s, d) = ((ip.src, sp), (ip.dst, dp)); + let forward = s <= d; + let (a, b) = if forward { (s, d) } else { (d, s) }; + Some((FlowKey { protocol: ip.protocol, a, b }, forward)) + } +} + +/// A conversation: IP protocol and the two (address, port) ends in sorted order. +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)] +pub struct FlowKey { + pub protocol: u8, + pub a: (IpAddr, u16), + pub b: (IpAddr, u16), +} + +/// Decode one frame from its link layer up. +pub fn decode(link_type: u32, data: &[u8]) -> Decoded { + let mut d = Decoded::default(); + let r = Reader::new(data); + let (mut ethertype, mut off) = match link_type { + 1 => { + d.protocols.push("eth"); + (r.u16_be(12), 14usize) + } + 113 => { + d.protocols.push("sll"); + (r.u16_be(14), 16) + } + 276 => { + d.protocols.push("sll2"); + (r.u16_be(0), 20) + } + 0 | 108 => { + d.protocols.push("loopback"); + // The family is in the capturing host's byte order (NULL) or big-endian (LOOP). + let fam = if link_type == 108 { r.u32_be(0) } else { r.u32_le(0).filter(|&v| v < 256).or_else(|| r.u32_be(0)) }; + ( + fam.map(|f| { + if f == 2 { + 0x0800 + } else if matches!(f, 24 | 28 | 30) { + 0x86dd + } else { + 0 + } + }), + 4, + ) + } + 12 | 14 | 101 | 228 | 229 => { + d.protocols.push("raw"); + 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))); + return d; + } + }; + // Both Ethernet and Linux cooked headers carry an EtherType. Each VLAN + // tag supplies another EtherType after its tag-control field. + for _ in 0..2 { + if !matches!(ethertype, Some(0x8100 | 0x88a8)) { + break; + } + d.protocols.push("vlan"); + ethertype = r.u16_be(off + 2); + off += 4; + } + let payload = data.get(off..).unwrap_or(&[]); + match ethertype { + Some(0x0800) => ipv4(payload, &mut d), + Some(0x86dd) => ipv6(payload, &mut d), + Some(0x0806) => d.protocols.push("arp"), + Some(other) => d.note = Some(format!("ethertype {other:#06x} is not decoded")), + None => d.note = Some("frame too short for its link header".into()), + } + d +} + +fn ipv4(p: &[u8], d: &mut Decoded) { + let r = Reader::new(p); + let (Some(vihl), Some(total), Some(frag), Some(ttl), Some(proto)) = (r.u8(0), r.u16_be(2), r.u16_be(6), r.u8(8), r.u8(9)) else { + d.note = Some("IPv4 header cut short".into()); + return; + }; + let ihl = usize::from(vihl & 0x0f) * 4; + 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( + b.first().copied().unwrap_or(0), + b.get(1).copied().unwrap_or(0), + b.get(2).copied().unwrap_or(0), + b.get(3).copied().unwrap_or(0), + )) + }; + 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).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()); + return; + } + transport(proto, body, d); +} + +fn ipv6(p: &[u8], d: &mut Decoded) { + let r = Reader::new(p); + let (Some(plen), Some(mut next), Some(hops), Some(src), Some(dst)) = (r.u16_be(4), r.u8(6), r.u8(7), r.slice(8, 16), r.slice(24, 16)) else { + 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()); + let payload_reader = Reader::new(p.get(..end).unwrap_or(&[])); + let mut off = 40usize; + let mut fragment = false; + for _ in 0..8 { + match next { + 0 | 43 | 60 => { + let (Some(n), Some(l)) = (payload_reader.u8(off), payload_reader.u8(off + 1)) else { break }; + let len = (usize::from(l) + 1) * 8; + if off.checked_add(len).is_none_or(|next_off| next_off > end) { + break; + } + next = n; + off += len; + } + 44 => { + if off.checked_add(8).is_none_or(|next_off| next_off > end) { + break; + } + let (Some(n), Some(fo)) = (payload_reader.u8(off), payload_reader.u16_be(off + 2)) else { break }; + 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 }; + let len = (usize::from(l) + 2) * 4; + if off.checked_add(len).is_none_or(|next_off| next_off > end) { + break; + } + next = n; + off += len; + } + _ => break, + } + } + d.ip = Some(IpInfo { version: 6, src: ip6(src), dst: ip6(dst), protocol: next, ttl: hops, fragment }); + if fragment { + d.note = Some("IPv6 fragment (transport header is in the first fragment)".into()); + return; + } + // RFC 8200: No Next Header ends the chain even if the packet has trailing bytes. + if next != 59 { + transport(next, p.get(off..end).unwrap_or(&[]), d); + } +} + +fn tcp_flags(f: u8) -> String { + let names = [(0x02, "SYN"), (0x10, "ACK"), (0x01, "FIN"), (0x04, "RST"), (0x08, "PSH"), (0x20, "URG"), (0x40, "ECE"), (0x80, "CWR")]; + names.iter().filter(|(b, _)| f & b != 0).map(|(_, n)| *n).collect::>().join(",") +} + +fn transport(proto: u8, p: &[u8], d: &mut Decoded) { + let r = Reader::new(p); + let empty = Transport { + protocol: "other", + src_port: None, + dst_port: None, + tcp_flags: None, + seq: None, + ack: None, + window: None, + icmp_type: None, + icmp_code: None, + payload_len: 0, + }; + match proto { + 6 => { + let (Some(sp), Some(dp)) = (r.u16_be(0), r.u16_be(2)) else { + d.note = Some("TCP header cut short".into()); + return; + }; + 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)); + 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), + dst_port: Some(dp), + tcp_flags: flags.map(tcp_flags), + seq, + ack, + window: win, + payload_len: payload.len(), + ..empty + }); + 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", false); + } 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); + } + } + 17 => { + let (Some(sp), Some(dp)) = (r.u16_be(0), r.u16_be(2)) else { + d.note = Some("UDP header cut short".into()); + return; + }; + d.protocols.push("udp"); + 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", false); + } else if sp == 5353 || dp == 5353 { + dns(payload, d, "mdns", dp == 5353); + } + } + 1 | 58 => { + let name = if proto == 1 { "icmp" } else { "icmpv6" }; + d.protocols.push(name); + d.transport = Some(Transport { protocol: name, icmp_type: r.u8(0), icmp_code: r.u8(1), payload_len: p.len().saturating_sub(4), ..empty }); + } + _ => d.transport = Some(Transport { protocol: "other", payload_len: p.len(), ..empty }), + } +} + +pub fn qtype_name(t: u16) -> String { + match t { + 1 => "A".into(), + 2 => "NS".into(), + 5 => "CNAME".into(), + 6 => "SOA".into(), + 12 => "PTR".into(), + 15 => "MX".into(), + 16 => "TXT".into(), + 28 => "AAAA".into(), + 33 => "SRV".into(), + 35 => "NAPTR".into(), + 39 => "DNAME".into(), + 44 => "SSHFP".into(), + 52 => "TLSA".into(), + 256 => "URI".into(), + 64 => "SVCB".into(), + 65 => "HTTPS".into(), + 257 => "CAA".into(), + 255 => "ANY".into(), + n => format!("TYPE{n}"), + } +} + +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, allow_compression: bool) -> 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 = 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), labels >= 4 && service_instance)), + l if allow_compression && l & 0xc0 == 0xc0 => { + let ptr = usize::from(u16::from_be_bytes([l & 0x3f, *msg.get(off + 1)?])); + after.get_or_insert(off + 2); + if ptr >= off { + return None; // only backward pointers, so no loops + } + off = ptr; + } + 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('.'); + } + for &c in label { + match c { + b'.' | b'\\' => { + out.push('\\'); + out.push(char::from(c)); + } + c if c.is_ascii_graphic() => out.push(char::from(c)), + _ => { + let _ = write!(out, "\\{c:03}"); + } + } + } + off += 1 + usize::from(l); + } + _ => return None, + } + } + None +} + +/// Decode discovery and authentication records whose domain names prohibit compression. +fn discovery_answer(kind: u16, rd: &[u8]) -> Option { + let r = Reader::new(rd); + let text = |b: &[u8]| b.iter().flat_map(|v| std::ascii::escape_default(*v)).map(char::from).collect::(); + let hex = |b: &[u8]| b.iter().map(|v| format!("{v:02x}")).collect::(); + match kind { + 39 => dns_name(rd, 0, false).filter(|(_, after, _)| *after == rd.len()).map(|(name, _, _)| name), + 44 => { + let (&algorithm, next) = rd.split_first()?; + let (&hash, digest) = next.split_first()?; + if digest.is_empty() || hash == 1 && digest.len() != 20 || hash == 2 && digest.len() != 32 { + return None; + } + Some(format!("{algorithm} {hash} {}", hex(digest))) + } + 52 => { + let [usage, selector, matching, cert @ ..] = rd else { return None }; + if cert.is_empty() || *matching == 1 && cert.len() != 32 || *matching == 2 && cert.len() != 64 { + return None; + } + Some(format!("{usage} {selector} {matching} {}", hex(cert))) + } + 256 => { + let target = rd.get(4..).filter(|s| !s.is_empty())?; + Some(format!("{} {} \"{}\"", r.u16_be(0)?, r.u16_be(2)?, strip_userinfo(&text(target)))) + } + 35 => { + let mut pos = 4; + let mut value = format!("{} {}", r.u16_be(0)?, r.u16_be(2)?); + for _ in 0..3 { + let len = usize::from(r.u8(pos)?); + value.push_str(&format!(" \"{}\"", text(r.slice(pos + 1, len)?))); + pos += 1 + len; + } + let (replacement, _, _) = dns_name(rd, pos, false).filter(|(_, after, _)| *after == rd.len())?; + Some(format!("{value} {replacement}")) + } + 64 | 65 => { + let priority = r.u16_be(0)?; + let (target, mut pos, _) = dns_name(rd, 2, false)?; + let mut value = format!("{priority} {target}"); + let mut previous = None; + while pos < rd.len() { + let key = r.u16_be(pos)?; + let len = usize::from(r.u16_be(pos + 2)?); + if key == u16::MAX || previous.is_some_and(|old| old >= key) { + return None; + } + let param = r.slice(pos + 4, len)?; + // Keep unknown keys lossless; interpreting them as text can fabricate an endpoint. + let field = match key { + 1 if priority != 0 => { + let mut remaining = param; + let mut ids = Vec::new(); + while let Some((&n, rest)) = remaining.split_first() { + if n == 0 { + return None; + } + let (id, tail) = rest.split_at_checked(usize::from(n))?; + ids.push(text(id).replace(',', "\\,")); + remaining = tail; + } + if ids.is_empty() { + return None; + } + format!("alpn={}", ids.join(",")) + } + 3 if priority != 0 => format!("port={}", u16::from_be_bytes(param.try_into().ok()?)), + 4 if priority != 0 => { + let (addresses, tail) = param.as_chunks::<4>(); + if addresses.is_empty() || !tail.is_empty() { + return None; + } + let hints: Vec<_> = addresses.iter().map(|ip| Ipv4Addr::from(*ip).to_string()).collect(); + format!("ipv4hint={}", hints.join(",")) + } + 6 if priority != 0 => { + let (addresses, tail) = param.as_chunks::<16>(); + if addresses.is_empty() || !tail.is_empty() { + return None; + } + let hints: Vec<_> = addresses.iter().map(|ip| Ipv6Addr::from(*ip).to_string()).collect(); + format!("ipv6hint={}", hints.join(",")) + } + _ => format!("key{key}=0x{}", hex(param)), + }; + value.push(' '); + value.push_str(&field); + previous = Some(key); + pos += len + 4; + } + Some(value) + } + _ => 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, mdns_wire_format: bool) { + 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 }; + if msg.len() < 12 { + return; + } + let opcode = (flags >> 11) & 0xf; + // Sanity: opcode 0–6 and no absurd counts, so random payload on port 53 isn't misread. + 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, true) else { + out.incomplete = true; + break; + }; + // 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; + }; + out.questions.push(DnsQuestion { name, qtype: qtype_name(qt) }); + off = next + 4; + } + if !out.incomplete { + for _ in 0..an.min(64) { + let Some((name, next, service_instance)) = dns_name(msg, off, true) else { + out.incomplete = true; + break; + }; + 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; + }; + let rd_off = next + 10; + let Some(rd) = r.slice(rd_off, usize::from(rdlen)) else { + out.incomplete = true; + break; + }; + let end = rd_off + rd.len(); + let within_record = msg.get(..end).unwrap_or(&[]); + let record_class = if mdns_wire_format { class & 0x7fff } else { class }; + let empty_prerequisite = rd.is_empty() && opcode == 5 && matches!(class, 254 | 255) && ttl == 0; + let value = match (rt, rd.len()) { + (1 | 28 | 6 | 33 | 35 | 39 | 44 | 52 | 64 | 65 | 256 | 257, 0) if empty_prerequisite => String::new(), + (1 | 28, _) if record_class != 1 => format!("<{} bytes>", rd.len()), + (1, 4) => Ipv4Addr::new( + rd.first().copied().unwrap_or(0), + rd.get(1).copied().unwrap_or(0), + rd.get(2).copied().unwrap_or(0), + rd.get(3).copied().unwrap_or(0), + ) + .to_string(), + (28, 16) => Ipv6Addr::from(<[u8; 16]>::try_from(rd).unwrap_or([0; 16])).to_string(), + (1 | 28, _) => { + out.incomplete = true; + break; + } + (33, _) => { + let fields = Reader::new(rd); + let Some((target, _, _)) = dns_name(within_record, rd_off + 6, mdns_wire_format).filter(|(_, after, _)| *after == end) else { + out.incomplete = true; + break; + }; + let (Some(priority), Some(weight), Some(port)) = (fields.u16_be(0), fields.u16_be(2), fields.u16_be(4)) else { + out.incomplete = true; + break; + }; + format!("{priority} {weight} {port} {target}") + } + (6, _) => { + let soa = dns_name(within_record, rd_off, true).and_then(|(primary, pos, _)| { + let (mailbox, pos, _) = dns_name(within_record, pos, true)?; + let (words, tail) = within_record.get(pos..)?.as_chunks::<4>(); + if !tail.is_empty() { + return None; + } + let words: &[[u8; 4]; 5] = words.try_into().ok()?; + let [serial, refresh, retry, expire, minimum] = words.map(u32::from_be_bytes); + Some(format!("{primary} {mailbox} {serial} {refresh} {retry} {expire} {minimum}")) + }); + let Some(soa) = soa else { + out.incomplete = true; + break; + }; + soa + } + (257, _) => { + let Some((&flags, rest)) = rd.split_first() else { + out.incomplete = true; + break; + }; + let caa = rest.split_first().and_then(|(&n, body)| body.split_at_checked(usize::from(n))).and_then(|(tag, value)| { + (!tag.is_empty() && tag.iter().all(u8::is_ascii_alphanumeric)).then(|| { + let value: String = value.iter().flat_map(|&byte| std::ascii::escape_default(byte)).map(char::from).collect(); + format!("{flags} {} {value}", String::from_utf8_lossy(tag)) + }) + }); + let Some(caa) = caa else { + out.incomplete = true; + break; + }; + caa + } + (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 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(within_record, start, true).filter(|(_, after, _)| *after == end) else { + out.incomplete = true; + break; + }; + name + } + } + (16, _) => { + // 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 + 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 + } + (35 | 39 | 44 | 52 | 64 | 65 | 256, _) if record_class == 1 => { + let Some(value) = discovery_answer(rt, rd) else { + out.incomplete = true; + break; + }; + value + } + (_, 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); + } + } + out.incomplete |= flags & 0x0200 != 0; + d.dns = Some(out); +} + +/// HTTP method names are case-sensitive tokens, including extension methods. +fn http_method(method: &str) -> bool { + !method.is_empty() && method.bytes().all(|b| b.is_ascii_alphanumeric() || b"!#$%&'*+-.^_`|~".contains(&b)) +} + +/// Remove `user:password@` from an absolute request target. +pub fn strip_userinfo(target: &str) -> String { + if let Some((scheme, rest)) = target.split_once("://") { + let auth_end = rest.find(['/', '?', '#']).unwrap_or(rest.len()); + if let Some(at) = rest.get(..auth_end).and_then(|a| a.rfind('@')) { + return format!("{scheme}://{}", rest.get(at + 1..).unwrap_or("")); + } + } + target.to_string() +} + +fn tcp_app(p: &[u8], d: &mut Decoded) { + let head = p.get(..p.len().min(16 << 10)).unwrap_or(p); + let Some(line_end) = head.windows(2).position(|w| w == b"\r\n") else { + tls(p, d); + return; + }; + let line = String::from_utf8_lossy(head.get(..line_end).unwrap_or(&[])); + let version = |v: &str| matches!(v.as_bytes(), [b'H', b'T', b'T', b'P', b'/', b'1', b'.', b'0'..=b'9']); + let mut parts = line.splitn(3, ' '); + let fields = (parts.next(), parts.next(), parts.next()); + if let (Some(v), Some(code), reason) = fields + && version(v) + && matches!(code.as_bytes(), [b'1'..=b'5', b'0'..=b'9', b'0'..=b'9']) + && reason.is_none_or(|text| text.bytes().all(|b| b == b'\t' || !b.is_ascii_control())) + { + d.protocols.push("http"); + d.http = Some(Http { kind: "response", method: None, target: None, status: code.parse().ok(), version: v.to_string(), host: None }); + return; + } + if let (Some(m), Some(t), Some(v)) = fields + && http_method(m) + && !t.is_empty() + && !t.bytes().any(|b| b.is_ascii_control()) + && version(v) + { + 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; + } + tls(p, d); +} + +fn tls(p: &[u8], d: &mut Decoded) { + let r = Reader::new(p); + let (Some(ct), Some(major), Some(minor)) = (r.u8(0), r.u8(1), r.u8(2)) else { return }; + if !(20..=23).contains(&ct) || major != 3 || minor > 4 { + return; + } + d.protocols.push("tls"); + 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 { + 0x0300 => "SSL 3.0".to_string(), + 0x0301 => "TLS 1.0".into(), + 0x0302 => "TLS 1.1".into(), + 0x0303 => "TLS 1.2".into(), + 0x0304 => "TLS 1.3".into(), + v if v & 0x0f0f == 0x0a0a && v >> 8 == v & 0xff => "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: record_end > p.len(), + }; + let Some(handshake_header) = record.u32_be(5) else { + hello.partial = true; + d.tls = Some(hello); + return; + }; + 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, min: usize, max: usize| { + let n = usize::from(r.u8(off)?); + if !(min..=max).contains(&n) { + return None; + } + r.slice(off + 1, n)?; + Some(off + 1 + n) + }; + let cipher_suites_end = |off: usize| { + let n = usize::from(r.u16_be(off)?); + if n < 2 || n % 2 != 0 { + return None; + } + 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, 0, 32).and_then(cipher_suites_end).and_then(|p| skip8(p, 1, 255)) 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 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 seen_extensions = BTreeSet::new(); + let mut e = off + 2; + 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) = extensions.slice(body, usize::from(l)) else { + hello.partial = true; + break; + }; + if !seen_extensions.insert(t) { + hello.partial = true; + e = body + usize::from(l); + continue; + } + let dr = Reader::new(data); + match t { + 0 => { + if let Some(len) = dr.u16_be(0) { + let list_end = 2 + usize::from(len); + hello.partial |= len == 0 || 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.sni.is_some() { + hello.partial = true; + } else { + 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 => { + if let Some(len) = dr.u16_be(0) { + let list_end = 2 + usize::from(len); + hello.partial |= len == 0 || 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()) { + 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; + }; + if hello.alpn.len() < 16 { + hello.alpn.push(String::from_utf8_lossy(proto).into_owned()); + } + a += 1 + usize::from(n); + } + } else { + hello.partial = true; + } + } + 43 => { + if let Some(len) = dr.u8(0) { + let list_end = 1 + usize::from(len); + hello.partial |= len < 2 || 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); +} + +// --------------------------------------------------------------------------------------------- +// Flows and summaries + +/// Assigns stable 1-based flow ids in order of first appearance. +#[derive(Debug, Default)] +pub struct FlowTable { + ids: HashMap, + /// Frames whose flow arrived after `MAX_FLOWS` and got no id. + pub untracked: u64, +} + +impl FlowTable { + /// The id of `key`, creating it when there is room. + pub fn id_for(&mut self, key: FlowKey) -> Option { + if let Some(&id) = self.ids.get(&key) { + return Some(id); + } + if self.ids.len() >= MAX_FLOWS { + self.untracked += 1; + return None; + } + let id = self.ids.len() + 1; + self.ids.insert(key, id); + Some(id) + } +} + +/// "addr:port", with brackets around IPv6 addresses; the port is omitted when zero. +pub fn endpoint((ip, port): (IpAddr, u16)) -> String { + match (ip, port) { + (IpAddr::V6(v6), 0) => v6.to_string(), + (IpAddr::V6(v6), p) => format!("[{v6}]:{p}"), + (v4, 0) => v4.to_string(), + (v4, p) => format!("{v4}:{p}"), + } +} + +pub fn ip_protocol_name(p: u8) -> &'static str { + match p { + 1 => "icmp", + 6 => "tcp", + 17 => "udp", + 58 => "icmpv6", + _ => "other", + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize)] +pub struct Flow { + pub id: usize, + pub protocol: &'static str, + pub a: String, + pub b: String, + pub packets: u64, + pub bytes: u64, + pub packets_a_to_b: u64, + pub packets_b_to_a: u64, + pub bytes_a_to_b: u64, + pub bytes_b_to_a: u64, + pub first_frame: u64, + #[serde(skip_serializing_if = "Option::is_none")] + pub first_ts_ns: Option, + #[serde(skip_serializing_if = "Option::is_none")] + pub last_ts_ns: Option, + /// Application protocols seen in it (dns, http, tls…). + pub applications: BTreeSet<&'static str>, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize)] +pub struct Count { + pub value: String, + pub count: u64, +} + +#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize)] +pub struct Summary { + pub format: &'static str, + pub version: String, + pub interfaces: Vec, + pub packets: u64, + pub bytes: u64, + pub first_ts_ns: Option, + pub last_ts_ns: Option, + /// Frames per protocol label. + pub protocols: Vec, + /// Frames per full protocol stack (eth:ipv4:udp:dns). + pub stacks: Vec, + /// Frames per IP address (source and destination each count once per frame). + pub endpoints: Vec, + pub flows: Vec, + pub flows_untracked_frames: u64, + /// "name (TYPE)" asked in DNS queries. + pub dns_queries: Vec, + /// "name TYPE value" from DNS responses. + pub dns_answers: Vec, + /// "question A|AAAA address" from DNS responses: each address answered, keyed by the response's first + /// question (so CNAME chains end at the name that was asked), or the record owner in a questionless reply. + pub dns_addresses: Vec, + /// "METHOD host target" from HTTP/1.x requests. + pub http_requests: Vec, + /// Server names from TLS ClientHellos. + pub tls_sni: Vec, + pub tls_alpn: Vec, + /// Frames whose network layer was not decoded (other link types, ARP, other ethertypes). + pub undecoded_frames: u64, + /// Inventories that hit `MAX_INVENTORY` distinct values. + pub capped_inventories: Vec<&'static str>, + pub truncated: bool, + pub warnings: Vec, +} + +#[derive(Default)] +struct Tally { + map: BTreeMap, + capped: bool, +} + +impl Tally { + fn add(&mut self, k: String) { + if let Some(v) = self.map.get_mut(&k) { + *v += 1; + } else if self.map.len() < MAX_INVENTORY { + self.map.insert(k, 1); + } else { + self.capped = true; + } + } + + fn done(self, name: &'static str, capped: &mut Vec<&'static str>) -> Vec { + if self.capped { + capped.push(name); + } + let mut v: Vec = self.map.into_iter().map(|(value, count)| Count { value, count }).collect(); + v.sort_by(|a, b| b.count.cmp(&a.count).then_with(|| a.value.cmp(&b.value))); + v + } +} + +/// Read every frame once and summarize the capture. `cancelled` is polled every 4096 frames. +pub fn summarize(data: &[u8], cancelled: &dyn Fn() -> bool) -> Result { + let mut cap = Capture::new(data)?; + let mut s = Summary::default(); + let mut flows = FlowTable::default(); + let mut flow_rows: Vec = Vec::new(); + let (mut protocols, mut stacks, mut endpoints) = (Tally::default(), Tally::default(), Tally::default()); + let (mut queries, mut answers, mut http, mut sni, mut alpn) = + (Tally::default(), Tally::default(), Tally::default(), Tally::default(), Tally::default()); + let mut addresses = Tally::default(); + for f in cap.by_ref() { + if f.number % 4096 == 0 && cancelled() { + return Err(FormatError::Malformed("cancelled".into())); + } + s.packets += 1; + s.bytes += u64::from(f.original_len); + if let Some(t) = f.ts_ns { + s.first_ts_ns = Some(s.first_ts_ns.map_or(t, |x| x.min(t))); + s.last_ts_ns = Some(s.last_ts_ns.map_or(t, |x| x.max(t))); + } + let d = decode(f.link_type, f.data); + for (i, p) in d.protocols.iter().enumerate() { + if !d.protocols[..i].contains(p) { + protocols.add((*p).to_string()); + } + } + stacks.add(d.stack()); + let Some(ip) = &d.ip else { + s.undecoded_frames += 1; + continue; + }; + endpoints.add(ip.src.to_string()); + if ip.dst != ip.src { + endpoints.add(ip.dst.to_string()); + } + if let Some((key, forward)) = d.flow_key() + && let Some(id) = flows.id_for(key) + { + if id > flow_rows.len() { + flow_rows.push(Flow { + id, + protocol: ip_protocol_name(key.protocol), + a: endpoint(key.a), + b: endpoint(key.b), + packets: 0, + bytes: 0, + packets_a_to_b: 0, + packets_b_to_a: 0, + bytes_a_to_b: 0, + bytes_b_to_a: 0, + first_frame: f.number, + first_ts_ns: f.ts_ns, + last_ts_ns: f.ts_ns, + applications: BTreeSet::new(), + }); + } + if let Some(row) = flow_rows.get_mut(id - 1) { + row.packets += 1; + row.bytes += u64::from(f.original_len); + if forward { + row.packets_a_to_b += 1; + row.bytes_a_to_b += u64::from(f.original_len); + } else { + row.packets_b_to_a += 1; + row.bytes_b_to_a += u64::from(f.original_len); + } + 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); + } + } + } + if let Some(dns) = &d.dns { + if !dns.response { + for q in &dns.questions { + queries.add(format!("{} ({})", q.name, q.qtype)); + } + } + for a in &dns.answers { + answers.add(format!("{} {} {}", a.name, a.rtype, a.value)); + } + if dns.response { + for a in dns.answers.iter().filter(|a| matches!(a.rtype.as_str(), "A" | "AAAA") && a.value.parse::().is_ok()) { + // Questionless replies (including unsolicited mDNS) name the address in the answer. + let name = dns.questions.first().map_or(&a.name, |q| &q.name); + addresses.add(format!("{name} {} {}", a.rtype, a.value)); + } + } + } + if let Some(h) = &d.http + && h.kind == "request" + { + http.add(format!("{} {} {}", h.method.as_deref().unwrap_or("?"), h.host.as_deref().unwrap_or("-"), h.target.as_deref().unwrap_or(""))); + } + if let Some(t) = &d.tls { + if let Some(n) = &t.sni { + sni.add(n.clone()); + } + for a in &t.alpn { + alpn.add(a.clone()); + } + } + } + let mut capped = Vec::new(); + s.format = cap.format; + s.version = cap.version.clone(); + s.interfaces = cap.interfaces.clone(); + s.protocols = protocols.done("protocols", &mut capped); + s.stacks = stacks.done("stacks", &mut capped); + s.endpoints = endpoints.done("endpoints", &mut capped); + s.dns_queries = queries.done("dns_queries", &mut capped); + s.dns_answers = answers.done("dns_answers", &mut capped); + s.dns_addresses = addresses.done("dns_addresses", &mut capped); + s.http_requests = http.done("http_requests", &mut capped); + s.tls_sni = sni.done("tls_sni", &mut capped); + s.tls_alpn = alpn.done("tls_alpn", &mut capped); + s.capped_inventories = capped; + s.flows = flow_rows; + s.flows_untracked_frames = flows.untracked; + s.truncated = cap.truncated; + s.warnings = cap.warnings; + Ok(s) +} + +/// `YYYY-MM-DDThh:mm:ss.nnnnnnnnnZ` for nanoseconds since the Unix epoch. +pub fn iso8601(ns: u64) -> String { + // u64 nanoseconds span only 1970..2554, entirely within chrono's representable range. + chrono::DateTime::from_timestamp((ns / 1_000_000_000) as i64, (ns % 1_000_000_000) as u32) + .map(|time| time.to_rfc3339_opts(chrono::SecondsFormat::Nanos, true)) + .unwrap_or_default() +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::test_support::{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 = crate::test_support::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 = crate::test_support::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(crate::test_support::block(3, &1u32.to_le_bytes())); + let valid = crate::test_support::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 malformed_packet_blocks_share_the_budget_and_report_each_reason_once() { + use crate::test_support::block; + let mut data = pcapng(&[]); + for kind in [2, 6] { + let mut body = [0; 20]; + body[12..16].copy_from_slice(&u32::MAX.to_le_bytes()); + data.extend(block(kind, &body)); + } + let mut body = [0; 20]; + body[..4].copy_from_slice(&u32::MAX.to_le_bytes()); + data.extend(block(6, &body)); + let mut shb = pcapng(&[]); + shb.truncate(28); + data.extend(shb); + data.extend(block(3, &[0; 4])); // No interface in this section. + data.extend(block(3, &[0; 4])); + let mut cap = Capture::new(&data).unwrap(); + cap.count = MAX_PACKETS - 4; + assert!(cap.next().is_none()); + assert!(cap.truncated); + assert_eq!(cap.warnings.len(), 3); + assert!(cap.warnings.iter().any(|s| s.contains("2 packet block(s) naming"))); + assert!(cap.warnings.iter().any(|s| s.contains("2 packet block(s) with"))); + assert!(cap.next().is_none()); + assert_eq!(cap.warnings.len(), 3); + } + + #[test] + fn invalid_classic_fractions_do_not_move_the_capture_period() { + for (magic, scale) in [(CLASSIC_US, 1_000_000u32), (CLASSIC_NS, 1_000_000_000)] { + let mut data = pcap(&[vec![], vec![]]); + data[..4].copy_from_slice(&magic.to_le_bytes()); + data[28..32].copy_from_slice(&scale.to_le_bytes()); + data[44..48].copy_from_slice(&(scale - 1).to_le_bytes()); + let mut cap = Capture::new(&data).unwrap(); + assert_eq!(cap.next().unwrap().ts_ns, None); + assert!(cap.next().unwrap().ts_ns.is_some()); + assert!(cap.next().is_none()); + assert_eq!(cap.warnings.len(), 1); + } + } + + #[test] + fn subnanosecond_decimal_resolutions_keep_the_interface_offset() { + use crate::test_support::block; + let mut data = pcapng(&[]); + data.truncate(28); + let mut idb = vec![1, 0, 0, 0, 0, 0, 0, 0, 9, 0, 1, 0, 127, 0, 0, 0, 14, 0, 8, 0]; + idb.extend(2i64.to_le_bytes()); + data.extend(block(1, &idb)); + let mut epb = [0; 20]; + epb[4..12].fill(0xff); + data.extend(block(6, &epb)); + let frame = Capture::new(&data).unwrap().next().unwrap(); + assert_eq!(frame.ts_ns, Some(2_000_000_000)); + } + + #[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). + let mut tcp = Vec::new(); + tcp.extend(41000u16.to_be_bytes()); + tcp.extend(9000u16.to_be_bytes()); + tcp.extend([0, 0, 0, 1, 0, 0, 0, 0, 0x50, 0x18, 4, 0, 0, 0, 0, 0]); + let mut frame = eth(0x0800, &ipv4_pkt(6, [10, 0, 0, 1], [10, 0, 0, 2], &tcp)); + frame.truncate(14 + 20 + 11); + let d = decode(1, &frame); + let t = d.transport.unwrap(); + assert_eq!((t.src_port, t.dst_port), (Some(41000), Some(9000))); + assert_eq!(t.seq, Some(1)); + assert_eq!(t.ack, None); + assert_eq!(t.window, None); + assert!(d.protocols.contains(&"tcp")); + } + + /// One-answer DNS response for `example.com` with a TXT answer carrying `rdata`. + fn txt_response(rdata: &[u8]) -> Vec { + let mut m = vec![0x12, 0x34, 0x81, 0x80, 0, 1, 0, 1, 0, 0, 0, 0]; + m.extend(b"\x07example\x03com\x00\x00\x01\x00\x01"); + m.extend([0xc0, 12, 0, 16, 0, 1, 0, 0, 0x00, 0x3c]); + m.extend((rdata.len() as u16).to_be_bytes()); + m.extend(rdata); + m + } + + #[test] + fn dns_txt_answer_keeps_every_character_string() { + // RFC 1035 §3.3.14: one TXT RDATA holds any number of length-prefixed + // character strings. Only the first used to survive (issue #330). + let rdata = [ + 5, b'f', b'i', b'r', b's', b't', // "first" + 6, b's', b'e', b'c', b'o', b'n', b'd', // "second" + ]; + let frame = eth(0x0800, &ipv4_pkt(17, [8, 8, 8, 8], [192, 168, 1, 10], &udp(53, 50000, &txt_response(&rdata)))); + let d = decode(1, &frame); + let dns = d.dns.unwrap(); + assert_eq!(dns.answers.len(), 1); + assert_eq!(dns.answers[0].rtype, "TXT"); + assert_eq!(dns.answers[0].value, "firstsecond"); + assert!(!dns.incomplete); + } + + #[test] + fn dns_txt_empty_first_string_keeps_later_content() { + // A zero-length character string does not end the record. + let rdata = [0, 6, b's', b'e', b'c', b'o', b'n', b'd']; + let frame = eth(0x0800, &ipv4_pkt(17, [8, 8, 8, 8], [192, 168, 1, 10], &udp(53, 50000, &txt_response(&rdata)))); + let d = decode(1, &frame); + let dns = d.dns.unwrap(); + assert_eq!(dns.answers.len(), 1); + assert_eq!(dns.answers[0].value, "second"); + assert!(!dns.incomplete); + } + + fn classic_link_word(link_word: u32, le: bool, nanos: bool, trailer: usize) { + let link = link_word & 0xffff; + let mut frame = sample_frames()[1].clone(); + if link == 101 { + frame.drain(..14); + } + frame.extend(vec![0xab; trailer]); + let word = |v: u32| if le { v.to_le_bytes() } else { v.to_be_bytes() }; + let short = |v: u16| if le { v.to_le_bytes() } else { v.to_be_bytes() }; + let mut data = word(if nanos { CLASSIC_NS } else { CLASSIC_US }).to_vec(); + data.extend(short(2)); + data.extend(short(4)); + data.extend([0; 8]); + data.extend(word(65535)); + data.extend(word(link_word)); + data.extend(word(1_700_000_000)); + data.extend(word(500)); + data.extend(word(frame.len() as u32)); + data.extend(word(frame.len() as u32)); + data.extend(&frame); + + let mut cap = Capture::new(&data).unwrap(); + assert_eq!(cap.interfaces[0].link_type, link); + assert_eq!(cap.interfaces[0].link_name, if link == 1 { "Ethernet" } else { "raw IP" }); + let packet = cap.next().unwrap(); + assert_eq!(packet.link_type, link); + assert_eq!(packet.data, frame); + assert_eq!(packet.ts_ns, Some(1_700_000_000_000_000_000 + if nanos { 500 } else { 500_000 })); + let d = decode(packet.link_type, packet.data); + assert_eq!(d.stack(), if link == 1 { "eth:ipv4:udp:dns" } else { "raw:ipv4:udp:dns" }); + let ip = d.ip.unwrap(); + assert_eq!(ip.src.to_string(), "8.8.8.8"); + assert_eq!(ip.dst.to_string(), "192.168.1.10"); + let dns = d.dns.unwrap(); + assert!(dns.response); + assert_eq!(dns.answers[0].value, "93.184.216.34"); + assert!(cap.next().is_none()); + + let s = summarize(&data, &|| false).unwrap(); + assert_eq!(s.packets, 1); + assert_eq!(s.undecoded_frames, 0); + assert_eq!(s.dns_answers[0].value, "example.com A 93.184.216.34"); + assert_eq!(s.flows[0].protocol, "udp"); + assert!(s.warnings.is_empty()); + } + + #[test] + fn fcs_bits_do_not_change_the_ethernet_link_type() { + classic_link_word(0x24000001, true, false, 4); + } + + #[test] + fn fcs_bits_are_masked_in_big_endian_files() { + classic_link_word(0x24000001, false, false, 4); + } + + #[test] + fn fcs_bits_are_masked_in_nanosecond_files() { + classic_link_word(0x24000001, true, true, 4); + } + + #[test] + fn fcs_bits_are_masked_in_big_endian_nanosecond_files() { + classic_link_word(0x24000001, false, true, 4); + classic_link_word(1, false, true, 0); + } + + #[test] + fn fcs_bits_do_not_change_big_endian_nanosecond_raw_ip() { + classic_link_word(0x24000065, false, true, 4); + classic_link_word(101, false, true, 0); + } + + #[test] + fn a_one_word_fcs_length_is_masked() { + classic_link_word(0x14000001, true, false, 2); + } + + #[test] + fn fcs_bits_do_not_change_the_raw_ip_link_type() { + classic_link_word(0x24000065, true, false, 4); + } + + #[test] + fn ethernet_without_fcs_bits_still_decodes() { + classic_link_word(1, true, false, 0); + } + + #[test] + fn raw_ip_without_fcs_bits_still_decodes() { + classic_link_word(101, true, false, 0); + } + + #[test] + fn linux_cooked_vlan_frames_reach_the_network_decoder() { + let ip = ipv4_pkt(17, [10, 0, 0, 1], [10, 0, 0, 2], &udp(123, 456, b"payload")); + for (link, header_len, protocol_at) in [(113, 16, 14), (276, 20, 0)] { + let mut frame = vec![0; header_len]; + frame[protocol_at..protocol_at + 2].copy_from_slice(&0x88a8_u16.to_be_bytes()); + frame.extend_from_slice(&[0, 1, 0x81, 0, 0, 2, 0x08, 0]); + frame.extend_from_slice(&ip); + let decoded = decode(link, &frame); + assert_eq!(decoded.protocols.iter().filter(|&&p| p == "vlan").count(), 2); + assert_eq!(decoded.transport.unwrap().dst_port, Some(456)); + assert!(decode(link, &frame[..header_len + 1]).ip.is_none()); + } + } + + #[test] + fn decodes_dns_tls_http() { + let frames = sample_frames(); + let d = decode(1, &frames[1]); + assert_eq!(d.stack(), "eth:ipv4:udp:dns"); + let dns = d.dns.unwrap(); + assert!(dns.response); + assert_eq!(dns.questions[0].name, "example.com"); + assert_eq!(dns.answers[0].value, "93.184.216.34"); + assert_eq!(dns.answers[0].ttl, 3600); + + let d = decode(1, &frames[4]); + assert_eq!(d.stack(), "eth:ipv4:tcp:tls"); + let t = d.tls.unwrap(); + assert_eq!(t.sni.as_deref(), Some("example.com")); + assert_eq!(t.alpn, vec!["h2", "http/1.1"]); + assert_eq!(t.supported_versions, vec!["TLS 1.3", "TLS 1.2"]); + assert!(!t.partial); + + let d = decode(1, &frames[5]); + let h = d.http.unwrap(); + assert_eq!(h.method.as_deref(), Some("GET")); + assert_eq!(h.host.as_deref(), Some("example.com")); + assert_eq!(h.target.as_deref(), Some("http://example.com/a?b=1")); + assert_eq!(decode(1, &frames[3]).transport.unwrap().tcp_flags.as_deref(), Some("SYN,ACK")); + assert_eq!(decode(1, &frames[6]).stack(), "eth:arp"); + } + + #[test] + fn summarizes_pcap_and_pcapng_alike() { + let frames = sample_frames(); + for data in [pcap(&frames), pcapng(&frames)] { + let s = summarize(&data, &|| false).unwrap(); + assert_eq!(s.packets, 7); + assert_eq!(s.flows.len(), 3, "{:?}", s.flows); + assert_eq!(s.flows[0].protocol, "udp"); + assert_eq!(s.flows[0].packets, 2); + assert_eq!((s.flows[0].packets_a_to_b, s.flows[0].packets_b_to_a), (1, 1)); + assert!(s.flows[1].applications.contains("tls")); + assert_eq!(s.dns_queries[0].value, "example.com (A)"); + assert_eq!(s.dns_answers[0].value, "example.com A 93.184.216.34"); + assert_eq!(s.tls_sni[0].value, "example.com"); + assert_eq!(s.http_requests[0].value, "GET example.com http://example.com/a?b=1"); + assert_eq!(s.undecoded_frames, 1); + assert!(s.warnings.is_empty(), "{:?}", s.warnings); + assert_eq!(s.interfaces[0].link_type, 1); + assert!(s.first_ts_ns.unwrap() >= 1_700_000_000_000_000_000); + } + assert_eq!(summarize(&pcap(&frames), &|| false).unwrap().format, "pcap"); + assert_eq!(iso8601(1_700_000_000_000_000_500), "2023-11-14T22:13:20.000000500Z"); + assert_eq!(iso8601(0), "1970-01-01T00:00:00.000000000Z"); + } + + #[test] + fn qinq_frames_count_vlan_once_per_frame() { + let mut payload = vec![0x00, 0x0a, 0x81, 0x00, 0x00, 0x14, 0x08, 0x00]; + payload.extend(ipv4_pkt(17, [10, 0, 0, 1], [10, 0, 0, 2], &udp(40000, 9999, b"ping"))); + let frame = eth(0x88a8, &payload); + let s = summarize(&pcap(&[frame.clone(), frame.clone(), frame]), &|| false).unwrap(); + let count = |name: &str| s.protocols.iter().find(|c| c.value == name).map(|c| c.count); + assert_eq!(s.stacks[0].value, "eth:vlan:vlan:ipv4:udp"); + assert_eq!(count("vlan"), Some(3)); + assert_eq!(count("eth"), Some(3)); + assert_eq!(count("ipv4"), Some(3)); + } + + #[test] + fn flows_count_bytes_per_direction() { + let req = eth(0x0800, &ipv4_pkt(17, [10, 0, 0, 1], [10, 0, 0, 2], &udp(40000, 9999, &[b'q'; 10]))); + let rep = eth(0x0800, &ipv4_pkt(17, [10, 0, 0, 2], [10, 0, 0, 1], &udp(9999, 40000, &[b'r'; 300]))); + let s = summarize(&pcap(&[req, rep]), &|| false).unwrap(); + let flow = serde_json::to_value(&s.flows[0]).unwrap(); + assert_eq!(flow["bytes"], 394); + assert_eq!(flow["bytes_a_to_b"], 52); + assert_eq!(flow["bytes_b_to_a"], 342); + } + + #[test] + fn pcapng_interface_tsoffset_adjusts_timestamps() { + let base = pcapng(&sample_frames()); + for offset_s in [3600i64, -50i64] { + let mut data = base[..52].to_vec(); + data.extend(14u16.to_le_bytes()); + data.extend(8u16.to_le_bytes()); + data.extend(offset_s.to_le_bytes()); + data.extend(&base[52..]); + data[32..36].copy_from_slice(&44u32.to_le_bytes()); + data[68..72].copy_from_slice(&44u32.to_le_bytes()); + let expected0 = (1_700_000_000_000_000_000i128 + i128::from(offset_s) * 1_000_000_000) as u64; + let frames: Vec<_> = Capture::new(&data).unwrap().collect(); + assert_eq!(frames[0].ts_ns, Some(expected0)); + let s = summarize(&data, &|| false).unwrap(); + assert_eq!((s.first_ts_ns, s.last_ts_ns), (Some(expected0), Some(expected0 + 6))); + assert_eq!((s.flows[0].first_ts_ns, s.flows[0].last_ts_ns), (Some(expected0), Some(expected0 + 1))); + } + } + + #[test] + fn ipv6_extension_outside_declared_payload_is_ignored() { + let mut v6 = vec![0x60, 0, 0, 0]; + v6.extend(0u16.to_be_bytes()); + v6.extend([60, 64]); + v6.extend([0u8; 32]); + v6.extend([17, 0, 0, 0, 0, 0, 0, 0]); + + let d = decode(101, &v6); + assert_eq!(d.ip.unwrap().protocol, 60); + } + + #[test] + fn ipv6_sll_and_raw_links() { + let mut v6 = vec![0x60, 0, 0, 0]; + let payload = udp(1000, 53, &dns_query()); + v6.extend((payload.len() as u16).to_be_bytes()); + v6.extend([17, 64]); + v6.extend([0x20, 0x01, 0x0d, 0xb8].iter().chain([0u8; 11].iter()).chain([1u8].iter())); + v6.extend([0x20, 0x01, 0x0d, 0xb8].iter().chain([0u8; 11].iter()).chain([2u8].iter())); + v6.extend(&payload); + let d = decode(101, &v6); + assert_eq!(d.stack(), "raw:ipv6:udp:dns"); + assert_eq!(d.ip.unwrap().src.to_string(), "2001:db8::1"); + let mut sll = vec![0u8; 14]; + sll.extend(0x86ddu16.to_be_bytes()); + sll.extend(&v6); + assert_eq!(decode(113, &sll).stack(), "sll:ipv6:udp:dns"); + assert!(decode(105, &v6).note.is_some()); + } + + #[test] + fn hostile_input_never_panics() { + assert!(Capture::new(b"").is_err()); + assert!(Capture::new(b"not a capture at all").is_err()); + let data = pcapng(&sample_frames()); + for cut in [0, 10, 28, 40, 100, data.len() / 2, data.len() - 3] { + let _ = summarize(data.get(..cut).unwrap(), &|| false); + } + let mut bad = pcap(&sample_frames()); + bad[32..36].copy_from_slice(&[0xff; 4]); // incl_len of the first record far past the end + let s = summarize(&bad, &|| false).unwrap(); + assert_eq!(s.packets, 0); + assert!(!s.warnings.is_empty()); + for seed in 0..200u64 { + let mut x = seed.wrapping_mul(6364136223846793005).wrapping_add(1442695040888963407); + let noise: Vec = (0..300) + .map(|_| { + x ^= x << 13; + x ^= x >> 7; + x ^= x << 17; + x as u8 + }) + .collect(); + for link in [0, 1, 101, 113, 276, 228] { + let _ = decode(link, &noise); + } + let mut f = sample_frames(); + f.push(noise); + let _ = summarize(&pcap(&f), &|| false); + } + // DNS compression loops are refused. + assert!(dns_name(&[0xc0, 0x00], 0, true).is_none()); + } +} + +#[cfg(test)] +mod timestamp_parity { + fn legacy_iso8601(ns: u64) -> String { + let secs = ns / 1_000_000_000; + let (days, rem) = (secs / 86_400, secs % 86_400); + // Civil-from-days (proleptic Gregorian), valid for every u64 day count we can reach. + let z = days as i64 + 719_468; + let era = z.div_euclid(146_097); + let doe = z - era * 146_097; + let yoe = (doe - doe / 1460 + doe / 36_524 - doe / 146_096) / 365; + let doy = doe - (365 * yoe + yoe / 4 - yoe / 100); + let mp = (5 * doy + 2) / 153; + let day = doy - (153 * mp + 2) / 5 + 1; + let month = if mp < 10 { mp + 3 } else { mp - 9 }; + let year = yoe + era * 400 + i64::from(month <= 2); + format!("{year:04}-{month:02}-{day:02}T{:02}:{:02}:{:02}.{:09}Z", rem / 3600, rem % 3600 / 60, rem % 60, ns % 1_000_000_000) + } + + #[test] + fn every_representable_day_and_boundaries_match_legacy() { + let day = 86_400_000_000_000u64; + for d in 0..=u64::MAX / day { + let ns = d * day; + assert_eq!(super::iso8601(ns), legacy_iso8601(ns)); + } + for ns in [0, 1, 999_999_999, 1_000_000_000, u64::MAX - 1, u64::MAX] { + assert_eq!(super::iso8601(ns), legacy_iso8601(ns)); + } + } +} diff --git a/crates/pcap/tests/dns_discovery_answers.rs b/crates/pcap/tests/dns_discovery_answers.rs new file mode 100644 index 000000000..97d9dc0dc --- /dev/null +++ b/crates/pcap/tests/dns_discovery_answers.rs @@ -0,0 +1,60 @@ +#[path = "support/mod.rs"] +mod support; + +use craft_pcap::{Dns, decode}; +use support::{dns_query, eth, ipv4_pkt, udp}; + +fn answer(kind: u16, rd: &[u8]) -> Dns { + let mut msg = dns_query(); + msg[2..4].copy_from_slice(&0x8180u16.to_be_bytes()); + msg[6..8].copy_from_slice(&1u16.to_be_bytes()); + msg.extend([0xc0, 12]); + msg.extend(kind.to_be_bytes()); + msg.extend([0, 1, 0, 0, 0, 60]); + msg.extend((rd.len() as u16).to_be_bytes()); + msg.extend(rd); + decode(1, ð(0x0800, &ipv4_pkt(17, [192, 0, 2, 2], [192, 0, 2, 1], &udp(53, 51000, &msg)))).dns.unwrap() +} + +#[test] +fn svc_binding_reports_target_and_port() { + for kind in [64, 65] { + let msg = answer(kind, b"\0\x01\x03api\0\0\x03\0\x02\x20\xfb"); + assert_eq!(msg.answers[0].value, "1 api port=8443"); + assert_eq!(answer(kind, b"\0\x01\0\0\x01\0\x03\x02h2\0\x04\0\x04\xc0\0\x02\x01").answers[0].value, "1 . alpn=h2 ipv4hint=192.0.2.1"); + assert!(answer(kind, b"\0\x01\0\0\x01\0\x01\x00").incomplete); + assert!(answer(kind, b"\0\x01\xc0\x0c").incomplete); + assert!(answer(kind, b"\0\x01\0\0\x03\0\x01\x00").incomplete); + } +} +#[test] +fn sshfp_preserves_algorithm_and_complete_digest() { + let mut d = vec![4, 2]; + d.extend([0x5a; 32]); + assert_eq!(answer(44, &d).answers[0].value, format!("4 2 {}", "5a".repeat(32))); + assert!(answer(44, &d[..15]).incomplete); +} +#[test] +fn tlsa_keeps_selector_and_certificate_association() { + let mut d = vec![3, 1, 1]; + d.extend([0xaa; 32]); + assert_eq!(answer(52, &d).answers[0].value, format!("3 1 1 {}", "aa".repeat(32))); + assert!(answer(52, &d[..4]).incomplete); +} +#[test] +fn naptr_keeps_order_preference_strings_and_replacement() { + let rd = b"\0\x0a\0\x02\x01s\x03sip\0\x03srv\0"; + assert_eq!(answer(35, rd).answers[0].value, r#"10 2 "s" "sip" "" srv"#); + assert!(answer(35, &rd[..rd.len() - 1]).incomplete); +} +#[test] +fn uri_keeps_priority_weight_and_target() { + assert_eq!(answer(256, b"\0\x02\0\x05https://x.test/s").answers[0].value, r#"2 5 "https://x.test/s""#); + assert!(answer(256, b"\0\x02\0\x05").incomplete); +} +#[test] +fn dname_only_accepts_a_complete_uncompressed_target() { + assert_eq!(answer(39, b"\x04host\0").answers[0].value, "host"); + assert!(answer(39, b"\xc0\x0c").incomplete); + assert!(answer(39, b"\x04host\0extra").incomplete); +} diff --git a/crates/pcap/tests/dns_question_class.rs b/crates/pcap/tests/dns_question_class.rs new file mode 100644 index 000000000..b6583f7f3 --- /dev/null +++ b/crates/pcap/tests/dns_question_class.rs @@ -0,0 +1,58 @@ +#[path = "support/mod.rs"] +mod support; + +use craft_pcap::{decode, summarize}; +use support::{dns_query, eth, ipv4_pkt, pcap, udp}; + +fn packet(message: &[u8]) -> Vec { + 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"); + } +} diff --git a/crates/pcap/tests/dns_rdata_names.rs b/crates/pcap/tests/dns_rdata_names.rs new file mode 100644 index 000000000..7e8542a0a --- /dev/null +++ b/crates/pcap/tests/dns_rdata_names.rs @@ -0,0 +1,272 @@ +#[path = "support/mod.rs"] +mod support; + +use craft_pcap::{decode, summarize}; +use support::{dns_query, eth, ipv4_pkt, pcap, udp}; + +fn response(record_type: u16, rdata: &[u8], declared_length: usize) -> Vec { + 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 { + 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 { + 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"); + } + } +} + +#[test] +fn an_in_address_requires_the_right_wire_size_but_update_prerequisites_may_be_empty() { + for (kind, bad) in [(1, &[1, 2, 3][..]), (28, &[0; 15][..])] { + let mut msg = response(kind, bad, bad.len()); + assert!(decode(1, &packet(&msg)).dns.unwrap().incomplete); + msg = response(kind, &[], 0); + msg[2..4].copy_from_slice(&0x2800u16.to_be_bytes()); + let n = msg.len(); + msg[n - 8..n - 6].copy_from_slice(&255u16.to_be_bytes()); + msg[n - 6..n - 2].fill(0); + let dns = decode(1, &packet(&msg)).dns.unwrap(); + assert!(!dns.incomplete); + assert_eq!(dns.answers[0].value, ""); + } +} + +#[test] +fn questionless_announcements_and_truncated_responses_keep_their_address() { + let mut message = vec![0, 0, 0x86, 0, 0, 0, 0, 1, 0, 0, 0, 0]; + message.extend(b"\x04node\x05local\x00\x00\x01\x80\x01\x00\x00\x00\x3c\x00\x04\xc0\x00\x02\x04"); + let frame = eth(0x0800, &ipv4_pkt(17, [192, 0, 2, 4], [224, 0, 0, 251], &udp(5353, 5353, &message))); + let dns = decode(1, &frame).dns.unwrap(); + assert!(dns.incomplete); + assert_eq!(dns.answers.len(), 1); + assert_eq!(summarize(&pcap(&[frame]), &|| false).unwrap().dns_addresses[0].value, "node.local A 192.0.2.4"); + assert!(decode(1, &packet(&message[..8])).dns.is_none()); +} + +#[test] +fn service_records_report_their_fields_and_refuse_invalid_framing() { + let mut soa = vec![0xc0, 12, 0xc0, 12]; + for n in 1u32..=5 { + soa.extend(n.to_be_bytes()); + } + for (kind, data, expected) in [ + (33, &b"\x00\x01\x00\x02\x01\xbb\x03srv\x00"[..], "1 2 443 srv"), + (6, soa.as_slice(), "example.com example.com 1 2 3 4 5"), + (257, &b"\x80\x05issueca.test"[..], "128 issue ca.test"), + ] { + let dns = decode(1, &packet(&response(kind, data, data.len()))).dns.unwrap(); + assert!(!dns.incomplete); + assert_eq!(dns.answers[0].value, expected); + } + for (kind, bad) in [(33, &b"\x00\x01\x00\x02\x01\xbb\xc0\x0c"[..]), (6, &soa[..soa.len() - 1]), (257, &b"\x00\x06issue"[..])] { + let dns = decode(1, &packet(&response(kind, bad, bad.len()))).dns.unwrap(); + assert!(dns.incomplete); + assert!(dns.answers.is_empty()); + } +} + +#[test] +fn mdns_srv_targets_can_be_compressed_except_in_legacy_replies() { + let data = [0, 1, 0, 2, 1, 187, 0xc0, 12]; + let msg = response(33, &data, data.len()); + for (port, legacy) in [(5353, false), (51000, true)] { + let frame = eth(0x0800, &ipv4_pkt(17, [192, 0, 2, 4], [192, 0, 2, 1], &udp(5353, port, &msg))); + let dns = decode(1, &frame).dns.unwrap(); + assert_eq!(dns.incomplete, legacy); + if !legacy { + assert_eq!(dns.answers[0].value, "1 2 443 example.com"); + } + } +} + +#[test] +fn caa_binary_values_remain_distinct_in_the_inventory() { + for (bytes, display) in [(&b"\xff"[..], r"\xff"), (b"\xfe", r"\xfe"), (br"\xff", r"\\xff")] { + let mut data = b"\x00\x01x".to_vec(); + data.extend(bytes); + let dns = decode(1, &packet(&response(257, &data, data.len()))).dns.unwrap(); + assert_eq!(dns.answers[0].value, format!("0 x {display}")); + } +} + +#[test] +fn only_mdns_masks_the_cache_flush_bit_in_an_address_class() { + let mut msg = response(1, &[192, 0, 2, 1], 4); + let class = msg.len() - 12; + msg[class..class + 2].copy_from_slice(&0x8001u16.to_be_bytes()); + for (port, expected) in [(53, "<4 bytes>"), (5353, "192.0.2.1")] { + let frame = eth(0x0800, &ipv4_pkt(17, [192, 0, 2, 4], [192, 0, 2, 1], &udp(port, port, &msg))); + assert_eq!(decode(1, &frame).dns.unwrap().answers[0].value, expected); + } +} diff --git a/crates/pcap/tests/pcap_dns_name_limit.rs b/crates/pcap/tests/pcap_dns_name_limit.rs new file mode 100644 index 000000000..82fc4e9f0 --- /dev/null +++ b/crates/pcap/tests/pcap_dns_name_limit.rs @@ -0,0 +1,167 @@ +#[path = "support/mod.rs"] +mod support; + +use craft_pcap::{Dns, decode}; +use support::{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) -> 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"); + } +} + +#[test] +fn dns_label_escapes_distinguish_wire_names_in_question_and_answer_owners() { + let mut message = vec![0, 1, 0x81, 0x80, 0, 2, 0, 1, 0, 0, 0, 0]; + message.extend(b"\x03a.b\x03\\\x00\xff\x00\x00\x01\x00\x01"); + message.extend(b"\x01a\x01b\x03\\\x00\xff\x00\x00\x01\x00\x01"); + message.extend([0xc0, 12, 0, 1, 0, 1, 0, 0, 0, 0, 0, 4, 1, 2, 3, 4]); + let dns = decode(101, &ipv4_pkt(17, [1; 4], [2; 4], &udp(53, 100, &message))).dns.unwrap(); + assert!(!dns.incomplete); + assert_eq!(dns.questions[0].name, r"a\.b.\\\000\255"); + assert_eq!(dns.questions[1].name, r"a.b.\\\000\255"); + assert_eq!(dns.answers[0].name, dns.questions[0].name); +} diff --git a/crates/pcap/tests/pcap_dns_txt_lengths.rs b/crates/pcap/tests/pcap_dns_txt_lengths.rs new file mode 100644 index 000000000..56312df41 --- /dev/null +++ b/crates/pcap/tests/pcap_dns_txt_lengths.rs @@ -0,0 +1,199 @@ +#[path = "support/mod.rs"] +mod support; + +use craft_pcap::{Dns, decode}; +use support::{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"); +} diff --git a/crates/pcap/tests/pcap_flow_time_range.rs b/crates/pcap/tests/pcap_flow_time_range.rs new file mode 100644 index 000000000..722121f4b --- /dev/null +++ b/crates/pcap/tests/pcap_flow_time_range.rs @@ -0,0 +1,39 @@ +#[path = "support/mod.rs"] +mod support; + +use craft_pcap::summarize; +use support::{block, eth, ipv4_pkt, pcap, pcapng, udp}; + +fn frame() -> Vec { + 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); +} diff --git a/crates/pcap/tests/pcap_http_host_boundary.rs b/crates/pcap/tests/pcap_http_host_boundary.rs new file mode 100644 index 000000000..5baa58fee --- /dev/null +++ b/crates/pcap/tests/pcap_http_host_boundary.rs @@ -0,0 +1,70 @@ +#[path = "support/mod.rs"] +mod support; + +use craft_pcap::{Http, decode}; +use support::{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")); +} + +#[test] +fn http_evidence_needs_a_complete_start_line() { + for input in [ + b"GET / HTTP/1.1".as_slice(), + b"GET / HTTP/1.1x\r\n", + b"GET / HTTP/1.1 extra\r\n", + b"GET HTTP/1.0\r\n", + b"GET /bad\tpath HTTP/1.1\r\n", + b"HTTP/1.garbage\r\n", + b"HTTP/1.1 20 OK\r\n", + b"HTTP/1.1 999 OK\r\n", + b"HTTP/1.1 200 OK", + b"HTTP/1.garbage 204\r\n\r\n", + b"HTTP/1.1 20\r\n\r\n", + b"HTTP/1.1 2040\r\n\r\n", + b"HTTP/1.1 999\r\n\r\n", + b"HTTP/1.1 2x4\r\n\r\n", + b"HTTP/1.1 204", + b"HTTP/1.1 204 bad\0reason\r\n\r\n", + ] { + assert!(decode(101, &ipv4_pkt(6, [1; 4], [2; 4], &tcp(100, 80, 0x18, input))).http.is_none(), "{input:?}"); + } + assert_eq!(request(b"GET / HTTP/1.0\r\n").version, "HTTP/1.0"); + assert_eq!(request(b"HTTP/1.1 204 \r\n").status, Some(204)); + assert_eq!(request(b"HTTP/1.1 403 Access denied\r\n").status, Some(403)); +} + +#[test] +fn responses_with_no_reason_phrase_still_keep_the_status_code() { + for (input, version, code) in + [(b"HTTP/1.1 204\r\n\r\n".as_slice(), "HTTP/1.1", 204), (b"HTTP/1.0 200\r\nContent-Length: 0\r\n\r\n".as_slice(), "HTTP/1.0", 200)] + { + let decoded = decode(101, &ipv4_pkt(6, [1; 4], [2; 4], &tcp(80, 100, 0x18, input))); + assert!(decoded.protocols.contains(&"http")); + let http = decoded.http.unwrap(); + assert_eq!(http.kind, "response"); + assert_eq!(http.version, version); + assert_eq!(http.status, Some(code)); + assert!(http.method.is_none()); + assert!(http.target.is_none()); + } +} diff --git a/crates/pcap/tests/pcap_http_methods.rs b/crates/pcap/tests/pcap_http_methods.rs new file mode 100644 index 000000000..57eb4e548 --- /dev/null +++ b/crates/pcap/tests/pcap_http_methods.rs @@ -0,0 +1,35 @@ +#[path = "support/mod.rs"] +mod support; + +use craft_pcap::decode; +use support::{ipv4_pkt, tcp}; + +/// WebDAV and extension methods retain the same HTTP evidence as core methods. +#[test] +fn extension_methods_are_http_requests() { + for method in ["PROPFIND", "MKCOL", "LOCK", "REPORT", "M-SEARCH", "custom", "X!#$%&'*+-.^_`|~012"] { + let request = format!("{method} /collection/ HTTP/1.1\r\nHost: dav.example\r\n\r\n"); + let decoded = decode(101, &ipv4_pkt(6, [1; 4], [2; 4], &tcp(100, 80, 0x18, request.as_bytes()))); + let http = decoded.http.unwrap_or_else(|| panic!("missing HTTP: {method}")); + assert_eq!(http.method.as_deref(), Some(method)); + assert_eq!(http.target.as_deref(), Some("/collection/")); + assert_eq!(http.host.as_deref(), Some("dav.example")); + } +} + +/// A method still needs a nonempty ASCII token and a complete valid start line. +#[test] +fn invalid_extension_method_lines_are_not_http() { + for request in [ + " / HTTP/1.1\r\n", + "BAD:METHOD / HTTP/1.1\r\n", + "BAD/METHOD / HTTP/1.1\r\n", + "MÉTHOD / HTTP/1.1\r\n", + "BAD\tMETHOD / HTTP/1.1\r\n", + "PROPFIND / HTTP/1.1", + "PROPFIND / HTTP/no\r\n", + ] { + let decoded = decode(101, &ipv4_pkt(6, [1; 4], [2; 4], &tcp(100, 80, 0x18, request.as_bytes()))); + assert!(decoded.http.is_none(), "{request:?}"); + } +} diff --git a/crates/pcap/tests/pcap_ipv4_lengths.rs b/crates/pcap/tests/pcap_ipv4_lengths.rs new file mode 100644 index 000000000..e1ea930a0 --- /dev/null +++ b/crates/pcap/tests/pcap_ipv4_lengths.rs @@ -0,0 +1,60 @@ +#[path = "support/mod.rs"] +mod support; + +use craft_pcap::decode; +use support::{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)); +} diff --git a/crates/pcap/tests/pcap_ipv6_fragments.rs b/crates/pcap/tests/pcap_ipv6_fragments.rs new file mode 100644 index 000000000..1c413f4b3 --- /dev/null +++ b/crates/pcap/tests/pcap_ipv6_fragments.rs @@ -0,0 +1,43 @@ +#[path = "support/mod.rs"] +mod support; + +use craft_pcap::decode; +use support::{eth, udp}; + +fn packet(offset: u16, next: u8, payload: &[u8]) -> Vec { + 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); + } +} diff --git a/crates/pcap/tests/pcap_ipv6_no_next_header.rs b/crates/pcap/tests/pcap_ipv6_no_next_header.rs new file mode 100644 index 000000000..b00848768 --- /dev/null +++ b/crates/pcap/tests/pcap_ipv6_no_next_header.rs @@ -0,0 +1,40 @@ +use craft_pcap::decode; + +/// Build a raw IPv6 packet with the given payload and Next Header field. +fn packet(next: u8, payload: &[u8]) -> Vec { + let mut packet = vec![0; 40]; + packet[0] = 0x60; + packet[4..6].copy_from_slice(&u16::try_from(payload.len()).unwrap().to_be_bytes()); + packet[6] = next; + packet[7] = 64; + packet.extend_from_slice(payload); + packet +} + +/// Both an empty packet and bytes after No Next Header have no transport record. +#[test] +fn no_next_header_has_no_transport() { + for payload in [b"".as_slice(), b"padding"] { + let decoded = decode(229, &packet(59, payload)); + assert_eq!(decoded.ip.unwrap().protocol, 59); + assert_eq!(decoded.protocols, ["raw", "ipv6"]); + assert!(decoded.transport.is_none()); + } +} + +/// Destination Options can also end the header chain. +#[test] +fn no_next_header_after_an_extension() { + let decoded = decode(229, &packet(60, &[59, 0, 0, 0, 0, 0, 0, 0, 1, 2])); + assert_eq!(decoded.ip.unwrap().protocol, 59); + assert!(decoded.transport.is_none()); +} + +/// UDP after the same extension still yields its transport and payload. +#[test] +fn udp_after_an_extension_still_decodes() { + let decoded = decode(229, &packet(60, &[17, 0, 0, 0, 0, 0, 0, 0, 0, 10, 0, 11, 0, 9, 0, 0, 42])); + let transport = decoded.transport.unwrap(); + assert_eq!(transport.protocol, "udp"); + assert_eq!((transport.src_port, transport.dst_port, transport.payload_len), (Some(10), Some(11), 1)); +} diff --git a/crates/pcap/tests/pcap_ipv6_version.rs b/crates/pcap/tests/pcap_ipv6_version.rs new file mode 100644 index 000000000..f69766321 --- /dev/null +++ b/crates/pcap/tests/pcap_ipv6_version.rs @@ -0,0 +1,56 @@ +#[path = "support/mod.rs"] +mod support; + +use craft_pcap::decode; +use support::{eth, ipv4_pkt}; + +fn raw_packets() -> (Vec, Vec) { + 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, ð(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, ð(0x86dd, &packet)).ip.unwrap().version, 6); +} diff --git a/crates/pcap/tests/pcap_tcp_ecn.rs b/crates/pcap/tests/pcap_tcp_ecn.rs new file mode 100644 index 000000000..278fba8fe --- /dev/null +++ b/crates/pcap/tests/pcap_tcp_ecn.rs @@ -0,0 +1,33 @@ +use craft_pcap::decode; + +/// Decode a raw IPv4 packet with a TCP header and the specified control bits. +fn flags_on_wire(bits: u8) -> String { + let mut packet = [0u8; 40]; + packet[0] = 0x45; + packet[2..4].copy_from_slice(&40u16.to_be_bytes()); + packet[8] = 64; + packet[9] = 6; + packet[20..24].copy_from_slice(&[0xc0, 0, 0x01, 0xbb]); + packet[32] = 0x50; + packet[33] = bits; + decode(228, &packet).transport.unwrap().tcp_flags.unwrap() +} + +/// An ECN-capable SYN shows both classic ECN flags. +#[test] +fn reports_ecn_setup_on_syn() { + assert_eq!(flags_on_wire(0xc2), "SYN,ECE,CWR"); +} + +/// The receiver and sender can signal ECE and CWR independently on ACKs. +#[test] +fn distinguishes_ecn_echo_and_window_reduction() { + assert_eq!(flags_on_wire(0x50), "ACK,ECE"); + assert_eq!(flags_on_wire(0x90), "ACK,CWR"); +} + +/// Existing non-ECN packets keep their flag strings. +#[test] +fn keeps_ordinary_ack_flags() { + assert_eq!(flags_on_wire(0x12), "SYN,ACK"); +} diff --git a/crates/pcap/tests/pcapng_simple_payload.rs b/crates/pcap/tests/pcapng_simple_payload.rs new file mode 100644 index 000000000..ee4743020 --- /dev/null +++ b/crates/pcap/tests/pcapng_simple_payload.rs @@ -0,0 +1,65 @@ +#[path = "support/mod.rs"] +mod support; + +use craft_pcap::Capture; +use support::{block, pcapng}; + +fn capture(original: u32, snaplen: u32, payload: &[u8]) -> Vec { + 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); +} diff --git a/crates/pcap/tests/regression_pcapng_framing.rs b/crates/pcap/tests/regression_pcapng_framing.rs new file mode 100644 index 000000000..1ba8d2878 --- /dev/null +++ b/crates/pcap/tests/regression_pcapng_framing.rs @@ -0,0 +1,80 @@ +#[path = "support/mod.rs"] +mod support; + +use craft_pcap::summarize; +use support::{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()); +} + +#[test] +fn a_skipped_packet_before_the_first_interface_preserves_later_frames() { + let original = pcapng(&sample_frames()); + let mut data = original[..28].to_vec(); + data.extend(block(3, &[0; 4])); + data.extend(&original[28..]); + let summary = summarize(&data, &|| false).unwrap(); + assert_eq!(summary.packets, 7); + assert!(summary.warnings.iter().any(|w| w.contains("undeclared interface"))); +} 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..e85c987aa --- /dev/null +++ b/crates/pcap/tests/regression_tcp_dns_framing.rs @@ -0,0 +1,70 @@ +#[path = "support/mod.rs"] +mod support; + +use craft_pcap::{Decoded, decode}; +use support::{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..d931f97b2 --- /dev/null +++ b/crates/pcap/tests/regression_tcp_header_length.rs @@ -0,0 +1,55 @@ +#[path = "support/mod.rs"] +mod support; + +use craft_pcap::{Decoded, decode}; +use support::{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..92a710fc4 --- /dev/null +++ b/crates/pcap/tests/regression_tls_bounds.rs @@ -0,0 +1,176 @@ +#[path = "support/mod.rs"] +mod support; + +use craft_pcap::{Decoded, decode}; +use support::{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); +} + +fn hello_with_vectors(session: &[u8], suites: &[u8], compression: &[u8], extensions: &[(u16, &[u8])]) -> craft_pcap::TlsHello { + let mut record = client_hello("unused.test"); + record.truncate(43); + record.push(session.len() as u8); + record.extend(session); + record.extend((suites.len() as u16).to_be_bytes()); + record.extend(suites); + record.push(compression.len() as u8); + record.extend(compression); + let mut ext = Vec::new(); + for (kind, bytes) in extensions { + ext.extend(kind.to_be_bytes()); + ext.extend((bytes.len() as u16).to_be_bytes()); + ext.extend(*bytes); + } + record.extend((ext.len() as u16).to_be_bytes()); + record.extend(ext); + let len = record.len(); + record[3..5].copy_from_slice(&((len - 5) as u16).to_be_bytes()); + record[6..9].copy_from_slice(&((len - 9) as u32).to_be_bytes()[1..]); + decoded(&record).tls.unwrap() +} + +#[test] +fn hello_vectors_must_have_protocol_lengths() { + assert!(!hello_with_vectors(&[0; 32], &[0, 47], &[0], &[]).partial); + assert!(hello_with_vectors(&[0; 33], &[0, 47], &[0], &[]).partial); + for suites in [&[][..], &[0, 47, 0][..]] { + assert!(hello_with_vectors(&[], suites, &[0], &[]).partial); + } + assert!(hello_with_vectors(&[], &[0, 47], &[], &[]).partial); + for (kind, empty) in [(0, &[0, 0][..]), (16, &[0, 0][..]), (43, &[0][..])] { + assert!(hello_with_vectors(&[], &[0, 47], &[0], &[(kind, empty)]).partial); + } +} + +#[test] +fn only_registered_grease_patterns_are_removed() { + let hello = hello_with_vectors(&[], &[0, 47], &[0], &[(43, &[6, 0x1a, 0x2a, 0x4a, 0x4a, 3, 4])]); + assert!(!hello.partial); + assert_eq!(hello.supported_versions, ["0x1a2a", "TLS 1.3"]); +} + +#[test] +fn duplicate_extensions_and_repeated_host_names_are_incomplete() { + let hello = hello_with_vectors(&[], &[0, 47], &[0], &[(43, &[2, 3, 4]), (43, &[2, 3, 3])]); + assert!(hello.partial); + assert_eq!(hello.supported_versions, ["TLS 1.3"]); + let hello = hello_with_vectors(&[], &[0, 47], &[0], &[(0, &[0, 8, 0, 0, 1, b'a', 0, 0, 1, b'b'])]); + assert!(hello.partial); + assert_eq!(hello.sni.as_deref(), Some("a")); +} + +#[test] +fn the_alpn_display_limit_does_not_hide_a_damaged_tail() { + let mut protocols = vec![0, 33]; + for _ in 0..16 { + protocols.extend([1, b'x']); + } + protocols.push(3); + let hello = hello_with_vectors(&[], &[0, 47], &[0], &[(16, &protocols)]); + assert_eq!(hello.alpn.len(), 16); + assert!(hello.partial); + protocols[1] = 34; + protocols.pop(); + protocols.extend([1, b'y']); + let hello = hello_with_vectors(&[], &[0, 47], &[0], &[(16, &protocols)]); + assert_eq!(hello.alpn.len(), 16); + assert!(!hello.partial); +} diff --git a/crates/pcap/tests/support/mod.rs b/crates/pcap/tests/support/mod.rs new file mode 100644 index 000000000..708864c83 --- /dev/null +++ b/crates/pcap/tests/support/mod.rs @@ -0,0 +1,173 @@ +#![allow(dead_code)] +//! Packet-capture fixtures: hand-built Ethernet/IPv4 frames (DNS, TCP handshake, TLS +//! ClientHello, HTTP request, ARP) written as classic pcap or pcapng. + +const CLASSIC_US: u32 = 0xa1b2_c3d4; +const NG_SHB: u32 = 0x0a0d_0d0a; +const NG_BOM: u32 = 0x1a2b_3c4d; + +pub fn eth(ethertype: u16, payload: &[u8]) -> Vec { + let mut f = vec![0xaa; 6]; + f.extend([0xbb; 6]); + f.extend(ethertype.to_be_bytes()); + f.extend(payload); + f +} + +pub fn ipv4_pkt(proto: u8, src: [u8; 4], dst: [u8; 4], payload: &[u8]) -> Vec { + let mut p = vec![0x45, 0, 0, 0, 0, 1, 0, 0, 64, proto, 0, 0]; + p.extend(src); + p.extend(dst); + let total = (20 + payload.len()) as u16; + p[2..4].copy_from_slice(&total.to_be_bytes()); + p.extend(payload); + p +} + +pub fn udp(sp: u16, dp: u16, payload: &[u8]) -> Vec { + let mut u = sp.to_be_bytes().to_vec(); + u.extend(dp.to_be_bytes()); + u.extend(((8 + payload.len()) as u16).to_be_bytes()); + u.extend([0, 0]); + u.extend(payload); + u +} + +pub fn tcp(sp: u16, dp: u16, flags: u8, payload: &[u8]) -> Vec { + let mut t = sp.to_be_bytes().to_vec(); + t.extend(dp.to_be_bytes()); + t.extend(1000u32.to_be_bytes()); + t.extend(0u32.to_be_bytes()); + t.extend([0x50, flags, 0xff, 0xff, 0, 0, 0, 0]); + t.extend(payload); + t +} + +/// DNS response for example.com A 93.184.216.34 (name compressed in the answer). +pub fn dns_response() -> Vec { + let mut m = vec![0x12, 0x34, 0x81, 0x80, 0, 1, 0, 1, 0, 0, 0, 0]; + m.extend(b"\x07example\x03com\x00\x00\x01\x00\x01"); + m.extend([0xc0, 12, 0, 1, 0, 1, 0, 0, 0x0e, 0x10, 0, 4, 93, 184, 216, 34]); + m +} + +pub fn dns_query() -> Vec { + let mut m = vec![0x12, 0x34, 0x01, 0x00, 0, 1, 0, 0, 0, 0, 0, 0]; + m.extend(b"\x07example\x03com\x00\x00\x01\x00\x01"); + m +} + +/// A TLS 1.3-style ClientHello naming `host` with ALPN h2 and http/1.1. +pub fn client_hello(host: &str) -> Vec { + let mut ext = Vec::new(); + let mut sni = vec![0u8]; + sni.extend((host.len() as u16).to_be_bytes()); + sni.extend(host.as_bytes()); + let mut sni_list = (sni.len() as u16).to_be_bytes().to_vec(); + sni_list.extend(sni); + ext.extend(0u16.to_be_bytes()); + ext.extend((sni_list.len() as u16).to_be_bytes()); + ext.extend(sni_list); + let alpn_list = b"\x02h2\x08http/1.1"; + ext.extend(16u16.to_be_bytes()); + ext.extend(((alpn_list.len() + 2) as u16).to_be_bytes()); + ext.extend((alpn_list.len() as u16).to_be_bytes()); + ext.extend(alpn_list); + ext.extend(43u16.to_be_bytes()); + ext.extend(5u16.to_be_bytes()); + ext.extend([4, 0x03, 0x04, 0x03, 0x03]); + let mut body = vec![3, 3]; + body.extend([7u8; 32]); + body.push(0); // session id + body.extend([0, 2, 0x13, 0x01]); // one cipher suite + body.extend([1, 0]); // compression + body.extend((ext.len() as u16).to_be_bytes()); + body.extend(ext); + let mut hs = vec![1]; + hs.extend(&(body.len() as u32).to_be_bytes()[1..]); + hs.extend(body); + let mut rec = vec![22, 3, 1]; + rec.extend((hs.len() as u16).to_be_bytes()); + rec.extend(hs); + rec +} + +/// Frames of a small conversation, as (link type 1) Ethernet frames. +pub fn sample_frames() -> Vec> { + let c = [192, 168, 1, 10]; + let dns_srv = [8, 8, 8, 8]; + let web = [93, 184, 216, 34]; + vec![ + eth(0x0800, &ipv4_pkt(17, c, dns_srv, &udp(50000, 53, &dns_query()))), + eth(0x0800, &ipv4_pkt(17, dns_srv, c, &udp(53, 50000, &dns_response()))), + eth(0x0800, &ipv4_pkt(6, c, web, &tcp(50001, 443, 0x02, &[]))), + eth(0x0800, &ipv4_pkt(6, web, c, &tcp(443, 50001, 0x12, &[]))), + eth(0x0800, &ipv4_pkt(6, c, web, &tcp(50001, 443, 0x18, &client_hello("example.com")))), + eth( + 0x0800, + &ipv4_pkt( + 6, + c, + web, + &tcp(50002, 80, 0x18, b"GET http://user:pw@example.com/a?b=1 HTTP/1.1\r\nHost: example.com\r\nUser-Agent: t\r\n\r\n"), + ), + ), + eth(0x0806, &[0u8; 28]), + ] +} + +/// A classic little-endian microsecond pcap of `frames`. +pub fn pcap(frames: &[Vec]) -> Vec { + let mut out = CLASSIC_US.to_le_bytes().to_vec(); + out.extend(2u16.to_le_bytes()); + out.extend(4u16.to_le_bytes()); + out.extend([0u8; 8]); + out.extend(65535u32.to_le_bytes()); + out.extend(1u32.to_le_bytes()); + for (i, f) in frames.iter().enumerate() { + out.extend((1_700_000_000u32 + i as u32).to_le_bytes()); + out.extend(500u32.to_le_bytes()); + out.extend((f.len() as u32).to_le_bytes()); + out.extend((f.len() as u32).to_le_bytes()); + out.extend(f); + } + out +} + +pub fn block(t: u32, body: &[u8]) -> Vec { + let mut body = body.to_vec(); + while !body.len().is_multiple_of(4) { + body.push(0); + } + let len = (body.len() + 12) as u32; + let mut b = t.to_le_bytes().to_vec(); + b.extend(len.to_le_bytes()); + b.extend(body); + b.extend(len.to_le_bytes()); + b +} + +/// A little-endian pcapng with one Ethernet interface at nanosecond resolution. +pub fn pcapng(frames: &[Vec]) -> Vec { + let mut shb = NG_BOM.to_le_bytes().to_vec(); + shb.extend(1u16.to_le_bytes()); + shb.extend(0u16.to_le_bytes()); + shb.extend((-1i64).to_le_bytes()); + let mut out = block(NG_SHB, &shb); + let mut idb = 1u16.to_le_bytes().to_vec(); + idb.extend([0, 0]); + idb.extend(0u32.to_le_bytes()); + idb.extend([9, 0, 1, 0, 9, 0, 0, 0, 0, 0, 0, 0]); // if_tsresol = 9, end of options + out.extend(block(1, &idb)); + for (i, f) in frames.iter().enumerate() { + let ts: u64 = 1_700_000_000_000_000_000 + i as u64; + let mut epb = 0u32.to_le_bytes().to_vec(); + epb.extend(((ts >> 32) as u32).to_le_bytes()); + epb.extend((ts as u32).to_le_bytes()); + epb.extend((f.len() as u32).to_le_bytes()); + epb.extend((f.len() as u32).to_le_bytes()); + epb.extend(f); + out.extend(block(6, &epb)); + } + out +}