diff --git a/crates/pcap/src/lib.rs b/crates/pcap/src/lib.rs index 809908396..d82dc8fea 100644 --- a/crates/pcap/src/lib.rs +++ b/crates/pcap/src/lib.rs @@ -12,7 +12,7 @@ use serde::Serialize; use std::collections::{BTreeMap, BTreeSet, HashMap}; use std::net::{IpAddr, Ipv4Addr, Ipv6Addr}; -/// Most frames read from one capture. +/// Most frames and rejected simple packet blocks read from one capture. pub const MAX_PACKETS: u64 = 5_000_000; /// Most flows tracked; later flows are counted but get no id. pub const MAX_FLOWS: usize = 100_000; @@ -89,6 +89,8 @@ pub struct Capture<'a> { /// The walk stopped at `MAX_PACKETS`. pub truncated: bool, count: u64, + rejected_simple_blocks: u64, + rejected_simple_reported: bool, } fn rd_u16(r: &Reader<'_>, le: bool, off: usize) -> Option { @@ -126,6 +128,8 @@ impl<'a> Capture<'a> { warnings: Vec::new(), truncated: false, count: 0, + rejected_simple_blocks: 0, + rejected_simple_reported: false, }; let classic = |le: bool, nanos: bool| -> Result<(Kind, String, Interface), FormatError> { let major = rd_u16(&r, le, 4).ok_or_else(|| FormatError::Truncated("pcap header".into()))?; @@ -168,6 +172,26 @@ impl<'a> Capture<'a> { None } + fn packet_limit_reached(&mut self) -> bool { + if self.count.saturating_add(self.rejected_simple_blocks) < MAX_PACKETS { + return false; + } + if !self.truncated && self.pos < self.data.len() { + self.truncated = true; + self.warnings.push(format!("stopped after {MAX_PACKETS} packet records")); + } + true + } + + fn report_rejected_simple_blocks(&mut self) { + if self.rejected_simple_blocks > 0 && !self.rejected_simple_reported { + let n = self.rejected_simple_blocks; + let suffix = if n == 1 { "" } else { "s" }; + self.warnings.push(format!("skipped {n} simple packet block{suffix} with inconsistent captured lengths")); + self.rejected_simple_reported = true; + } + } + fn ts(&self, iface: usize, units: u64) -> Option { let (base, exp) = self.interfaces.get(iface).map(|i| i.tsresol).unwrap_or((10, 6)); let offset_s = self.interfaces.get(iface).map(|i| i.tsoffset).unwrap_or(0); @@ -211,6 +235,9 @@ impl<'a> Capture<'a> { fn next_ng(&mut self, mut le: bool) -> Option> { loop { + if self.packet_limit_reached() { + return None; + } let r = Reader::new(self.data); let p = self.pos; if p >= self.data.len() { @@ -312,7 +339,11 @@ impl<'a> Capture<'a> { let iface = self.section_base; let snap = self.interfaces.get(iface).map(|i| i.snaplen).filter(|&s| s > 0).unwrap_or(u32::MAX); let room = body_end.saturating_sub(body + 4); - let cap = (orig.min(snap) as usize).min(room); + let cap = orig.min(snap) as usize; + if cap.checked_add(3).map(|n| n & !3) != Some(room) { + self.rejected_simple_blocks += 1; + continue; + } let Some(data) = r.slice(body + 4, cap) else { continue }; if iface >= self.interfaces.len() { continue; @@ -338,17 +369,18 @@ impl<'a> Iterator for Capture<'a> { type Item = Frame<'a>; fn next(&mut self) -> Option> { - if self.count >= MAX_PACKETS { - if !self.truncated && self.pos < self.data.len() { - self.truncated = true; - self.warnings.push(format!("stopped after {MAX_PACKETS} frames")); + let frame = if self.packet_limit_reached() { + None + } else { + match self.kind { + Kind::Classic { le, nanos } => self.next_classic(le, nanos), + Kind::Ng { le } => self.next_ng(le), } - return None; - } - match self.kind { - Kind::Classic { le, nanos } => self.next_classic(le, nanos), - Kind::Ng { le } => self.next_ng(le), + }; + if frame.is_none() { + self.report_rejected_simple_blocks(); } + frame } } @@ -535,7 +567,12 @@ pub fn decode(link_type: u32, data: &[u8]) -> Decoded { } 12 | 14 | 101 | 228 | 229 => { d.protocols.push("raw"); - (r.u8(0).map(|b| if b >> 4 == 6 { 0x86dd } else { 0x0800 }), 0) + let ethertype = match link_type { + 228 => Some(0x0800), + 229 => Some(0x86dd), + _ => r.u8(0).map(|b| if b >> 4 == 6 { 0x86dd } else { 0x0800 }), + }; + (ethertype, 0) } _ => { d.note = Some(format!("link type {link_type} ({}) is not decoded", link_name(link_type))); @@ -560,11 +597,15 @@ fn ipv4(p: &[u8], d: &mut Decoded) { return; }; let ihl = usize::from(vihl & 0x0f) * 4; - let (Some(src), Some(dst)) = (r.slice(12, 4), r.slice(16, 4)) else { return }; - if vihl >> 4 != 4 || ihl < 20 { + if vihl >> 4 != 4 || ihl < 20 || usize::from(total) < ihl { d.note = Some("not a valid IPv4 header".into()); return; } + if r.slice(0, ihl).is_none() { + d.note = Some("IPv4 header cut short".into()); + return; + } + let (Some(src), Some(dst)) = (r.slice(12, 4), r.slice(16, 4)) else { return }; d.protocols.push("ipv4"); let ip4 = |b: &[u8]| { IpAddr::V4(Ipv4Addr::new( @@ -576,7 +617,7 @@ fn ipv4(p: &[u8], d: &mut Decoded) { }; let fragment = frag & 0x1fff != 0; d.ip = Some(IpInfo { version: 4, src: ip4(src), dst: ip4(dst), protocol: proto, ttl, fragment }); - let end = usize::from(total).clamp(ihl, p.len().max(ihl)); + let end = usize::from(total).min(p.len()); let body = p.get(ihl..end).unwrap_or(&[]); if fragment { d.note = Some("IPv4 fragment (transport header is in the first fragment)".into()); @@ -591,6 +632,10 @@ fn ipv6(p: &[u8], d: &mut Decoded) { d.note = Some("IPv6 header cut short".into()); return; }; + if r.u8(0).is_none_or(|version| version >> 4 != 6) { + d.note = Some("not a valid IPv6 header".into()); + return; + } d.protocols.push("ipv6"); let ip6 = |b: &[u8]| IpAddr::V6(Ipv6Addr::from(<[u8; 16]>::try_from(b).unwrap_or([0; 16]))); let end = (40 + usize::from(plen)).min(p.len()); @@ -616,6 +661,9 @@ fn ipv6(p: &[u8], d: &mut Decoded) { next = n; fragment = fo & 0xfff8 != 0; off += 8; + if fragment { + break; + } } 51 => { let (Some(n), Some(l)) = (payload_reader.u8(off), payload_reader.u8(off + 1)) else { break }; @@ -756,14 +804,29 @@ pub fn qtype_name(t: u16) -> String { } } -/// A (possibly compressed) DNS name at `off`; returns the name and the offset after it. -fn dns_name(msg: &[u8], mut off: usize) -> Option<(String, usize)> { +fn dns_sd_service_label(label: &[u8]) -> bool { + let Some(name) = label.strip_prefix(b"_") else { return false }; + // RFC 6763 §7 / RFC 6335 §5.1, excluding the leading underscore. + (1..=15).contains(&name.len()) + && name.first().is_some_and(u8::is_ascii_alphanumeric) + && name.last().is_some_and(u8::is_ascii_alphanumeric) + && name.iter().all(|c| c.is_ascii_alphanumeric() || *c == b'-') + && name.iter().any(u8::is_ascii_alphabetic) + && !name.windows(2).any(|pair| pair == b"--") +} + +/// A DNS name, the offset after it, and whether its wire labels name a DNS-SD instance. +fn dns_name(msg: &[u8], mut off: usize) -> Option<(String, usize, bool)> { let mut out = String::new(); + // Count the expanded wire name, including label lengths and the terminating root. + let mut wire_len = 1usize; let mut after: Option = None; + let mut labels = 0; + let mut service_instance = false; for _ in 0..128 { let len = *msg.get(off)?; match len { - 0 => return Some((if out.is_empty() { ".".into() } else { out }, after.unwrap_or(off + 1))), + 0 => return Some((if out.is_empty() { ".".into() } else { out }, after.unwrap_or(off + 1), labels >= 4 && service_instance)), l if l & 0xc0 == 0xc0 => { let ptr = usize::from(u16::from_be_bytes([l & 0x3f, *msg.get(off + 1)?])); after.get_or_insert(off + 2); @@ -774,13 +837,22 @@ fn dns_name(msg: &[u8], mut off: usize) -> Option<(String, usize)> { } l if l < 64 => { let label = msg.get(off + 1..off + 1 + usize::from(l))?; + wire_len += 1 + label.len(); + if wire_len > 255 { + return None; + } + // Match Instance / _service / _tcp|_udp / Domain before rendering: + // a literal dot inside one wire label is not a label boundary. + match labels { + 1 => service_instance = dns_sd_service_label(label), + 2 => service_instance &= label.eq_ignore_ascii_case(b"_tcp") || label.eq_ignore_ascii_case(b"_udp"), + _ => {} + } + labels += 1; if !out.is_empty() { out.push('.'); } out.extend(label.iter().map(|&c| if c.is_ascii_graphic() { char::from(c) } else { '?' })); - if out.len() > 255 { - return None; - } off += 1 + usize::from(l); } _ => return None, @@ -789,22 +861,26 @@ fn dns_name(msg: &[u8], mut off: usize) -> Option<(String, usize)> { None } +/// Decode a bounded set of DNS questions and answer/prerequisite records from one message. +/// Preserve complete entries before malformed data and mark the message incomplete. fn dns(msg: &[u8], d: &mut Decoded, label: &'static str) { let r = Reader::new(msg); let (Some(id), Some(flags), Some(qd), Some(an)) = (r.u16_be(0), r.u16_be(2), r.u16_be(4), r.u16_be(6)) else { return }; + let opcode = (flags >> 11) & 0xf; // Sanity: opcode 0–6 and no absurd counts, so random payload on port 53 isn't misread. - if (flags >> 11) & 0xf > 6 || qd > 64 || qd == 0 && an == 0 { + if opcode > 6 || qd > 64 || qd == 0 && an == 0 { return; } d.protocols.push(label); let mut out = Dns { id, response: flags & 0x8000 != 0, rcode: (flags & 0xf) as u8, questions: Vec::new(), answers: Vec::new(), incomplete: false }; let mut off = 12usize; for _ in 0..qd { - let Some((name, next)) = dns_name(msg, off) else { + let Some((name, next, _)) = dns_name(msg, off) else { out.incomplete = true; break; }; - let Some(qt) = r.u16_be(next) else { + // The class is not displayed, but both two-byte fields must be present. + let (Some(qt), Some(_class)) = (r.u16_be(next), r.u16_be(next + 2)) else { out.incomplete = true; break; }; @@ -813,11 +889,11 @@ fn dns(msg: &[u8], d: &mut Decoded, label: &'static str) { } if !out.incomplete { for _ in 0..an.min(64) { - let Some((name, next)) = dns_name(msg, off) else { + let Some((name, next, service_instance)) = dns_name(msg, off) else { out.incomplete = true; break; }; - let (Some(rt), Some(ttl), Some(rdlen)) = (r.u16_be(next), r.u32_be(next + 4), r.u16_be(next + 8)) else { + let (Some(rt), Some(class), Some(ttl), Some(rdlen)) = (r.u16_be(next), r.u16_be(next + 2), r.u32_be(next + 4), r.u16_be(next + 8)) else { out.incomplete = true; break; }; @@ -835,31 +911,54 @@ fn dns(msg: &[u8], d: &mut Decoded, label: &'static str) { ) .to_string(), (28, 16) => Ipv6Addr::from(<[u8; 16]>::try_from(rd).unwrap_or([0; 16])).to_string(), - (2 | 5 | 12, _) => dns_name(msg, rd_off).map(|(n, _)| n).unwrap_or_default(), - (15, _) => dns_name(msg, rd_off + 2).map(|(n, _)| n).unwrap_or_default(), + (2 | 5 | 12 | 15, _) => { + // RFC 2136 prerequisites can name an RRset without carrying its value. + if rd.is_empty() && opcode == 5 && matches!(class, 254 | 255) && ttl == 0 { + String::new() + } else { + let end = rd_off + rd.len(); + let start = rd_off + if rt == 15 { 2 } else { 0 }; + // Keep earlier bytes available to compression pointers, but the encoded + // name itself must fit the record and account for all of its RDATA. + let Some((name, _, _)) = dns_name(msg.get(..end).unwrap_or(&[]), start).filter(|(_, after, _)| *after == end) else { + out.incomplete = true; + break; + }; + name + } + } (16, _) => { - // RFC 1035 §3.3.14: one TXT RDATA holds any number of + // RFC 1035 §3.3.14: one TXT RDATA holds one or more // length-prefixed character strings, and a zero-length // string does not end the record. Consumers join them all // (RFC 7208 §3.3), so keep every string instead of the // first one and skip the rest of the RDATA. let mut txt = String::new(); let mut pos = 0; + // UPDATE's answer section holds prerequisites. ANY/NONE + // prerequisites use empty RDATA and zero TTL (RFC 2136 §2.4). + let empty_prerequisite = opcode == 5 && matches!(class, 254 | 255) && ttl == 0; + // DNS-SD receivers treat empty RDATA as an empty string + // (RFC 6763 §6.1), for both multicast and unicast DNS. + let empty_service_txt = opcode == 0 && service_instance; + out.incomplete |= rd.is_empty() && !empty_prerequisite && !empty_service_txt; while let Some(&len) = rd.get(pos) { let len = usize::from(len); - let end = (pos + 1).saturating_add(len).min(rd.len()); - match rd.get(pos + 1..end) { - Some(part) => { - txt.push_str(&String::from_utf8_lossy(part)); - pos = end; - } - None => break, - } + let end = pos + 1 + len; + let Some(part) = rd.get(pos + 1..end) else { + out.incomplete = true; + break; + }; + txt.push_str(&String::from_utf8_lossy(part)); + pos = end; } txt } (_, n) => format!("<{n} bytes>"), }; + if out.incomplete { + break; + } out.answers.push(DnsAnswer { name, rtype: qtype_name(rt), ttl, value }); off = rd_off + usize::from(rdlen); } @@ -896,12 +995,21 @@ fn tcp_app(p: &[u8], d: &mut Decoded) { && METHODS.contains(&m) && v.starts_with("HTTP/1.") { - let lower = String::from_utf8_lossy(head).to_ascii_lowercase(); - let host = lower.find("\r\nhost:").and_then(|i| { - let start = i + 7; - let raw = String::from_utf8_lossy(head.get(start..)?).into_owned(); - Some(raw.split("\r\n").next().unwrap_or("").trim().to_string()) - }); + let mut remaining = head.get(line_end + 2..).unwrap_or(&[]); + let mut host = None; + while let Some(end) = remaining.windows(2).position(|w| w == b"\r\n") { + let field = remaining.get(..end).unwrap_or(&[]); + if field.is_empty() { + break; + } + if let Some(colon) = field.iter().position(|&b| b == b':') + && field.get(..colon).is_some_and(|name| name.eq_ignore_ascii_case(b"host")) + { + host = field.get(colon + 1..).map(|value| String::from_utf8_lossy(value).trim().to_string()); + break; + } + remaining = remaining.get(end + 2..).unwrap_or(&[]); + } d.protocols.push("http"); d.http = Some(Http { kind: "request", method: Some(m.to_string()), target: Some(strip_userinfo(t)), status: None, version: v.to_string(), host }); return; @@ -1270,8 +1378,9 @@ pub fn summarize(data: &[u8], cancelled: &dyn Fn() -> bool) -> Result 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..88b7315b7 --- /dev/null +++ b/crates/pcap/tests/dns_rdata_names.rs @@ -0,0 +1,184 @@ +use craft_anything_formats::pcap::{decode, summarize}; +use craft_anything_testkit::pcap::{dns_query, eth, ipv4_pkt, pcap, udp}; + +fn response(record_type: u16, rdata: &[u8], declared_length: usize) -> Vec { + 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"); + } + } +} 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..f16c89387 --- /dev/null +++ b/crates/pcap/tests/pcap_dns_name_limit.rs @@ -0,0 +1,151 @@ +use craft_anything_formats::pcap::{Dns, decode}; +use craft_anything_testkit::pcap::{ipv4_pkt, udp}; + +fn query(last: usize, compressed: bool) -> Dns { + let mut msg = vec![0, 1, 1, 0, 0, if compressed { 2 } else { 1 }, 0, 0, 0, 0, 0, 0]; + for len in [63, 63, 63, last] { + msg.push(len as u8); + msg.extend(vec![b'a'; len]); + } + msg.extend([0, 0, 1, 0, 1]); + if compressed { + msg.extend([0xc0, 12, 0, 1, 0, 1]); + } + decode(101, &ipv4_pkt(17, [1; 4], [2; 4], &udp(100, 53, &msg))).dns.unwrap() +} + +#[test] +fn label_lengths_and_the_root_octet_count_towards_the_dns_limit() { + for last in [62, 63] { + let dns = query(last, false); + assert!(dns.incomplete); + assert!(dns.questions.is_empty()); + } +} + +#[test] +fn a_255_octet_name_is_valid_in_plain_and_compressed_form() { + for compressed in [false, true] { + let dns = query(61, compressed); + assert!(!dns.incomplete); + assert_eq!(dns.questions.len(), if compressed { 2 } else { 1 }); + assert_eq!(dns.questions[0].name.len(), 253); + } +} + +fn prefixed_pointer(last: usize, answer_type: Option) -> 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"); + } +} 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..a90207b21 --- /dev/null +++ b/crates/pcap/tests/pcap_dns_txt_lengths.rs @@ -0,0 +1,196 @@ +use craft_anything_formats::pcap::{Dns, decode}; +use craft_anything_testkit::pcap::{ipv4_pkt, udp}; + +fn response(data: &[u8]) -> Dns { + let mut msg = vec![0, 1, 0x81, 0x80, 0, 0, 0, 1, 0, 0, 0, 0]; + msg.extend([0, 0, 16, 0, 1, 0, 0, 0, 60]); + msg.extend((data.len() as u16).to_be_bytes()); + msg.extend(data); + decode(101, &ipv4_pkt(17, [1; 4], [2; 4], &udp(53, 100, &msg))).dns.unwrap() +} + +fn prerequisites(flags: u16, class: u16, ttl: u32, data: &[u8]) -> Dns { + let mut msg = vec![0, 1]; + msg.extend(flags.to_be_bytes()); + msg.extend([0, 1, 0, 2, 0, 0, 0, 0]); + // UPDATE's zone section has the question layout: example.test, SOA, IN. + msg.extend(b"\x07example\x04test\x00\x00\x06\x00\x01"); + msg.extend([0xc0, 12, 0, 16]); + msg.extend(class.to_be_bytes()); + msg.extend(ttl.to_be_bytes()); + msg.extend((data.len() as u16).to_be_bytes()); + msg.extend(data); + // Different owners let NONE and value-dependent prerequisites hold together. + // The following TXT record must also survive. + msg.extend(b"\x05after"); + msg.extend([0xc0, 12, 0, 16, 0, 1, 0, 0, 0, 0, 0, 3, 2, b'o', b'k']); + decode(101, &ipv4_pkt(17, [1; 4], [2; 4], &udp(100, 53, &msg))).dns.unwrap() +} + +fn named_txt(owner: &[&[u8]], data: &[u8], port: u16, flags: u16, class: u16, ttl: u32, compressed: bool) -> Dns { + let mut name = Vec::new(); + for label in owner { + name.push(u8::try_from(label.len()).unwrap()); + name.extend(*label); + } + name.push(0); + let mut msg = vec![0, 1]; + msg.extend(flags.to_be_bytes()); + msg.extend([0, 1, 0, 2, 0, 0, 0, 0]); + msg.extend(&name); + msg.extend([0, 16, 0, 1]); + if compressed { + msg.extend([0xc0, 12]); + } else { + msg.extend(&name); + } + msg.extend([0, 16]); + msg.extend(class.to_be_bytes()); + msg.extend(ttl.to_be_bytes()); + msg.extend(u16::try_from(data.len()).unwrap().to_be_bytes()); + msg.extend(data); + // The next answer must survive an empty DNS-SD TXT record. + msg.extend([0xc0, 12, 0, 1, 0, 1, 0, 0, 0, 60, 0, 4, 127, 0, 0, 1]); + decode(101, &ipv4_pkt(17, [1; 4], [2; 4], &udp(port, 100, &msg))).dns.unwrap() +} + +fn assert_empty_txt_and_following_answer(dns: Dns) { + assert!(!dns.incomplete); + assert_eq!(dns.answers.len(), 2); + assert_eq!(dns.answers[0].rtype, "TXT"); + assert_eq!(dns.answers[0].value, ""); + assert_eq!(dns.answers[1].value, "127.0.0.1"); +} + +#[test] +fn empty_dns_sd_txt_preserves_following_answers() { + let multicast: &[&[u8]] = &[b"Printer", b"_ipp", b"_tcp", b"local"]; + let unicast: &[&[u8]] = &[b"Printer", b"_ipp", b"_tcp", b"example", b"test"]; + for (port, owner) in [(5353, multicast), (53, unicast)] { + assert_empty_txt_and_following_answer(named_txt(owner, &[], port, 0x8400, 1, 60, false)); + } +} + +#[test] +fn empty_dns_sd_txt_is_valid_in_mdns_known_answers_and_cache_flush_records() { + let owner: &[&[u8]] = &[b"Printer", b"_ipp", b"_tcp", b"local"]; + // Queries may contain known answers; the cache-flush bit belongs to CLASS. + for (flags, class) in [(0, 1), (0x8400, 0x8001)] { + assert_empty_txt_and_following_answer(named_txt(owner, &[], 5353, flags, class, 60, false)); + } +} + +#[test] +fn dns_sd_owner_preserves_wire_labels_case_and_compression() { + let owner: &[&[u8]] = &[b"Printer.with dots", b"_Ab-12", b"_UdP", b"example", b"test"]; + for compressed in [false, true] { + assert_empty_txt_and_following_answer(named_txt(owner, &[], 53, 0x8180, 1, 60, compressed)); + } +} + +#[test] +fn other_empty_txt_owners_are_not_dns_sd_instances() { + let owners: &[&[&[u8]]] = &[ + &[b"Printer", b"local"], + &[b"Printer._ipp._tcp", b"local"], + &[b"Printer", b"_ipp._tcp", b"_tcp", b"local"], + &[b"_ipp", b"_tcp", b"local"], + &[b"Printer", b"_ipp", b"_tcp"], + &[b"Printer", b"_ipp", b"_other", b"local"], + &[b"Printer", b"_123", b"_tcp", b"local"], + &[b"Printer", b"_bad--name", b"_tcp", b"local"], + ]; + for owner in owners { + let dns = named_txt(owner, &[], 5353, 0x8400, 1, 60, false); + assert!(dns.incomplete, "owner {owner:?}"); + assert!(dns.answers.is_empty()); + } +} + +#[test] +fn dns_sd_txt_still_rejects_truncated_nonempty_strings() { + let owner: &[&[u8]] = &[b"Printer", b"_ipp", b"_tcp", b"local"]; + for data in [&b"\x02x"[..], &b"\x00\x04x"[..]] { + let dns = named_txt(owner, data, 5353, 0x8400, 0x8001, 60, true); + assert!(dns.incomplete); + assert!(dns.answers.is_empty()); + } +} + +#[test] +fn dns_sd_owner_does_not_relax_update_prerequisite_classes() { + let owner: &[&[u8]] = &[b"Printer", b"_ipp", b"_tcp", b"example", b"test"]; + let dns = named_txt(owner, &[], 53, 5 << 11, 1, 0, true); + assert!(dns.incomplete); + assert!(dns.answers.is_empty()); + for class in [254, 255] { + assert_empty_txt_and_following_answer(named_txt(owner, &[], 53, 5 << 11, class, 0, true)); + } +} + +#[test] +fn empty_update_prerequisites_preserve_following_records() { + for class in [254, 255] { + let dns = prerequisites(5 << 11, class, 0, &[]); + assert!(!dns.incomplete, "class {class}"); + assert_eq!(dns.answers.len(), 2); + assert_eq!(dns.answers[0].name, "example.test"); + assert_eq!(dns.answers[0].value, ""); + assert_eq!(dns.answers[1].name, "after.example.test"); + assert_eq!(dns.answers[1].value, "ok"); + } +} + +#[test] +fn empty_txt_rdata_requires_update_and_a_prerequisite_class() { + assert!(response(&[]).incomplete); + for (flags, class, ttl) in [(0x8180, 254, 0), (0x8180, 255, 0), (5 << 11, 1, 0), (5 << 11, 254, 60), (5 << 11, 255, 60)] { + let dns = prerequisites(flags, class, ttl, &[]); + assert!(dns.incomplete, "flags {flags:#x}, class {class}, ttl {ttl}"); + assert!(dns.answers.is_empty()); + } + for opcode in [1, 2, 3, 4, 6] { + for class in [254, 255] { + let dns = prerequisites(opcode << 11, class, 0, &[]); + assert!(dns.incomplete, "opcode {opcode}, class {class}"); + assert!(dns.answers.is_empty()); + } + } +} + +#[test] +fn update_prerequisite_classes_do_not_allow_truncated_strings() { + for class in [254, 255] { + let dns = prerequisites(5 << 11, class, 0, b"\x02x"); + assert!(dns.incomplete); + assert!(dns.answers.is_empty()); + } +} + +#[test] +fn truncated_txt_strings_are_not_complete_answers() { + for data in [&b"\x05abc"[..], &b"\x02ok\x04x"[..], &b"\x01"[..]] { + let dns = response(data); + assert!(dns.incomplete); + assert!(dns.answers.is_empty()); + } +} + +#[test] +fn empty_and_multiple_complete_strings_remain_valid() { + for (data, expected) in [(&b"\x00"[..], ""), (&b"\x00\x02ok\x01!"[..], "ok!")] { + let dns = response(data); + assert!(!dns.incomplete); + assert_eq!(dns.answers[0].value, expected); + } +} + +#[test] +fn value_dependent_update_accepts_an_empty_character_string() { + let dns = prerequisites(5 << 11, 1, 0, b"\x00"); + assert!(!dns.incomplete); + assert_eq!(dns.answers.len(), 2); + assert_eq!(dns.answers[0].value, ""); + assert_eq!(dns.answers[1].name, "after.example.test"); + assert_eq!(dns.answers[1].value, "ok"); +} 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..96b6c128b --- /dev/null +++ b/crates/pcap/tests/pcap_flow_time_range.rs @@ -0,0 +1,36 @@ +use craft_anything_formats::pcap::summarize; +use craft_anything_testkit::pcap::{block, eth, ipv4_pkt, pcap, pcapng, udp}; + +fn frame() -> Vec { + 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..13b6955d8 --- /dev/null +++ b/crates/pcap/tests/pcap_http_host_boundary.rs @@ -0,0 +1,24 @@ +use craft_anything_formats::pcap::{Http, decode}; +use craft_anything_testkit::pcap::{ipv4_pkt, tcp}; + +fn request(data: &[u8]) -> Http { + decode(101, &ipv4_pkt(6, [1; 4], [2; 4], &tcp(100, 80, 0x18, data))).http.unwrap() +} + +#[test] +fn a_host_shaped_line_in_the_body_is_not_a_request_header() { + let http = request(b"POST / HTTP/1.1\r\nContent-Length: 22\r\n\r\nbody\r\nHost: forged.test\r\n"); + assert!(http.host.is_none()); +} + +#[test] +fn invalid_utf8_before_host_does_not_shift_header_byte_offsets() { + let http = request(b"GET / HTTP/1.1\r\nX-Data: \xff\r\nHoSt:\tReal.test \t\r\n\r\n"); + assert_eq!(http.host.as_deref(), Some("Real.test")); +} + +#[test] +fn host_requires_a_complete_header_line_and_keeps_its_spelling() { + assert!(request(b"GET / HTTP/1.1\r\nHost: cut").host.is_none()); + assert_eq!(request(b"GET / HTTP/1.1\r\nHost: Real.test\r\n\r\n").host.as_deref(), Some("Real.test")); +} diff --git a/crates/pcap/tests/pcap_ipv4_lengths.rs b/crates/pcap/tests/pcap_ipv4_lengths.rs new file mode 100644 index 000000000..21f1f6eac --- /dev/null +++ b/crates/pcap/tests/pcap_ipv4_lengths.rs @@ -0,0 +1,57 @@ +use craft_anything_formats::pcap::decode; +use craft_anything_testkit::pcap::{ipv4_pkt, udp}; + +#[test] +fn incomplete_ipv4_base_headers_explain_why_decoding_stopped() { + let packet = ipv4_pkt(17, [1; 4], [2; 4], &[]); + for captured in 10..20 { + let decoded = decode(101, &packet[..captured]); + assert!(decoded.ip.is_none(), "captured {captured} bytes"); + assert!(decoded.transport.is_none(), "captured {captured} bytes"); + assert_eq!(decoded.note.as_deref(), Some("IPv4 header cut short"), "captured {captured} bytes"); + } +} + +#[test] +fn an_ipv4_total_length_cannot_be_shorter_than_its_header() { + for total in [0u16, 19, 23] { + let mut packet = ipv4_pkt(17, [1, 2, 3, 4], [5, 6, 7, 8], &udp(100, 200, b"body")); + packet[0] = 0x46; + packet[2..4].copy_from_slice(&total.to_be_bytes()); + let decoded = decode(101, &packet); + assert!(decoded.ip.is_none()); + assert!(decoded.transport.is_none()); + assert!(decoded.note.is_some()); + } +} + +#[test] +fn missing_ipv4_options_do_not_form_a_complete_ip_header() { + let mut packet = ipv4_pkt(17, [1; 4], [2; 4], &[]); + packet[0] = 0x46; + packet[2..4].copy_from_slice(&24u16.to_be_bytes()); + let decoded = decode(101, &packet); + assert!(decoded.ip.is_none()); + assert!(decoded.note.is_some()); +} + +#[test] +fn complete_options_and_truncated_transport_keep_their_valid_fields() { + let body = udp(100, 200, b"body"); + let mut payload = vec![0; 4]; + payload.extend(body); + let mut packet = ipv4_pkt(17, [1; 4], [2; 4], &payload); + packet[0] = 0x46; + assert_eq!(decode(101, &packet).transport.unwrap().payload_len, 4); + packet.truncate(34); + let decoded = decode(101, &packet); + assert!(decoded.ip.is_some()); + let transport = decoded.transport.unwrap(); + assert_eq!(transport.src_port, Some(100)); + assert_eq!(transport.dst_port, Some(200)); + assert_eq!(transport.payload_len, 2); + packet.truncate(28); + let decoded = decode(101, &packet); + assert!(decoded.ip.is_some()); + assert_eq!(decoded.transport.unwrap().src_port, Some(100)); +} diff --git a/crates/pcap/tests/pcap_ipv6_fragments.rs b/crates/pcap/tests/pcap_ipv6_fragments.rs new file mode 100644 index 000000000..8f82257d1 --- /dev/null +++ b/crates/pcap/tests/pcap_ipv6_fragments.rs @@ -0,0 +1,40 @@ +use craft_anything_formats::pcap::decode; +use craft_anything_testkit::pcap::{eth, udp}; + +fn packet(offset: u16, next: u8, payload: &[u8]) -> Vec { + 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_version.rs b/crates/pcap/tests/pcap_ipv6_version.rs new file mode 100644 index 000000000..4e4b25dc3 --- /dev/null +++ b/crates/pcap/tests/pcap_ipv6_version.rs @@ -0,0 +1,53 @@ +use craft_anything_formats::pcap::decode; +use craft_anything_testkit::pcap::{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/pcapng_simple_payload.rs b/crates/pcap/tests/pcapng_simple_payload.rs new file mode 100644 index 000000000..c61f6c70a --- /dev/null +++ b/crates/pcap/tests/pcapng_simple_payload.rs @@ -0,0 +1,62 @@ +use craft_anything_formats::pcap::Capture; +use craft_anything_testkit::pcap::{block, pcapng}; + +fn capture(original: u32, snaplen: u32, payload: &[u8]) -> Vec { + 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); +}