use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
use std::ops::Range;
use crate::network::types::{DnsInfo, DnsQueryType};
const MAX_DNS_NAME_LEN: usize = 253;
const MAX_ANSWERS_TO_PARSE: usize = 64;
const MAX_RESPONSE_IPS_PER_PACKET: usize = 16;
const MAX_NAME_POINTER_HOPS: usize = 16;
fn skip_dns_name(payload: &[u8], start: usize) -> Option<usize> {
let mut offset = start;
let mut hops = 0;
loop {
if offset >= payload.len() {
return None;
}
let label_len = payload[offset] as usize;
if label_len == 0 {
return Some(offset + 1);
}
if label_len & 0xC0 == 0xC0 {
if offset + 1 >= payload.len() {
return None;
}
hops += 1;
if hops > MAX_NAME_POINTER_HOPS {
return None;
}
return Some(offset + 2);
}
if label_len & 0xC0 != 0 {
return None;
}
let next = offset.checked_add(1)?.checked_add(label_len)?;
if next > payload.len() {
return None;
}
offset = next;
}
}
fn parse_question(payload: &[u8], start: usize) -> (Option<String>, Option<DnsQueryType>, usize) {
let mut offset = start;
let mut name = String::new();
let mut name_over_limit = false;
while offset < payload.len() {
let label_len = payload[offset] as usize;
if label_len == 0 {
offset += 1;
break;
}
if label_len & 0xC0 == 0xC0 {
offset += 2;
break;
}
if label_len & 0xC0 != 0 {
break;
}
if offset + 1 + label_len > payload.len() {
break;
}
if !name_over_limit {
if !name.is_empty() {
name.push('.');
}
if let Ok(label) = std::str::from_utf8(&payload[offset + 1..offset + 1 + label_len]) {
name.push_str(label);
}
if name.len() > MAX_DNS_NAME_LEN {
name_over_limit = true;
}
}
offset += 1 + label_len;
}
let query_name = if name.is_empty() { None } else { Some(name) };
let mut query_type = None;
if offset + 2 <= payload.len() {
let qtype = u16::from_be_bytes([payload[offset], payload[offset + 1]]);
query_type = Some(DnsQueryType::from_wire(qtype));
}
offset = offset.saturating_add(4);
(query_name, query_type, offset)
}
fn walk_a_aaaa_records(
payload: &[u8],
start: usize,
count: usize,
ips: &mut Vec<IpAddr>,
queried_type: Option<DnsQueryType>,
matched: &mut usize,
) -> (usize, usize) {
let mut offset = start;
let mut walked = 0;
let count = count.min(MAX_ANSWERS_TO_PARSE);
for _ in 0..count {
let Some(rr) = parse_rr_header(payload, offset) else {
return (offset, walked);
};
if queried_type.is_some() && queried_type == Some(DnsQueryType::from_wire(rr.rtype)) {
*matched += 1;
}
if ips.len() < MAX_RESPONSE_IPS_PER_PACKET {
match (rr.rtype, rr.rdata.len()) {
(1, 4) => {
let octets: [u8; 4] = payload[rr.rdata.clone()]
.try_into()
.expect("rdlength==4 and bounds checked above");
ips.push(IpAddr::V4(Ipv4Addr::from(octets)));
}
(28, 16) => {
let octets: [u8; 16] = payload[rr.rdata.clone()]
.try_into()
.expect("rdlength==16 and bounds checked above");
ips.push(IpAddr::V6(Ipv6Addr::from(octets)));
}
_ => {
}
}
}
offset = rr.rdata.end;
walked += 1;
}
(offset, walked)
}
struct RrHeader {
rtype: u16,
rdata: Range<usize>,
}
fn parse_rr_header(payload: &[u8], offset: usize) -> Option<RrHeader> {
let after_name = skip_dns_name(payload, offset)?;
if after_name.checked_add(10)? > payload.len() {
return None;
}
let rtype = u16::from_be_bytes([payload[after_name], payload[after_name + 1]]);
let rdlength = u16::from_be_bytes([payload[after_name + 8], payload[after_name + 9]]) as usize;
let rdata_start = after_name + 10;
let rdata_end = rdata_start.checked_add(rdlength)?;
if rdata_end > payload.len() {
return None;
}
Some(RrHeader {
rtype,
rdata: rdata_start..rdata_end,
})
}
fn authority_marks_nodata(payload: &[u8], start: usize, count: usize) -> bool {
if count == 0 {
return true;
}
if count > MAX_ANSWERS_TO_PARSE {
return false;
}
let mut offset = start;
let mut has_soa = false;
for _ in 0..count {
let Some(rr) = parse_rr_header(payload, offset) else {
return false;
};
if rr.rtype == 6 {
has_soa = true;
}
offset = rr.rdata.end;
}
has_soa
}
pub(super) struct DnsHeaderCounts {
pub is_response: bool,
pub truncated: bool,
pub qdcount: u16,
pub ancount: u16,
pub nscount: u16,
pub arcount: u16,
pub txid: u16,
pub rcode: u8,
}
pub(super) fn dns_header_counts(payload: &[u8]) -> Option<DnsHeaderCounts> {
if payload.len() < 12 {
return None;
}
let flags = u16::from_be_bytes([payload[2], payload[3]]);
Some(DnsHeaderCounts {
is_response: (flags & 0x8000) != 0,
truncated: (flags & 0x0200) != 0,
qdcount: u16::from_be_bytes([payload[4], payload[5]]),
ancount: u16::from_be_bytes([payload[6], payload[7]]),
nscount: u16::from_be_bytes([payload[8], payload[9]]),
arcount: u16::from_be_bytes([payload[10], payload[11]]),
txid: u16::from_be_bytes([payload[0], payload[1]]),
rcode: (flags & 0x000F) as u8,
})
}
pub(super) fn parse_questions_starting_at_header(
payload: &[u8],
qdcount: u16,
) -> (Option<String>, Option<DnsQueryType>, usize) {
let mut offset = 12;
let mut query_name = None;
let mut query_type = None;
for i in 0..qdcount {
let (name, qtype, next) = parse_question(payload, offset);
if i == 0 {
query_name = name;
query_type = qtype;
}
offset = next;
if offset > payload.len() {
break;
}
}
(query_name, query_type, offset)
}
fn parse_dns_base(payload: &[u8]) -> Option<(DnsHeaderCounts, DnsInfo, usize)> {
let header = dns_header_counts(payload)?;
let (query_name, query_type, offset) =
parse_questions_starting_at_header(payload, header.qdcount);
let info = DnsInfo {
query_name,
query_type,
response_ips: Vec::new(),
is_response: header.is_response,
txid: header.txid,
rcode: header.is_response.then_some(header.rcode),
nodata: None,
};
Some((header, info, offset))
}
pub(super) fn analyze_dns(payload: &[u8]) -> Option<DnsInfo> {
let (header, mut info, mut offset) = parse_dns_base(payload)?;
if header.is_response {
let mut matched = 0;
let (after_answers, answers_walked) = walk_a_aaaa_records(
payload,
offset,
header.ancount as usize,
&mut info.response_ips,
info.query_type,
&mut matched,
);
offset = after_answers;
if header.rcode == 0 && info.query_type.is_some() {
if matched > 0 {
info.nodata = Some(false);
} else if !header.truncated
&& answers_walked == header.ancount as usize
&& authority_marks_nodata(payload, offset, header.nscount as usize)
{
info.nodata = Some(true);
}
}
let _ = offset;
}
Some(info)
}
pub(super) fn analyze_dns_for_mdns(payload: &[u8]) -> Option<DnsInfo> {
let (header, mut info, mut offset) = parse_dns_base(payload)?;
if header.is_response {
let mut matched = 0;
let (after_answers, _) = walk_a_aaaa_records(
payload,
offset,
header.ancount as usize,
&mut info.response_ips,
None,
&mut matched,
);
offset = after_answers;
if let Some(after_authority) = skip_records(payload, offset, header.nscount) {
let _ = walk_a_aaaa_records(
payload,
after_authority,
header.arcount as usize,
&mut info.response_ips,
None,
&mut matched,
);
}
}
Some(info)
}
fn skip_records(payload: &[u8], start: usize, count: u16) -> Option<usize> {
let mut offset = start;
let count = (count as usize).min(MAX_ANSWERS_TO_PARSE);
for _ in 0..count {
offset = parse_rr_header(payload, offset)?.rdata.end;
}
Some(offset)
}
#[cfg(test)]
pub(super) mod test_fixtures {
pub(crate) fn encode_name(packet: &mut Vec<u8>, name: &str) {
for label in name.split('.') {
packet.push(label.len() as u8);
packet.extend_from_slice(label.as_bytes());
}
packet.push(0x00);
}
pub(crate) fn build_dns_header(
txid: u16,
flags: u16,
qdcount: u16,
ancount: u16,
nscount: u16,
arcount: u16,
) -> Vec<u8> {
let mut packet = Vec::with_capacity(12);
for field in [txid, flags, qdcount, ancount, nscount, arcount] {
packet.extend_from_slice(&field.to_be_bytes());
}
packet
}
pub(crate) fn push_question(packet: &mut Vec<u8>, name: &str, qtype: u16) {
encode_name(packet, name);
packet.extend_from_slice(&qtype.to_be_bytes());
packet.extend_from_slice(&[0x00, 0x01]); }
pub(crate) fn build_dns_packet(txid: u16, flags: u16, name: &str, qtype: u16) -> Vec<u8> {
let mut packet = build_dns_header(txid, flags, 1, 0, 0, 0);
push_question(&mut packet, name, qtype);
packet
}
pub(crate) enum RrName<'a> {
Ptr(u16),
Labels(&'a str),
}
pub(crate) fn push_rr(packet: &mut Vec<u8>, name: RrName, rtype: u16, ttl: u32, rdata: &[u8]) {
match name {
RrName::Ptr(offset) => packet.extend_from_slice(&(0xC000 | offset).to_be_bytes()),
RrName::Labels(labels) => encode_name(packet, labels),
}
packet.extend_from_slice(&rtype.to_be_bytes());
packet.extend_from_slice(&[0x00, 0x01]); packet.extend_from_slice(&ttl.to_be_bytes());
packet.extend_from_slice(&(rdata.len() as u16).to_be_bytes());
packet.extend_from_slice(rdata);
}
pub(crate) fn push_a(packet: &mut Vec<u8>, name: RrName, ttl: u32, ip: [u8; 4]) {
push_rr(packet, name, 1, ttl, &ip);
}
pub(crate) fn push_aaaa(packet: &mut Vec<u8>, name: RrName, ttl: u32, ip: [u8; 16]) {
push_rr(packet, name, 28, ttl, &ip);
}
}
#[cfg(test)]
mod tests {
use super::test_fixtures::{
RrName, build_dns_header, build_dns_packet, push_a, push_aaaa, push_question, push_rr,
};
use super::*;
#[test]
fn test_empty_payload_safe() {
assert!(analyze_dns(&[]).is_none());
}
#[test]
fn test_short_payload_safe() {
assert!(analyze_dns(&[0; 5]).is_none());
}
#[test]
fn test_dns_name_length_limit() {
let mut payload = vec![0u8; 12]; payload[5] = 1; for _ in 0..10 {
payload.push(63); payload.extend_from_slice(&[b'a'; 63]);
}
payload.push(0); payload.extend_from_slice(&[0, 1, 0, 1]);
let info = analyze_dns(&payload).unwrap();
if let Some(name) = &info.query_name {
assert!(name.len() <= MAX_DNS_NAME_LEN + 63 + 1);
}
assert_eq!(info.query_type, Some(DnsQueryType::A));
}
#[test]
fn test_normal_dns_query() {
let payload = build_dns_packet(0, 0, "example.com", 1);
let info = analyze_dns(&payload).unwrap();
assert_eq!(info.query_name, Some("example.com".to_string()));
assert_eq!(info.query_type, Some(DnsQueryType::A));
assert!(!info.is_response);
}
#[test]
fn test_query_parses_txid_and_has_no_rcode() {
let mut payload = make_example_question(false, 0);
payload[0] = 0xAB;
payload[1] = 0xCD;
let info = analyze_dns(&payload).unwrap();
assert_eq!(info.txid, 0xABCD);
assert_eq!(
info.rcode, None,
"a query carries no response code even though the header bits are zero"
);
}
#[test]
fn test_response_parses_txid_and_rcode() {
let mut payload = make_example_question(true, 0);
payload[0] = 0xAB;
payload[1] = 0xCD;
payload[3] = 0x03;
let info = analyze_dns(&payload).unwrap();
assert_eq!(info.txid, 0xABCD);
assert_eq!(info.rcode, Some(3));
assert_eq!(
info.nodata, None,
"NODATA only applies to NOERROR responses; NXDOMAIN says it all"
);
}
#[test]
fn test_noerror_response_has_rcode_zero() {
let payload = make_example_question(true, 0);
let info = analyze_dns(&payload).unwrap();
assert_eq!(info.rcode, Some(0));
}
#[test]
fn test_question_rejects_reserved_label_bits() {
let mut payload = vec![0u8; 12];
payload[5] = 1; payload.push(3);
payload.extend_from_slice(b"abc");
payload.push(0x40);
payload.extend_from_slice(&[b'x'; 64]);
payload.push(0);
payload.extend_from_slice(&[0, 1, 0, 1]);
let info = analyze_dns(&payload).unwrap();
assert_eq!(info.query_name, Some("abc".to_string()));
}
fn make_example_question(qr_bit: bool, ancount: u16) -> Vec<u8> {
let flags = if qr_bit { 0x8000 } else { 0 };
let mut payload = build_dns_header(0, flags, 1, ancount, 0, 0);
push_question(&mut payload, "example.com", 1);
payload
}
#[test]
fn test_response_with_single_a_record_populates_ip() {
let mut payload = make_example_question(true, 1);
push_a(&mut payload, RrName::Ptr(12), 60, [93, 184, 216, 34]);
let info = analyze_dns(&payload).unwrap();
assert!(info.is_response);
assert_eq!(
info.response_ips,
vec![IpAddr::V4(Ipv4Addr::new(93, 184, 216, 34))]
);
assert_eq!(
info.nodata,
Some(false),
"the answer contains a record of the queried type"
);
}
#[test]
fn test_noerror_response_without_queried_type_flags_nodata() {
let mut payload = make_example_question(true, 1);
push_rr(&mut payload, RrName::Ptr(12), 5, 60, &[0xC0, 0x0C]);
let info = analyze_dns(&payload).unwrap();
assert_eq!(info.rcode, Some(0));
assert_eq!(info.nodata, Some(true));
assert!(info.response_ips.is_empty());
}
#[test]
fn test_soa_authority_confirms_nodata() {
let mut payload = make_example_question(true, 0);
payload[8..10].copy_from_slice(&1u16.to_be_bytes()); let mut soa = vec![0xC0, 0x0C, 0xC0, 0x0C];
soa.extend_from_slice(&[0u8; 20]);
push_rr(&mut payload, RrName::Ptr(12), 6, 60, &soa);
let info = analyze_dns(&payload).unwrap();
assert_eq!(info.rcode, Some(0));
assert_eq!(info.nodata, Some(true));
}
#[test]
fn test_referral_response_leaves_nodata_unset() {
let mut payload = make_example_question(true, 0);
payload[8..10].copy_from_slice(&1u16.to_be_bytes()); push_rr(&mut payload, RrName::Ptr(12), 2, 60, &[0xC0, 0x0C]);
let info = analyze_dns(&payload).unwrap();
assert_eq!(info.rcode, Some(0));
assert_eq!(info.nodata, None);
}
#[test]
fn test_truncated_response_leaves_nodata_unset() {
let mut payload = make_example_question(true, 0);
payload[2] |= 0x02;
let info = analyze_dns(&payload).unwrap();
assert_eq!(info.rcode, Some(0));
assert_eq!(info.nodata, None);
}
#[test]
fn test_unparseable_answer_section_leaves_nodata_unset() {
let payload = make_example_question(true, 1);
let info = analyze_dns(&payload).unwrap();
assert_eq!(info.rcode, Some(0));
assert_eq!(info.nodata, None);
assert!(info.response_ips.is_empty());
}
#[test]
fn test_response_with_aaaa_record_populates_ipv6() {
let mut payload = make_example_question(true, 1);
push_aaaa(
&mut payload,
RrName::Ptr(12),
60,
[
0x20, 0x01, 0x0d, 0xb8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x01,
],
);
let info = analyze_dns(&payload).unwrap();
assert_eq!(info.response_ips.len(), 1);
assert!(matches!(info.response_ips[0], IpAddr::V6(_)));
}
#[test]
fn test_response_mixed_records_collects_a_and_aaaa_skips_cname() {
let mut payload = make_example_question(true, 3);
push_rr(&mut payload, RrName::Ptr(12), 5, 60, &[0xC0, 0x0C]);
push_a(&mut payload, RrName::Ptr(12), 60, [1, 2, 3, 4]);
push_aaaa(
&mut payload,
RrName::Ptr(12),
60,
Ipv6Addr::LOCALHOST.octets(),
);
let info = analyze_dns(&payload).unwrap();
assert_eq!(
info.response_ips,
vec![
IpAddr::V4(Ipv4Addr::new(1, 2, 3, 4)),
IpAddr::V6(Ipv6Addr::LOCALHOST),
]
);
}
#[test]
fn test_query_packet_leaves_response_ips_empty() {
let mut payload = make_example_question(false, 1);
push_a(&mut payload, RrName::Ptr(12), 60, [8, 8, 8, 8]);
let info = analyze_dns(&payload).unwrap();
assert!(!info.is_response);
assert!(info.response_ips.is_empty());
assert_eq!(info.nodata, None, "a query cannot claim NODATA");
}
#[test]
fn test_truncated_rdata_does_not_panic() {
let mut payload = make_example_question(true, 1);
push_a(&mut payload, RrName::Ptr(12), 60, [1, 2, 3, 4]);
payload.truncate(payload.len() - 2);
let info = analyze_dns(&payload).unwrap();
assert!(info.response_ips.is_empty());
}
#[test]
fn test_multi_question_offset_lands_on_first_answer() {
let mut payload = build_dns_header(0, 0x8000, 2, 1, 0, 0);
push_question(&mut payload, "example.com", 1); push_question(&mut payload, "test.net", 28); push_a(&mut payload, RrName::Ptr(12), 60, [1, 2, 3, 4]);
let info = analyze_dns(&payload).unwrap();
assert_eq!(info.query_name, Some("example.com".to_string()));
assert_eq!(info.query_type, Some(DnsQueryType::A));
assert_eq!(
info.response_ips,
vec![IpAddr::V4(Ipv4Addr::new(1, 2, 3, 4))]
);
}
#[test]
fn test_response_ips_capped_per_packet() {
let n: u16 = (MAX_RESPONSE_IPS_PER_PACKET as u16) + 4;
let mut payload = make_example_question(true, n);
for i in 0..n {
push_a(
&mut payload,
RrName::Ptr(12),
60,
[10, 0, 0, (i & 0xFF) as u8],
);
}
let info = analyze_dns(&payload).unwrap();
assert_eq!(info.response_ips.len(), MAX_RESPONSE_IPS_PER_PACKET);
}
}