Merge pull request #2047 from storytold/feat/pcap-inspection

Share PCAP and PCAPNG capture and per-frame protocol inspection
This commit is contained in:
Dylan M. Taylor authored and GitHub committed 2026-11-17 14:06:29 -05:00
commit d9f0ada8b3
25 files changed
+4021 -7

No files matched your search

+3
View File
@@ -138,6 +138,9 @@ Sanitization, animation fitting and numeric output policy remain caller-owned.
`crates/jsonc` is extracted from Craft Anything `crates/formats/src/jsonc.rs` at `e5c9c94106747ed44b9a3fb0decce867c2285f93` (MIT OR Apache-2.0). The original implementation and hardening by BFlat, newline preservation by NetterSilver, and subsequent RRFZ/Afloat correctness fixes retain separate primary-author port commits with immutable source revisions. Shared API wiring and optional input-byte admission are subsequent changes. Compatibility parsing and all existing formatting/editing tests are retained; application file I/O and policy are not imported.
## Packet capture and protocol inspection
`crates/pcap` extracts Craft Anything `crates/formats/src/pcap.rs`, its checked byte reader primitives and synthetic packet fixtures/regressions at `5979f9b13f16dcf1df3c7ae7f8e7735f452866f2` (MIT OR Apache-2.0). Brandon Thomas introduced the implementation, byte reader and fixtures in `f64ae3bf3c8863a982af1304e06de20653803968`. Subsequent fixes by phatloi0010, GGWA, BFlat, Afloat, NetterSilver, Max Mittelstädt and RRFZ retain separate primary-author source-history commits with immutable source revisions. Shared error/API wiring and chrono-based timestamp formatting with exhaustive day-boundary parity tests are subsequent Dylan M. Taylor changes. No packet reassembly, decryption, live capture or app analysis policy is imported.
## HTTP Archive reader
`crates/har` preserves Craft Anything `crates/formats/src/har.rs` from `5979f9b13f16dcf1df3c7ae7f8e7735f452866f2` (MIT OR Apache-2.0). Brandon Thomas introduced the typed reader in `f64ae3bf3c8863a982af1304e06de20653803968`; BFlat added UTF-8 BOM compatibility in `cb0bb9d8fa4536ba44ef2c86f5ed759b879cc2d3`. Both source snapshots retain primary author attribution. Shared wiring, explicit byte admission and its tests are subsequent Dylan M. Taylor changes. Redaction and analysis remain app-owned.
Generated
+17 -7
View File
@@ -2153,13 +2153,6 @@ dependencies = [
"flate2",
]
[[package]]
name = "craft-hdr"
version = "0.1.0"
dependencies = [
"thiserror 2.0.21",
]
[[package]]
name = "craft-har"
version = "0.1.0"
@@ -2168,6 +2161,13 @@ dependencies = [
"thiserror 2.0.21",
]
[[package]]
name = "craft-hdr"
version = "0.1.0"
dependencies = [
"thiserror 2.0.21",
]
[[package]]
name = "craft-heif"
version = "0.1.0"
@@ -2642,6 +2642,16 @@ dependencies = [
name = "craft-palette"
version = "0.1.0"
[[package]]
name = "craft-pcap"
version = "0.1.0"
dependencies = [
"chrono",
"serde",
"serde_json",
"thiserror 2.0.21",
]
[[package]]
name = "craft-pcraft-bundle"
version = "0.1.0"
+1
View File
@@ -11,6 +11,7 @@ rust-version = "1.95"
repository = "https://github.com/storytold/craft-libs"
[workspace.dependencies]
craft-pcap = { path = "crates/pcap" }
craft-har = { path = "crates/har" }
craft-jsonc = { path = "crates/jsonc" }
craft-palette = { path = "crates/palette" }
+17
View File
@@ -0,0 +1,17 @@
[package]
name = "craft-pcap"
description = "Read-only PCAP/PCAPNG and per-frame protocol inspection"
version.workspace = true
edition.workspace = true
license.workspace = true
rust-version.workspace = true
repository.workspace = true
[lints]
workspace = true
[dependencies]
serde = { workspace = true }
thiserror = { workspace = true }
chrono = { workspace = true }
[dev-dependencies]
serde_json = { workspace = true }
+49
View File
@@ -0,0 +1,49 @@
//! Checked little/big-endian reads over untrusted bytes. Every read returns `None` when out of range.
#[derive(Debug, Clone, Copy)]
pub struct Reader<'a> {
data: &'a [u8],
}
impl<'a> Reader<'a> {
pub fn new(data: &'a [u8]) -> Self {
Reader { data }
}
pub fn slice(&self, off: usize, len: usize) -> Option<&'a [u8]> {
let end = off.checked_add(len)?;
self.data.get(off..end)
}
pub fn u8(&self, off: usize) -> Option<u8> {
self.data.get(off).copied()
}
fn arr<const N: usize>(&self, off: usize) -> Option<[u8; N]> {
self.slice(off, N)?.try_into().ok()
}
pub fn u16_le(&self, off: usize) -> Option<u16> {
self.arr(off).map(u16::from_le_bytes)
}
pub fn u32_le(&self, off: usize) -> Option<u32> {
self.arr(off).map(u32::from_le_bytes)
}
pub fn u64_le(&self, off: usize) -> Option<u64> {
self.arr(off).map(u64::from_le_bytes)
}
pub fn u16_be(&self, off: usize) -> Option<u16> {
self.arr(off).map(u16::from_be_bytes)
}
pub fn u32_be(&self, off: usize) -> Option<u32> {
self.arr(off).map(u32::from_be_bytes)
}
pub fn u64_be(&self, off: usize) -> Option<u64> {
self.arr(off).map(u64::from_be_bytes)
}
}
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,60 @@
#[path = "support/mod.rs"]
mod support;
use craft_pcap::{Dns, decode};
use support::{dns_query, eth, ipv4_pkt, udp};
fn answer(kind: u16, rd: &[u8]) -> Dns {
let mut msg = dns_query();
msg[2..4].copy_from_slice(&0x8180u16.to_be_bytes());
msg[6..8].copy_from_slice(&1u16.to_be_bytes());
msg.extend([0xc0, 12]);
msg.extend(kind.to_be_bytes());
msg.extend([0, 1, 0, 0, 0, 60]);
msg.extend((rd.len() as u16).to_be_bytes());
msg.extend(rd);
decode(1, &eth(0x0800, &ipv4_pkt(17, [192, 0, 2, 2], [192, 0, 2, 1], &udp(53, 51000, &msg)))).dns.unwrap()
}
#[test]
fn svc_binding_reports_target_and_port() {
for kind in [64, 65] {
let msg = answer(kind, b"\0\x01\x03api\0\0\x03\0\x02\x20\xfb");
assert_eq!(msg.answers[0].value, "1 api port=8443");
assert_eq!(answer(kind, b"\0\x01\0\0\x01\0\x03\x02h2\0\x04\0\x04\xc0\0\x02\x01").answers[0].value, "1 . alpn=h2 ipv4hint=192.0.2.1");
assert!(answer(kind, b"\0\x01\0\0\x01\0\x01\x00").incomplete);
assert!(answer(kind, b"\0\x01\xc0\x0c").incomplete);
assert!(answer(kind, b"\0\x01\0\0\x03\0\x01\x00").incomplete);
}
}
#[test]
fn sshfp_preserves_algorithm_and_complete_digest() {
let mut d = vec![4, 2];
d.extend([0x5a; 32]);
assert_eq!(answer(44, &d).answers[0].value, format!("4 2 {}", "5a".repeat(32)));
assert!(answer(44, &d[..15]).incomplete);
}
#[test]
fn tlsa_keeps_selector_and_certificate_association() {
let mut d = vec![3, 1, 1];
d.extend([0xaa; 32]);
assert_eq!(answer(52, &d).answers[0].value, format!("3 1 1 {}", "aa".repeat(32)));
assert!(answer(52, &d[..4]).incomplete);
}
#[test]
fn naptr_keeps_order_preference_strings_and_replacement() {
let rd = b"\0\x0a\0\x02\x01s\x03sip\0\x03srv\0";
assert_eq!(answer(35, rd).answers[0].value, r#"10 2 "s" "sip" "" srv"#);
assert!(answer(35, &rd[..rd.len() - 1]).incomplete);
}
#[test]
fn uri_keeps_priority_weight_and_target() {
assert_eq!(answer(256, b"\0\x02\0\x05https://x.test/s").answers[0].value, r#"2 5 "https://x.test/s""#);
assert!(answer(256, b"\0\x02\0\x05").incomplete);
}
#[test]
fn dname_only_accepts_a_complete_uncompressed_target() {
assert_eq!(answer(39, b"\x04host\0").answers[0].value, "host");
assert!(answer(39, b"\xc0\x0c").incomplete);
assert!(answer(39, b"\x04host\0extra").incomplete);
}
+58
View File
@@ -0,0 +1,58 @@
#[path = "support/mod.rs"]
mod support;
use craft_pcap::{decode, summarize};
use support::{dns_query, eth, ipv4_pkt, pcap, udp};
fn packet(message: &[u8]) -> Vec<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");
}
}
+272
View File
@@ -0,0 +1,272 @@
#[path = "support/mod.rs"]
mod support;
use craft_pcap::{decode, summarize};
use support::{dns_query, eth, ipv4_pkt, pcap, udp};
fn response(record_type: u16, rdata: &[u8], declared_length: usize) -> Vec<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");
}
}
}
#[test]
fn an_in_address_requires_the_right_wire_size_but_update_prerequisites_may_be_empty() {
for (kind, bad) in [(1, &[1, 2, 3][..]), (28, &[0; 15][..])] {
let mut msg = response(kind, bad, bad.len());
assert!(decode(1, &packet(&msg)).dns.unwrap().incomplete);
msg = response(kind, &[], 0);
msg[2..4].copy_from_slice(&0x2800u16.to_be_bytes());
let n = msg.len();
msg[n - 8..n - 6].copy_from_slice(&255u16.to_be_bytes());
msg[n - 6..n - 2].fill(0);
let dns = decode(1, &packet(&msg)).dns.unwrap();
assert!(!dns.incomplete);
assert_eq!(dns.answers[0].value, "");
}
}
#[test]
fn questionless_announcements_and_truncated_responses_keep_their_address() {
let mut message = vec![0, 0, 0x86, 0, 0, 0, 0, 1, 0, 0, 0, 0];
message.extend(b"\x04node\x05local\x00\x00\x01\x80\x01\x00\x00\x00\x3c\x00\x04\xc0\x00\x02\x04");
let frame = eth(0x0800, &ipv4_pkt(17, [192, 0, 2, 4], [224, 0, 0, 251], &udp(5353, 5353, &message)));
let dns = decode(1, &frame).dns.unwrap();
assert!(dns.incomplete);
assert_eq!(dns.answers.len(), 1);
assert_eq!(summarize(&pcap(&[frame]), &|| false).unwrap().dns_addresses[0].value, "node.local A 192.0.2.4");
assert!(decode(1, &packet(&message[..8])).dns.is_none());
}
#[test]
fn service_records_report_their_fields_and_refuse_invalid_framing() {
let mut soa = vec![0xc0, 12, 0xc0, 12];
for n in 1u32..=5 {
soa.extend(n.to_be_bytes());
}
for (kind, data, expected) in [
(33, &b"\x00\x01\x00\x02\x01\xbb\x03srv\x00"[..], "1 2 443 srv"),
(6, soa.as_slice(), "example.com example.com 1 2 3 4 5"),
(257, &b"\x80\x05issueca.test"[..], "128 issue ca.test"),
] {
let dns = decode(1, &packet(&response(kind, data, data.len()))).dns.unwrap();
assert!(!dns.incomplete);
assert_eq!(dns.answers[0].value, expected);
}
for (kind, bad) in [(33, &b"\x00\x01\x00\x02\x01\xbb\xc0\x0c"[..]), (6, &soa[..soa.len() - 1]), (257, &b"\x00\x06issue"[..])] {
let dns = decode(1, &packet(&response(kind, bad, bad.len()))).dns.unwrap();
assert!(dns.incomplete);
assert!(dns.answers.is_empty());
}
}
#[test]
fn mdns_srv_targets_can_be_compressed_except_in_legacy_replies() {
let data = [0, 1, 0, 2, 1, 187, 0xc0, 12];
let msg = response(33, &data, data.len());
for (port, legacy) in [(5353, false), (51000, true)] {
let frame = eth(0x0800, &ipv4_pkt(17, [192, 0, 2, 4], [192, 0, 2, 1], &udp(5353, port, &msg)));
let dns = decode(1, &frame).dns.unwrap();
assert_eq!(dns.incomplete, legacy);
if !legacy {
assert_eq!(dns.answers[0].value, "1 2 443 example.com");
}
}
}
#[test]
fn caa_binary_values_remain_distinct_in_the_inventory() {
for (bytes, display) in [(&b"\xff"[..], r"\xff"), (b"\xfe", r"\xfe"), (br"\xff", r"\\xff")] {
let mut data = b"\x00\x01x".to_vec();
data.extend(bytes);
let dns = decode(1, &packet(&response(257, &data, data.len()))).dns.unwrap();
assert_eq!(dns.answers[0].value, format!("0 x {display}"));
}
}
#[test]
fn only_mdns_masks_the_cache_flush_bit_in_an_address_class() {
let mut msg = response(1, &[192, 0, 2, 1], 4);
let class = msg.len() - 12;
msg[class..class + 2].copy_from_slice(&0x8001u16.to_be_bytes());
for (port, expected) in [(53, "<4 bytes>"), (5353, "192.0.2.1")] {
let frame = eth(0x0800, &ipv4_pkt(17, [192, 0, 2, 4], [192, 0, 2, 1], &udp(port, port, &msg)));
assert_eq!(decode(1, &frame).dns.unwrap().answers[0].value, expected);
}
}
+167
View File
@@ -0,0 +1,167 @@
#[path = "support/mod.rs"]
mod support;
use craft_pcap::{Dns, decode};
use support::{ipv4_pkt, udp};
fn query(last: usize, compressed: bool) -> Dns {
let mut msg = vec![0, 1, 1, 0, 0, if compressed { 2 } else { 1 }, 0, 0, 0, 0, 0, 0];
for len in [63, 63, 63, last] {
msg.push(len as u8);
msg.extend(vec![b'a'; len]);
}
msg.extend([0, 0, 1, 0, 1]);
if compressed {
msg.extend([0xc0, 12, 0, 1, 0, 1]);
}
decode(101, &ipv4_pkt(17, [1; 4], [2; 4], &udp(100, 53, &msg))).dns.unwrap()
}
#[test]
fn label_lengths_and_the_root_octet_count_towards_the_dns_limit() {
for last in [62, 63] {
let dns = query(last, false);
assert!(dns.incomplete);
assert!(dns.questions.is_empty());
}
}
#[test]
fn a_255_octet_name_is_valid_in_plain_and_compressed_form() {
for compressed in [false, true] {
let dns = query(61, compressed);
assert!(!dns.incomplete);
assert_eq!(dns.questions.len(), if compressed { 2 } else { 1 });
assert_eq!(dns.questions[0].name.len(), 253);
}
}
fn prefixed_pointer(last: usize, answer_type: Option<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");
}
}
#[test]
fn dns_label_escapes_distinguish_wire_names_in_question_and_answer_owners() {
let mut message = vec![0, 1, 0x81, 0x80, 0, 2, 0, 1, 0, 0, 0, 0];
message.extend(b"\x03a.b\x03\\\x00\xff\x00\x00\x01\x00\x01");
message.extend(b"\x01a\x01b\x03\\\x00\xff\x00\x00\x01\x00\x01");
message.extend([0xc0, 12, 0, 1, 0, 1, 0, 0, 0, 0, 0, 4, 1, 2, 3, 4]);
let dns = decode(101, &ipv4_pkt(17, [1; 4], [2; 4], &udp(53, 100, &message))).dns.unwrap();
assert!(!dns.incomplete);
assert_eq!(dns.questions[0].name, r"a\.b.\\\000\255");
assert_eq!(dns.questions[1].name, r"a.b.\\\000\255");
assert_eq!(dns.answers[0].name, dns.questions[0].name);
}
+199
View File
@@ -0,0 +1,199 @@
#[path = "support/mod.rs"]
mod support;
use craft_pcap::{Dns, decode};
use support::{ipv4_pkt, udp};
fn response(data: &[u8]) -> Dns {
let mut msg = vec![0, 1, 0x81, 0x80, 0, 0, 0, 1, 0, 0, 0, 0];
msg.extend([0, 0, 16, 0, 1, 0, 0, 0, 60]);
msg.extend((data.len() as u16).to_be_bytes());
msg.extend(data);
decode(101, &ipv4_pkt(17, [1; 4], [2; 4], &udp(53, 100, &msg))).dns.unwrap()
}
fn prerequisites(flags: u16, class: u16, ttl: u32, data: &[u8]) -> Dns {
let mut msg = vec![0, 1];
msg.extend(flags.to_be_bytes());
msg.extend([0, 1, 0, 2, 0, 0, 0, 0]);
// UPDATE's zone section has the question layout: example.test, SOA, IN.
msg.extend(b"\x07example\x04test\x00\x00\x06\x00\x01");
msg.extend([0xc0, 12, 0, 16]);
msg.extend(class.to_be_bytes());
msg.extend(ttl.to_be_bytes());
msg.extend((data.len() as u16).to_be_bytes());
msg.extend(data);
// Different owners let NONE and value-dependent prerequisites hold together.
// The following TXT record must also survive.
msg.extend(b"\x05after");
msg.extend([0xc0, 12, 0, 16, 0, 1, 0, 0, 0, 0, 0, 3, 2, b'o', b'k']);
decode(101, &ipv4_pkt(17, [1; 4], [2; 4], &udp(100, 53, &msg))).dns.unwrap()
}
fn named_txt(owner: &[&[u8]], data: &[u8], port: u16, flags: u16, class: u16, ttl: u32, compressed: bool) -> Dns {
let mut name = Vec::new();
for label in owner {
name.push(u8::try_from(label.len()).unwrap());
name.extend(*label);
}
name.push(0);
let mut msg = vec![0, 1];
msg.extend(flags.to_be_bytes());
msg.extend([0, 1, 0, 2, 0, 0, 0, 0]);
msg.extend(&name);
msg.extend([0, 16, 0, 1]);
if compressed {
msg.extend([0xc0, 12]);
} else {
msg.extend(&name);
}
msg.extend([0, 16]);
msg.extend(class.to_be_bytes());
msg.extend(ttl.to_be_bytes());
msg.extend(u16::try_from(data.len()).unwrap().to_be_bytes());
msg.extend(data);
// The next answer must survive an empty DNS-SD TXT record.
msg.extend([0xc0, 12, 0, 1, 0, 1, 0, 0, 0, 60, 0, 4, 127, 0, 0, 1]);
decode(101, &ipv4_pkt(17, [1; 4], [2; 4], &udp(port, 100, &msg))).dns.unwrap()
}
fn assert_empty_txt_and_following_answer(dns: Dns) {
assert!(!dns.incomplete);
assert_eq!(dns.answers.len(), 2);
assert_eq!(dns.answers[0].rtype, "TXT");
assert_eq!(dns.answers[0].value, "");
assert_eq!(dns.answers[1].value, "127.0.0.1");
}
#[test]
fn empty_dns_sd_txt_preserves_following_answers() {
let multicast: &[&[u8]] = &[b"Printer", b"_ipp", b"_tcp", b"local"];
let unicast: &[&[u8]] = &[b"Printer", b"_ipp", b"_tcp", b"example", b"test"];
for (port, owner) in [(5353, multicast), (53, unicast)] {
assert_empty_txt_and_following_answer(named_txt(owner, &[], port, 0x8400, 1, 60, false));
}
}
#[test]
fn empty_dns_sd_txt_is_valid_in_mdns_known_answers_and_cache_flush_records() {
let owner: &[&[u8]] = &[b"Printer", b"_ipp", b"_tcp", b"local"];
// Queries may contain known answers; the cache-flush bit belongs to CLASS.
for (flags, class) in [(0, 1), (0x8400, 0x8001)] {
assert_empty_txt_and_following_answer(named_txt(owner, &[], 5353, flags, class, 60, false));
}
}
#[test]
fn dns_sd_owner_preserves_wire_labels_case_and_compression() {
let owner: &[&[u8]] = &[b"Printer.with dots", b"_Ab-12", b"_UdP", b"example", b"test"];
for compressed in [false, true] {
assert_empty_txt_and_following_answer(named_txt(owner, &[], 53, 0x8180, 1, 60, compressed));
}
}
#[test]
fn other_empty_txt_owners_are_not_dns_sd_instances() {
let owners: &[&[&[u8]]] = &[
&[b"Printer", b"local"],
&[b"Printer._ipp._tcp", b"local"],
&[b"Printer", b"_ipp._tcp", b"_tcp", b"local"],
&[b"_ipp", b"_tcp", b"local"],
&[b"Printer", b"_ipp", b"_tcp"],
&[b"Printer", b"_ipp", b"_other", b"local"],
&[b"Printer", b"_123", b"_tcp", b"local"],
&[b"Printer", b"_bad--name", b"_tcp", b"local"],
];
for owner in owners {
let dns = named_txt(owner, &[], 5353, 0x8400, 1, 60, false);
assert!(dns.incomplete, "owner {owner:?}");
assert!(dns.answers.is_empty());
}
}
#[test]
fn dns_sd_txt_still_rejects_truncated_nonempty_strings() {
let owner: &[&[u8]] = &[b"Printer", b"_ipp", b"_tcp", b"local"];
for data in [&b"\x02x"[..], &b"\x00\x04x"[..]] {
let dns = named_txt(owner, data, 5353, 0x8400, 0x8001, 60, true);
assert!(dns.incomplete);
assert!(dns.answers.is_empty());
}
}
#[test]
fn dns_sd_owner_does_not_relax_update_prerequisite_classes() {
let owner: &[&[u8]] = &[b"Printer", b"_ipp", b"_tcp", b"example", b"test"];
let dns = named_txt(owner, &[], 53, 5 << 11, 1, 0, true);
assert!(dns.incomplete);
assert!(dns.answers.is_empty());
for class in [254, 255] {
assert_empty_txt_and_following_answer(named_txt(owner, &[], 53, 5 << 11, class, 0, true));
}
}
#[test]
fn empty_update_prerequisites_preserve_following_records() {
for class in [254, 255] {
let dns = prerequisites(5 << 11, class, 0, &[]);
assert!(!dns.incomplete, "class {class}");
assert_eq!(dns.answers.len(), 2);
assert_eq!(dns.answers[0].name, "example.test");
assert_eq!(dns.answers[0].value, "");
assert_eq!(dns.answers[1].name, "after.example.test");
assert_eq!(dns.answers[1].value, "ok");
}
}
#[test]
fn empty_txt_rdata_requires_update_and_a_prerequisite_class() {
assert!(response(&[]).incomplete);
for (flags, class, ttl) in [(0x8180, 254, 0), (0x8180, 255, 0), (5 << 11, 1, 0), (5 << 11, 254, 60), (5 << 11, 255, 60)] {
let dns = prerequisites(flags, class, ttl, &[]);
assert!(dns.incomplete, "flags {flags:#x}, class {class}, ttl {ttl}");
assert!(dns.answers.is_empty());
}
for opcode in [1, 2, 3, 4, 6] {
for class in [254, 255] {
let dns = prerequisites(opcode << 11, class, 0, &[]);
assert!(dns.incomplete, "opcode {opcode}, class {class}");
assert!(dns.answers.is_empty());
}
}
}
#[test]
fn update_prerequisite_classes_do_not_allow_truncated_strings() {
for class in [254, 255] {
let dns = prerequisites(5 << 11, class, 0, b"\x02x");
assert!(dns.incomplete);
assert!(dns.answers.is_empty());
}
}
#[test]
fn truncated_txt_strings_are_not_complete_answers() {
for data in [&b"\x05abc"[..], &b"\x02ok\x04x"[..], &b"\x01"[..]] {
let dns = response(data);
assert!(dns.incomplete);
assert!(dns.answers.is_empty());
}
}
#[test]
fn empty_and_multiple_complete_strings_remain_valid() {
for (data, expected) in [(&b"\x00"[..], ""), (&b"\x00\x02ok\x01!"[..], "ok!")] {
let dns = response(data);
assert!(!dns.incomplete);
assert_eq!(dns.answers[0].value, expected);
}
}
#[test]
fn value_dependent_update_accepts_an_empty_character_string() {
let dns = prerequisites(5 << 11, 1, 0, b"\x00");
assert!(!dns.incomplete);
assert_eq!(dns.answers.len(), 2);
assert_eq!(dns.answers[0].value, "");
assert_eq!(dns.answers[1].name, "after.example.test");
assert_eq!(dns.answers[1].value, "ok");
}
+39
View File
@@ -0,0 +1,39 @@
#[path = "support/mod.rs"]
mod support;
use craft_pcap::summarize;
use support::{block, eth, ipv4_pkt, pcap, pcapng, udp};
fn frame() -> Vec<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,70 @@
#[path = "support/mod.rs"]
mod support;
use craft_pcap::{Http, decode};
use support::{ipv4_pkt, tcp};
fn request(data: &[u8]) -> Http {
decode(101, &ipv4_pkt(6, [1; 4], [2; 4], &tcp(100, 80, 0x18, data))).http.unwrap()
}
#[test]
fn a_host_shaped_line_in_the_body_is_not_a_request_header() {
let http = request(b"POST / HTTP/1.1\r\nContent-Length: 22\r\n\r\nbody\r\nHost: forged.test\r\n");
assert!(http.host.is_none());
}
#[test]
fn invalid_utf8_before_host_does_not_shift_header_byte_offsets() {
let http = request(b"GET / HTTP/1.1\r\nX-Data: \xff\r\nHoSt:\tReal.test \t\r\n\r\n");
assert_eq!(http.host.as_deref(), Some("Real.test"));
}
#[test]
fn host_requires_a_complete_header_line_and_keeps_its_spelling() {
assert!(request(b"GET / HTTP/1.1\r\nHost: cut").host.is_none());
assert_eq!(request(b"GET / HTTP/1.1\r\nHost: Real.test\r\n\r\n").host.as_deref(), Some("Real.test"));
}
#[test]
fn http_evidence_needs_a_complete_start_line() {
for input in [
b"GET / HTTP/1.1".as_slice(),
b"GET / HTTP/1.1x\r\n",
b"GET / HTTP/1.1 extra\r\n",
b"GET HTTP/1.0\r\n",
b"GET /bad\tpath HTTP/1.1\r\n",
b"HTTP/1.garbage\r\n",
b"HTTP/1.1 20 OK\r\n",
b"HTTP/1.1 999 OK\r\n",
b"HTTP/1.1 200 OK",
b"HTTP/1.garbage 204\r\n\r\n",
b"HTTP/1.1 20\r\n\r\n",
b"HTTP/1.1 2040\r\n\r\n",
b"HTTP/1.1 999\r\n\r\n",
b"HTTP/1.1 2x4\r\n\r\n",
b"HTTP/1.1 204",
b"HTTP/1.1 204 bad\0reason\r\n\r\n",
] {
assert!(decode(101, &ipv4_pkt(6, [1; 4], [2; 4], &tcp(100, 80, 0x18, input))).http.is_none(), "{input:?}");
}
assert_eq!(request(b"GET / HTTP/1.0\r\n").version, "HTTP/1.0");
assert_eq!(request(b"HTTP/1.1 204 \r\n").status, Some(204));
assert_eq!(request(b"HTTP/1.1 403 Access denied\r\n").status, Some(403));
}
#[test]
fn responses_with_no_reason_phrase_still_keep_the_status_code() {
for (input, version, code) in
[(b"HTTP/1.1 204\r\n\r\n".as_slice(), "HTTP/1.1", 204), (b"HTTP/1.0 200\r\nContent-Length: 0\r\n\r\n".as_slice(), "HTTP/1.0", 200)]
{
let decoded = decode(101, &ipv4_pkt(6, [1; 4], [2; 4], &tcp(80, 100, 0x18, input)));
assert!(decoded.protocols.contains(&"http"));
let http = decoded.http.unwrap();
assert_eq!(http.kind, "response");
assert_eq!(http.version, version);
assert_eq!(http.status, Some(code));
assert!(http.method.is_none());
assert!(http.target.is_none());
}
}
+35
View File
@@ -0,0 +1,35 @@
#[path = "support/mod.rs"]
mod support;
use craft_pcap::decode;
use support::{ipv4_pkt, tcp};
/// WebDAV and extension methods retain the same HTTP evidence as core methods.
#[test]
fn extension_methods_are_http_requests() {
for method in ["PROPFIND", "MKCOL", "LOCK", "REPORT", "M-SEARCH", "custom", "X!#$%&'*+-.^_`|~012"] {
let request = format!("{method} /collection/ HTTP/1.1\r\nHost: dav.example\r\n\r\n");
let decoded = decode(101, &ipv4_pkt(6, [1; 4], [2; 4], &tcp(100, 80, 0x18, request.as_bytes())));
let http = decoded.http.unwrap_or_else(|| panic!("missing HTTP: {method}"));
assert_eq!(http.method.as_deref(), Some(method));
assert_eq!(http.target.as_deref(), Some("/collection/"));
assert_eq!(http.host.as_deref(), Some("dav.example"));
}
}
/// A method still needs a nonempty ASCII token and a complete valid start line.
#[test]
fn invalid_extension_method_lines_are_not_http() {
for request in [
" / HTTP/1.1\r\n",
"BAD:METHOD / HTTP/1.1\r\n",
"BAD/METHOD / HTTP/1.1\r\n",
"MÉTHOD / HTTP/1.1\r\n",
"BAD\tMETHOD / HTTP/1.1\r\n",
"PROPFIND / HTTP/1.1",
"PROPFIND / HTTP/no\r\n",
] {
let decoded = decode(101, &ipv4_pkt(6, [1; 4], [2; 4], &tcp(100, 80, 0x18, request.as_bytes())));
assert!(decoded.http.is_none(), "{request:?}");
}
}
+60
View File
@@ -0,0 +1,60 @@
#[path = "support/mod.rs"]
mod support;
use craft_pcap::decode;
use support::{ipv4_pkt, udp};
#[test]
fn incomplete_ipv4_base_headers_explain_why_decoding_stopped() {
let packet = ipv4_pkt(17, [1; 4], [2; 4], &[]);
for captured in 10..20 {
let decoded = decode(101, &packet[..captured]);
assert!(decoded.ip.is_none(), "captured {captured} bytes");
assert!(decoded.transport.is_none(), "captured {captured} bytes");
assert_eq!(decoded.note.as_deref(), Some("IPv4 header cut short"), "captured {captured} bytes");
}
}
#[test]
fn an_ipv4_total_length_cannot_be_shorter_than_its_header() {
for total in [0u16, 19, 23] {
let mut packet = ipv4_pkt(17, [1, 2, 3, 4], [5, 6, 7, 8], &udp(100, 200, b"body"));
packet[0] = 0x46;
packet[2..4].copy_from_slice(&total.to_be_bytes());
let decoded = decode(101, &packet);
assert!(decoded.ip.is_none());
assert!(decoded.transport.is_none());
assert!(decoded.note.is_some());
}
}
#[test]
fn missing_ipv4_options_do_not_form_a_complete_ip_header() {
let mut packet = ipv4_pkt(17, [1; 4], [2; 4], &[]);
packet[0] = 0x46;
packet[2..4].copy_from_slice(&24u16.to_be_bytes());
let decoded = decode(101, &packet);
assert!(decoded.ip.is_none());
assert!(decoded.note.is_some());
}
#[test]
fn complete_options_and_truncated_transport_keep_their_valid_fields() {
let body = udp(100, 200, b"body");
let mut payload = vec![0; 4];
payload.extend(body);
let mut packet = ipv4_pkt(17, [1; 4], [2; 4], &payload);
packet[0] = 0x46;
assert_eq!(decode(101, &packet).transport.unwrap().payload_len, 4);
packet.truncate(34);
let decoded = decode(101, &packet);
assert!(decoded.ip.is_some());
let transport = decoded.transport.unwrap();
assert_eq!(transport.src_port, Some(100));
assert_eq!(transport.dst_port, Some(200));
assert_eq!(transport.payload_len, 2);
packet.truncate(28);
let decoded = decode(101, &packet);
assert!(decoded.ip.is_some());
assert_eq!(decoded.transport.unwrap().src_port, Some(100));
}
+43
View File
@@ -0,0 +1,43 @@
#[path = "support/mod.rs"]
mod support;
use craft_pcap::decode;
use support::{eth, udp};
fn packet(offset: u16, next: u8, payload: &[u8]) -> Vec<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,40 @@
use craft_pcap::decode;
/// Build a raw IPv6 packet with the given payload and Next Header field.
fn packet(next: u8, payload: &[u8]) -> Vec<u8> {
let mut packet = vec![0; 40];
packet[0] = 0x60;
packet[4..6].copy_from_slice(&u16::try_from(payload.len()).unwrap().to_be_bytes());
packet[6] = next;
packet[7] = 64;
packet.extend_from_slice(payload);
packet
}
/// Both an empty packet and bytes after No Next Header have no transport record.
#[test]
fn no_next_header_has_no_transport() {
for payload in [b"".as_slice(), b"padding"] {
let decoded = decode(229, &packet(59, payload));
assert_eq!(decoded.ip.unwrap().protocol, 59);
assert_eq!(decoded.protocols, ["raw", "ipv6"]);
assert!(decoded.transport.is_none());
}
}
/// Destination Options can also end the header chain.
#[test]
fn no_next_header_after_an_extension() {
let decoded = decode(229, &packet(60, &[59, 0, 0, 0, 0, 0, 0, 0, 1, 2]));
assert_eq!(decoded.ip.unwrap().protocol, 59);
assert!(decoded.transport.is_none());
}
/// UDP after the same extension still yields its transport and payload.
#[test]
fn udp_after_an_extension_still_decodes() {
let decoded = decode(229, &packet(60, &[17, 0, 0, 0, 0, 0, 0, 0, 0, 10, 0, 11, 0, 9, 0, 0, 42]));
let transport = decoded.transport.unwrap();
assert_eq!(transport.protocol, "udp");
assert_eq!((transport.src_port, transport.dst_port, transport.payload_len), (Some(10), Some(11), 1));
}
+56
View File
@@ -0,0 +1,56 @@
#[path = "support/mod.rs"]
mod support;
use craft_pcap::decode;
use support::{eth, ipv4_pkt};
fn raw_packets() -> (Vec<u8>, Vec<u8>) {
let ipv4 = ipv4_pkt(17, [1; 4], [2; 4], &[0; 20]);
let mut ipv6 = vec![0u8; 40];
ipv6[0] = 0x60;
ipv6[6] = 59;
(ipv4, ipv6)
}
#[test]
fn explicit_raw_link_types_reject_the_other_ip_version() {
let (ipv4, ipv6) = raw_packets();
for (link_type, packet) in [(228, &ipv6), (229, &ipv4)] {
let decoded = decode(link_type, packet);
assert!(decoded.ip.is_none(), "link type {link_type}");
assert!(decoded.transport.is_none(), "link type {link_type}");
assert!(decoded.note.is_some(), "link type {link_type}");
}
}
#[test]
fn matching_raw_link_types_and_generic_raw_packets_remain_readable() {
let (ipv4, ipv6) = raw_packets();
assert_eq!(decode(228, &ipv4).ip.unwrap().version, 4);
assert_eq!(decode(229, &ipv6).ip.unwrap().version, 6);
for link_type in [12, 14, 101] {
assert_eq!(decode(link_type, &ipv4).ip.unwrap().version, 4);
assert_eq!(decode(link_type, &ipv6).ip.unwrap().version, 6);
}
}
#[test]
fn an_ethernet_type_does_not_replace_the_ipv6_version_check() {
for version in [0, 4, 5, 7, 15] {
let mut packet = [0u8; 40];
packet[0] = version << 4;
packet[6] = 59;
let decoded = decode(1, &eth(0x86dd, &packet));
assert!(decoded.ip.is_none(), "version {version}");
assert!(decoded.transport.is_none());
assert!(decoded.note.is_some());
}
}
#[test]
fn ipv6_version_keeps_traffic_class_bits() {
let mut packet = [0u8; 40];
packet[0] = 0x6f;
packet[6] = 59;
assert_eq!(decode(1, &eth(0x86dd, &packet)).ip.unwrap().version, 6);
}
+33
View File
@@ -0,0 +1,33 @@
use craft_pcap::decode;
/// Decode a raw IPv4 packet with a TCP header and the specified control bits.
fn flags_on_wire(bits: u8) -> String {
let mut packet = [0u8; 40];
packet[0] = 0x45;
packet[2..4].copy_from_slice(&40u16.to_be_bytes());
packet[8] = 64;
packet[9] = 6;
packet[20..24].copy_from_slice(&[0xc0, 0, 0x01, 0xbb]);
packet[32] = 0x50;
packet[33] = bits;
decode(228, &packet).transport.unwrap().tcp_flags.unwrap()
}
/// An ECN-capable SYN shows both classic ECN flags.
#[test]
fn reports_ecn_setup_on_syn() {
assert_eq!(flags_on_wire(0xc2), "SYN,ECE,CWR");
}
/// The receiver and sender can signal ECE and CWR independently on ACKs.
#[test]
fn distinguishes_ecn_echo_and_window_reduction() {
assert_eq!(flags_on_wire(0x50), "ACK,ECE");
assert_eq!(flags_on_wire(0x90), "ACK,CWR");
}
/// Existing non-ECN packets keep their flag strings.
#[test]
fn keeps_ordinary_ack_flags() {
assert_eq!(flags_on_wire(0x12), "SYN,ACK");
}
@@ -0,0 +1,65 @@
#[path = "support/mod.rs"]
mod support;
use craft_pcap::Capture;
use support::{block, pcapng};
fn capture(original: u32, snaplen: u32, payload: &[u8]) -> Vec<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);
}
@@ -0,0 +1,80 @@
#[path = "support/mod.rs"]
mod support;
use craft_pcap::summarize;
use support::{block, pcapng, sample_frames};
#[test]
fn mismatched_block_footers_stop_the_capture_with_a_warning() {
let original = pcapng(&sample_frames());
for footer in [24, 56] {
let mut data = original.clone();
data[footer..footer + 4].copy_from_slice(&12u32.to_le_bytes());
let result = summarize(&data, &|| false).unwrap();
assert!(!result.warnings.is_empty(), "footer at {footer}");
assert_eq!(result.packets, 0);
}
}
#[test]
fn fixed_block_headers_cannot_borrow_the_next_blocks_bytes() {
let header = pcapng(&[]);
for (kind, short_body) in [(1, vec![]), (2, vec![0; 16]), (6, vec![0; 16]), (3, vec![])] {
let mut data = header[..28].to_vec();
if kind != 1 {
data.extend(&header[28..]);
}
data.extend(block(kind, &short_body));
data.extend(&pcapng(&sample_frames())[28..]);
let result = summarize(&data, &|| false).unwrap();
assert!(!result.warnings.is_empty(), "kind {kind}");
assert_eq!(result.packets, 0, "kind {kind}");
assert_eq!(result.interfaces.len(), usize::from(kind != 1), "kind {kind}");
}
}
#[test]
fn valid_blocks_and_unknown_blocks_still_work() {
let original = pcapng(&sample_frames());
let mut data = original[..60].to_vec();
data.extend(block(0x0000_1234, b"ignored"));
data.extend(&original[60..]);
let result = summarize(&data, &|| false).unwrap();
assert_eq!(result.packets, 7);
assert!(result.warnings.is_empty());
assert_eq!(result.interfaces.len(), 1);
}
#[test]
fn big_endian_block_footers_use_the_sections_byte_order() {
let be_block = |kind: u32, body: &[u8]| {
let size = (body.len() + 12) as u32;
let mut out = kind.to_be_bytes().to_vec();
out.extend(size.to_be_bytes());
out.extend(body);
out.extend(size.to_be_bytes());
out
};
let mut section = 0x1a2b3c4du32.to_be_bytes().to_vec();
section.extend([0, 1, 0, 0]);
section.extend((-1i64).to_be_bytes());
let mut data = be_block(0x0a0d0d0a, &section);
data.extend(be_block(1, &[0, 1, 0, 0, 0, 0, 0, 0]));
let result = summarize(&data, &|| false).unwrap();
assert!(result.warnings.is_empty());
assert_eq!(result.interfaces[0].link_type, 1);
let end = data.len();
data[end - 4..].copy_from_slice(&20u32.to_le_bytes());
assert!(!summarize(&data, &|| false).unwrap().warnings.is_empty());
}
#[test]
fn a_skipped_packet_before_the_first_interface_preserves_later_frames() {
let original = pcapng(&sample_frames());
let mut data = original[..28].to_vec();
data.extend(block(3, &[0; 4]));
data.extend(&original[28..]);
let summary = summarize(&data, &|| false).unwrap();
assert_eq!(summary.packets, 7);
assert!(summary.warnings.iter().any(|w| w.contains("undeclared interface")));
}
@@ -0,0 +1,70 @@
#[path = "support/mod.rs"]
mod support;
use craft_pcap::{Decoded, decode};
use support::{dns_query, dns_response, ipv4_pkt, tcp};
fn decoded(payload: &[u8]) -> Decoded {
decode(101, &ipv4_pkt(6, [192, 0, 2, 1], [192, 0, 2, 2], &tcp(53, 51000, 0x18, payload)))
}
fn framed(message: &[u8], declared: usize) -> Vec<u8> {
let mut payload = (declared as u16).to_be_bytes().to_vec();
payload.extend(message);
payload
}
#[test]
fn an_unfinished_dns_message_is_not_reported_complete() {
let message = dns_response();
let result = decoded(&framed(&message, message.len() + 1));
assert!(result.dns.is_none());
assert!(result.note.is_some());
assert_eq!(result.transport.unwrap().src_port, Some(53));
}
#[test]
fn dns_records_cannot_borrow_bytes_past_the_message_length() {
let result = decoded(&framed(&dns_response(), 12));
let dns = result.dns.unwrap();
assert!(dns.questions.is_empty() && dns.answers.is_empty());
assert!(dns.incomplete);
}
#[test]
fn a_length_smaller_than_the_dns_header_is_rejected() {
for length in 0..12 {
let result = decoded(&framed(&dns_response(), length));
assert!(result.dns.is_none(), "length {length}");
assert!(result.note.is_some(), "length {length}");
}
}
#[test]
fn a_partial_dns_length_prefix_is_reported() {
let result = decoded(&[0]);
assert!(result.dns.is_none());
assert!(result.note.is_some());
}
#[test]
fn an_empty_tcp_ack_does_not_claim_a_missing_dns_message() {
let result = decoded(&[]);
assert!(result.dns.is_none());
assert!(result.note.is_none());
assert_eq!(result.transport.unwrap().payload_len, 0);
}
#[test]
fn the_first_complete_dns_message_is_decoded_without_the_next_one() {
let first = dns_query();
let second = dns_response();
let mut payload = framed(&first, first.len());
payload.extend(framed(&second, second.len()));
let result = decoded(&payload);
let dns = result.dns.unwrap();
assert!(!dns.response && !dns.incomplete);
assert_eq!(dns.questions[0].name, "example.com");
assert!(dns.answers.is_empty());
assert!(result.note.is_none());
}
@@ -0,0 +1,55 @@
#[path = "support/mod.rs"]
mod support;
use craft_pcap::{Decoded, decode};
use support::{ipv4_pkt, tcp};
fn decoded(segment: &[u8]) -> Decoded {
decode(101, &ipv4_pkt(6, [192, 0, 2, 1], [192, 0, 2, 2], segment))
}
#[test]
fn a_tcp_header_shorter_than_twenty_bytes_is_not_payload() {
for words in 0..5u8 {
let mut segment = tcp(51000, 80, 0x18, b"GET / HTTP/1.1\r\n\r\n");
segment[12] = words << 4;
let result = decoded(&segment);
let transport = result.transport.unwrap();
assert_eq!(transport.payload_len, 0, "offset {words}");
assert_eq!((transport.src_port, transport.dst_port), (Some(51000), Some(80)));
assert!(result.http.is_none() && result.tls.is_none());
assert!(result.note.is_some());
}
}
#[test]
fn a_cut_tcp_header_keeps_ports_but_reports_the_cut() {
let whole = tcp(51000, 80, 0x18, b"request");
for end in 4..20 {
let result = decoded(&whole[..end]);
let transport = result.transport.unwrap();
assert_eq!((transport.src_port, transport.dst_port), (Some(51000), Some(80)));
assert_eq!(transport.payload_len, 0);
assert!(result.note.is_some(), "cut at {end}");
}
for words in 6..=15u8 {
let mut segment = tcp(51000, 80, 0x18, &[]);
segment[12] = words << 4;
let result = decoded(&segment);
assert_eq!(result.transport.unwrap().payload_len, 0);
assert!(result.note.is_some(), "missing options for offset {words}");
}
}
#[test]
fn a_valid_tcp_header_with_options_finds_its_payload() {
let mut segment = tcp(51000, 80, 0x18, &[]);
segment[12] = 7 << 4;
segment.extend([1; 8]);
let payload = b"GET /resource HTTP/1.1\r\nHost: example.test\r\n\r\n";
segment.extend(payload);
let result = decoded(&segment);
assert_eq!(result.transport.unwrap().payload_len, payload.len());
assert_eq!(result.http.unwrap().target.as_deref(), Some("/resource"));
assert!(result.note.is_none());
}
+176
View File
@@ -0,0 +1,176 @@
#[path = "support/mod.rs"]
mod support;
use craft_pcap::{Decoded, decode};
use support::{client_hello, ipv4_pkt, tcp};
fn decoded(record: &[u8]) -> Decoded {
decode(101, &ipv4_pkt(6, [192, 0, 2, 1], [192, 0, 2, 2], &tcp(51000, 443, 0x18, record)))
}
fn assert_no_complete_sni(record: &[u8]) {
let result = decoded(record);
assert!(result.protocols.contains(&"tls"));
assert!(result.tls.is_none_or(|hello| hello.sni.is_none() && hello.partial));
}
#[test]
fn a_client_hello_cannot_read_past_its_tls_record() {
let mut record = client_hello("example.test");
record[3..5].copy_from_slice(&4u16.to_be_bytes());
assert_no_complete_sni(&record);
}
#[test]
fn a_client_hello_cannot_read_past_its_handshake() {
let mut record = client_hello("example.test");
record[6..9].copy_from_slice(&[0, 0, 34]);
assert_no_complete_sni(&record);
}
#[test]
fn extensions_cannot_read_past_the_declared_extension_list() {
let mut record = client_hello("example.test");
record[50..52].copy_from_slice(&4u16.to_be_bytes());
assert_no_complete_sni(&record);
}
#[test]
fn a_truncated_record_reports_partial_even_when_the_hello_fields_fit() {
let mut record = client_hello("example.test");
let larger = (record.len() + 20) as u16;
record[3..5].copy_from_slice(&larger.to_be_bytes());
assert!(decoded(&record).tls.unwrap().partial);
}
#[test]
fn server_names_stay_inside_the_name_list() {
let mut record = client_hello("example.test");
record[56..58].copy_from_slice(&3u16.to_be_bytes());
assert_no_complete_sni(&record);
}
#[test]
fn alpn_names_stay_inside_the_protocol_list() {
let mut record = client_hello("example.test");
let alpn_list = 52 + 4 + 5 + "example.test".len() + 4;
record[alpn_list..alpn_list + 2].copy_from_slice(&3u16.to_be_bytes());
let hello = decoded(&record).tls.unwrap();
assert_eq!(hello.alpn, ["h2"]);
assert!(hello.partial);
}
#[test]
fn supported_versions_stay_inside_the_version_list() {
let mut record = client_hello("example.test");
let versions = 52 + 4 + 5 + "example.test".len() + 4 + 14 + 4;
record[versions] = 2;
let hello = decoded(&record).tls.unwrap();
assert_eq!(hello.supported_versions, ["TLS 1.3"]);
assert!(hello.partial);
}
#[test]
fn a_complete_legacy_hello_can_omit_extensions() {
let mut record = client_hello("example.test");
record.truncate(50);
record[3..5].copy_from_slice(&45u16.to_be_bytes());
record[6..9].copy_from_slice(&[0, 0, 41]);
record[46..48].copy_from_slice(&0x002fu16.to_be_bytes());
let hello = decoded(&record).tls.unwrap();
assert!(hello.sni.is_none() && hello.alpn.is_empty() && hello.supported_versions.is_empty());
assert!(!hello.partial);
}
#[test]
fn a_following_handshake_does_not_extend_the_first_hello() {
let mut record = client_hello("example.test");
record.extend([14, 0, 0, 0]);
let record_len = (record.len() - 5) as u16;
record[3..5].copy_from_slice(&record_len.to_be_bytes());
let hello = decoded(&record).tls.unwrap();
assert_eq!(hello.sni.as_deref(), Some("example.test"));
assert_eq!(hello.alpn, ["h2", "http/1.1"]);
assert!(!hello.partial);
}
#[test]
fn complete_hello_metadata_is_unchanged() {
let record = client_hello("example.test");
let hello = decoded(&record).tls.unwrap();
assert_eq!(hello.sni.as_deref(), Some("example.test"));
assert_eq!(hello.alpn, ["h2", "http/1.1"]);
assert_eq!(hello.supported_versions, ["TLS 1.3", "TLS 1.2"]);
assert!(!hello.partial);
}
fn hello_with_vectors(session: &[u8], suites: &[u8], compression: &[u8], extensions: &[(u16, &[u8])]) -> craft_pcap::TlsHello {
let mut record = client_hello("unused.test");
record.truncate(43);
record.push(session.len() as u8);
record.extend(session);
record.extend((suites.len() as u16).to_be_bytes());
record.extend(suites);
record.push(compression.len() as u8);
record.extend(compression);
let mut ext = Vec::new();
for (kind, bytes) in extensions {
ext.extend(kind.to_be_bytes());
ext.extend((bytes.len() as u16).to_be_bytes());
ext.extend(*bytes);
}
record.extend((ext.len() as u16).to_be_bytes());
record.extend(ext);
let len = record.len();
record[3..5].copy_from_slice(&((len - 5) as u16).to_be_bytes());
record[6..9].copy_from_slice(&((len - 9) as u32).to_be_bytes()[1..]);
decoded(&record).tls.unwrap()
}
#[test]
fn hello_vectors_must_have_protocol_lengths() {
assert!(!hello_with_vectors(&[0; 32], &[0, 47], &[0], &[]).partial);
assert!(hello_with_vectors(&[0; 33], &[0, 47], &[0], &[]).partial);
for suites in [&[][..], &[0, 47, 0][..]] {
assert!(hello_with_vectors(&[], suites, &[0], &[]).partial);
}
assert!(hello_with_vectors(&[], &[0, 47], &[], &[]).partial);
for (kind, empty) in [(0, &[0, 0][..]), (16, &[0, 0][..]), (43, &[0][..])] {
assert!(hello_with_vectors(&[], &[0, 47], &[0], &[(kind, empty)]).partial);
}
}
#[test]
fn only_registered_grease_patterns_are_removed() {
let hello = hello_with_vectors(&[], &[0, 47], &[0], &[(43, &[6, 0x1a, 0x2a, 0x4a, 0x4a, 3, 4])]);
assert!(!hello.partial);
assert_eq!(hello.supported_versions, ["0x1a2a", "TLS 1.3"]);
}
#[test]
fn duplicate_extensions_and_repeated_host_names_are_incomplete() {
let hello = hello_with_vectors(&[], &[0, 47], &[0], &[(43, &[2, 3, 4]), (43, &[2, 3, 3])]);
assert!(hello.partial);
assert_eq!(hello.supported_versions, ["TLS 1.3"]);
let hello = hello_with_vectors(&[], &[0, 47], &[0], &[(0, &[0, 8, 0, 0, 1, b'a', 0, 0, 1, b'b'])]);
assert!(hello.partial);
assert_eq!(hello.sni.as_deref(), Some("a"));
}
#[test]
fn the_alpn_display_limit_does_not_hide_a_damaged_tail() {
let mut protocols = vec![0, 33];
for _ in 0..16 {
protocols.extend([1, b'x']);
}
protocols.push(3);
let hello = hello_with_vectors(&[], &[0, 47], &[0], &[(16, &protocols)]);
assert_eq!(hello.alpn.len(), 16);
assert!(hello.partial);
protocols[1] = 34;
protocols.pop();
protocols.extend([1, b'y']);
let hello = hello_with_vectors(&[], &[0, 47], &[0], &[(16, &protocols)]);
assert_eq!(hello.alpn.len(), 16);
assert!(!hello.partial);
}
+173
View File
@@ -0,0 +1,173 @@
#![allow(dead_code)]
//! Packet-capture fixtures: hand-built Ethernet/IPv4 frames (DNS, TCP handshake, TLS
//! ClientHello, HTTP request, ARP) written as classic pcap or pcapng.
const CLASSIC_US: u32 = 0xa1b2_c3d4;
const NG_SHB: u32 = 0x0a0d_0d0a;
const NG_BOM: u32 = 0x1a2b_3c4d;
pub fn eth(ethertype: u16, payload: &[u8]) -> Vec<u8> {
let mut f = vec![0xaa; 6];
f.extend([0xbb; 6]);
f.extend(ethertype.to_be_bytes());
f.extend(payload);
f
}
pub fn ipv4_pkt(proto: u8, src: [u8; 4], dst: [u8; 4], payload: &[u8]) -> Vec<u8> {
let mut p = vec![0x45, 0, 0, 0, 0, 1, 0, 0, 64, proto, 0, 0];
p.extend(src);
p.extend(dst);
let total = (20 + payload.len()) as u16;
p[2..4].copy_from_slice(&total.to_be_bytes());
p.extend(payload);
p
}
pub fn udp(sp: u16, dp: u16, payload: &[u8]) -> Vec<u8> {
let mut u = sp.to_be_bytes().to_vec();
u.extend(dp.to_be_bytes());
u.extend(((8 + payload.len()) as u16).to_be_bytes());
u.extend([0, 0]);
u.extend(payload);
u
}
pub fn tcp(sp: u16, dp: u16, flags: u8, payload: &[u8]) -> Vec<u8> {
let mut t = sp.to_be_bytes().to_vec();
t.extend(dp.to_be_bytes());
t.extend(1000u32.to_be_bytes());
t.extend(0u32.to_be_bytes());
t.extend([0x50, flags, 0xff, 0xff, 0, 0, 0, 0]);
t.extend(payload);
t
}
/// DNS response for example.com A 93.184.216.34 (name compressed in the answer).
pub fn dns_response() -> Vec<u8> {
let mut m = vec![0x12, 0x34, 0x81, 0x80, 0, 1, 0, 1, 0, 0, 0, 0];
m.extend(b"\x07example\x03com\x00\x00\x01\x00\x01");
m.extend([0xc0, 12, 0, 1, 0, 1, 0, 0, 0x0e, 0x10, 0, 4, 93, 184, 216, 34]);
m
}
pub fn dns_query() -> Vec<u8> {
let mut m = vec![0x12, 0x34, 0x01, 0x00, 0, 1, 0, 0, 0, 0, 0, 0];
m.extend(b"\x07example\x03com\x00\x00\x01\x00\x01");
m
}
/// A TLS 1.3-style ClientHello naming `host` with ALPN h2 and http/1.1.
pub fn client_hello(host: &str) -> Vec<u8> {
let mut ext = Vec::new();
let mut sni = vec![0u8];
sni.extend((host.len() as u16).to_be_bytes());
sni.extend(host.as_bytes());
let mut sni_list = (sni.len() as u16).to_be_bytes().to_vec();
sni_list.extend(sni);
ext.extend(0u16.to_be_bytes());
ext.extend((sni_list.len() as u16).to_be_bytes());
ext.extend(sni_list);
let alpn_list = b"\x02h2\x08http/1.1";
ext.extend(16u16.to_be_bytes());
ext.extend(((alpn_list.len() + 2) as u16).to_be_bytes());
ext.extend((alpn_list.len() as u16).to_be_bytes());
ext.extend(alpn_list);
ext.extend(43u16.to_be_bytes());
ext.extend(5u16.to_be_bytes());
ext.extend([4, 0x03, 0x04, 0x03, 0x03]);
let mut body = vec![3, 3];
body.extend([7u8; 32]);
body.push(0); // session id
body.extend([0, 2, 0x13, 0x01]); // one cipher suite
body.extend([1, 0]); // compression
body.extend((ext.len() as u16).to_be_bytes());
body.extend(ext);
let mut hs = vec![1];
hs.extend(&(body.len() as u32).to_be_bytes()[1..]);
hs.extend(body);
let mut rec = vec![22, 3, 1];
rec.extend((hs.len() as u16).to_be_bytes());
rec.extend(hs);
rec
}
/// Frames of a small conversation, as (link type 1) Ethernet frames.
pub fn sample_frames() -> Vec<Vec<u8>> {
let c = [192, 168, 1, 10];
let dns_srv = [8, 8, 8, 8];
let web = [93, 184, 216, 34];
vec![
eth(0x0800, &ipv4_pkt(17, c, dns_srv, &udp(50000, 53, &dns_query()))),
eth(0x0800, &ipv4_pkt(17, dns_srv, c, &udp(53, 50000, &dns_response()))),
eth(0x0800, &ipv4_pkt(6, c, web, &tcp(50001, 443, 0x02, &[]))),
eth(0x0800, &ipv4_pkt(6, web, c, &tcp(443, 50001, 0x12, &[]))),
eth(0x0800, &ipv4_pkt(6, c, web, &tcp(50001, 443, 0x18, &client_hello("example.com")))),
eth(
0x0800,
&ipv4_pkt(
6,
c,
web,
&tcp(50002, 80, 0x18, b"GET http://user:pw@example.com/a?b=1 HTTP/1.1\r\nHost: example.com\r\nUser-Agent: t\r\n\r\n"),
),
),
eth(0x0806, &[0u8; 28]),
]
}
/// A classic little-endian microsecond pcap of `frames`.
pub fn pcap(frames: &[Vec<u8>]) -> Vec<u8> {
let mut out = CLASSIC_US.to_le_bytes().to_vec();
out.extend(2u16.to_le_bytes());
out.extend(4u16.to_le_bytes());
out.extend([0u8; 8]);
out.extend(65535u32.to_le_bytes());
out.extend(1u32.to_le_bytes());
for (i, f) in frames.iter().enumerate() {
out.extend((1_700_000_000u32 + i as u32).to_le_bytes());
out.extend(500u32.to_le_bytes());
out.extend((f.len() as u32).to_le_bytes());
out.extend((f.len() as u32).to_le_bytes());
out.extend(f);
}
out
}
pub fn block(t: u32, body: &[u8]) -> Vec<u8> {
let mut body = body.to_vec();
while !body.len().is_multiple_of(4) {
body.push(0);
}
let len = (body.len() + 12) as u32;
let mut b = t.to_le_bytes().to_vec();
b.extend(len.to_le_bytes());
b.extend(body);
b.extend(len.to_le_bytes());
b
}
/// A little-endian pcapng with one Ethernet interface at nanosecond resolution.
pub fn pcapng(frames: &[Vec<u8>]) -> Vec<u8> {
let mut shb = NG_BOM.to_le_bytes().to_vec();
shb.extend(1u16.to_le_bytes());
shb.extend(0u16.to_le_bytes());
shb.extend((-1i64).to_le_bytes());
let mut out = block(NG_SHB, &shb);
let mut idb = 1u16.to_le_bytes().to_vec();
idb.extend([0, 0]);
idb.extend(0u32.to_le_bytes());
idb.extend([9, 0, 1, 0, 9, 0, 0, 0, 0, 0, 0, 0]); // if_tsresol = 9, end of options
out.extend(block(1, &idb));
for (i, f) in frames.iter().enumerate() {
let ts: u64 = 1_700_000_000_000_000_000 + i as u64;
let mut epb = 0u32.to_le_bytes().to_vec();
epb.extend(((ts >> 32) as u32).to_le_bytes());
epb.extend((ts as u32).to_le_bytes());
epb.extend((f.len() as u32).to_le_bytes());
epb.extend((f.len() as u32).to_le_bytes());
epb.extend(f);
out.extend(block(6, &epb));
}
out
}