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