use crate::protocols::error::{PacketError, Result};
use crate::protocols::sizes::DNS_HDR_LEN;
use dns_parser::{Packet, QueryType, RData};
use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
const IPV4_ARPA_SUFFIX: &str = ".in-addr.arpa";
const IPV6_ARPA_SUFFIX: &str = ".ip6.arpa";
const IPV6_NIBBLES: usize = 32;
#[non_exhaustive]
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct PtrResponse {
pub id: u16,
pub subject: Option<IpAddr>,
pub hostname: Option<String>,
}
pub fn parse_ptr_response(payload: &[u8]) -> Result<PtrResponse> {
let packet =
Packet::parse(payload).map_err(|error| PacketError::unreadable("a DNS response", error))?;
if packet.header.query {
return Err(PacketError::UnexpectedMessage {
expected: "a DNS response",
got: "a query",
});
}
let subject = packet
.questions
.first()
.filter(|question| question.qtype == QueryType::PTR)
.and_then(|question| address_from_pointer_name(&question.qname.to_string()));
let hostname = packet.answers.iter().find_map(|record| match &record.data {
RData::PTR(ptr) => Some(ptr.0.to_string().trim_end_matches('.').to_string()),
_ => None,
});
Ok(PtrResponse {
id: packet.header.id,
subject,
hostname,
})
}
pub fn first_text_answer(payload: &[u8]) -> Option<String> {
let packet = Packet::parse(payload).ok()?;
if packet.header.query {
return None;
}
let text = packet
.answers
.iter()
.find_map(|record| match &record.data {
RData::TXT(txt) => Some(txt.iter().collect::<Vec<_>>().concat()),
_ => None,
})?;
let text = String::from_utf8(text).ok()?;
(!text.is_empty()).then_some(text)
}
pub fn is_response(payload: &[u8]) -> bool {
Packet::parse(payload).is_ok_and(|packet| !packet.header.query)
}
pub fn reverse_pointer_name(ip: IpAddr) -> String {
match ip {
IpAddr::V4(ipv4) => {
let [a, b, c, d] = ipv4.octets();
format!("{d}.{c}.{b}.{a}{IPV4_ARPA_SUFFIX}")
}
IpAddr::V6(ipv6) => {
let mut name = String::with_capacity(IPV6_NIBBLES * 2 + IPV6_ARPA_SUFFIX.len());
for byte in ipv6.octets().iter().rev() {
use std::fmt::Write;
write!(name, "{:x}.{:x}.", byte & 0x0F, byte >> 4)
.expect("writing to a String cannot fail");
}
name.truncate(name.len() - 1);
name.push_str(IPV6_ARPA_SUFFIX);
name
}
}
}
pub fn address_from_pointer_name(name: &str) -> Option<IpAddr> {
let name = name.trim_end_matches('.').to_ascii_lowercase();
if let Some(prefix) = name.strip_suffix(IPV4_ARPA_SUFFIX) {
return parse_ipv4_pointer(prefix);
}
if let Some(prefix) = name.strip_suffix(IPV6_ARPA_SUFFIX) {
return parse_ipv6_pointer(prefix);
}
None
}
fn parse_ipv4_pointer(prefix: &str) -> Option<IpAddr> {
let labels: Vec<&str> = prefix.split('.').collect();
let [d, c, b, a] = <[&str; 4]>::try_from(labels).ok()?;
Some(IpAddr::V4(Ipv4Addr::new(
octet(a)?,
octet(b)?,
octet(c)?,
octet(d)?,
)))
}
fn octet(label: &str) -> Option<u8> {
let value: u8 = label.parse().ok()?;
(label == value.to_string()).then_some(value)
}
fn parse_ipv6_pointer(prefix: &str) -> Option<IpAddr> {
let labels: Vec<&str> = prefix.split('.').collect();
if labels.len() != IPV6_NIBBLES {
return None;
}
let mut octets = [0u8; 16];
for (byte, pair) in octets.iter_mut().zip(labels.rchunks(2)) {
let low = hex_nibble(pair[0])?;
let high = hex_nibble(pair[1])?;
*byte = (high << 4) | low;
}
Some(IpAddr::V6(Ipv6Addr::from(octets)))
}
fn hex_nibble(label: &str) -> Option<u8> {
let mut chars = label.chars();
let digit = chars.next()?.to_digit(16)?;
chars.next().is_none().then_some(digit as u8)
}
pub fn build_ptr_packet(ip_addr: IpAddr, id: u16) -> Vec<u8> {
build_query(
id,
true,
&[(&reverse_pointer_name(ip_addr), record_type::PTR)],
)
.expect("a reverse name is spelled from an address and cannot break a name bound")
}
pub mod record_type {
pub const A: u16 = 1;
pub const PTR: u16 = 12;
pub const AAAA: u16 = 28;
pub const TXT: u16 = 16;
}
const CLASS_IN: u16 = 1;
const FLAG_RECURSION_DESIRED: u16 = 0x0100;
const MAX_LABEL_OCTETS: usize = 63;
const MAX_NAME_OCTETS: usize = 255;
pub fn build_query(id: u16, recursion_desired: bool, questions: &[(&str, u16)]) -> Result<Vec<u8>> {
let flags = if recursion_desired {
FLAG_RECURSION_DESIRED
} else {
0
};
let mut bytes = Vec::with_capacity(DNS_HDR_LEN + questions.len() * 32);
bytes.extend_from_slice(&id.to_be_bytes());
bytes.extend_from_slice(&flags.to_be_bytes());
bytes.extend_from_slice(&(questions.len() as u16).to_be_bytes());
bytes.extend_from_slice(&[0; 6]); debug_assert_eq!(bytes.len(), DNS_HDR_LEN);
for (name, kind) in questions {
write_name(name, &mut bytes)?;
bytes.extend_from_slice(&kind.to_be_bytes());
bytes.extend_from_slice(&CLASS_IN.to_be_bytes());
}
Ok(bytes)
}
fn write_name(name: &str, out: &mut Vec<u8>) -> Result<()> {
let trimmed = name.trim_end_matches('.');
let mut encoded = Vec::with_capacity(trimmed.len() + 2);
for label in trimmed.split('.') {
if label.is_empty() {
return Err(PacketError::unwritable_name(
name,
"it has an empty label, which no name may carry",
));
}
if label.len() > MAX_LABEL_OCTETS {
return Err(PacketError::unwritable_name(
name,
format_args!(
"the label {label:?} is {} octets, and a label holds at most {MAX_LABEL_OCTETS}",
label.len()
),
));
}
encoded.push(label.len() as u8);
encoded.extend_from_slice(label.as_bytes());
}
encoded.push(0);
if encoded.len() > MAX_NAME_OCTETS {
return Err(PacketError::unwritable_name(
name,
format_args!(
"it is {} octets on the wire, and a name holds at most {MAX_NAME_OCTETS}",
encoded.len()
),
));
}
out.extend_from_slice(&encoded);
Ok(())
}
#[cfg(test)]
pub(crate) mod tests {
use super::*;
fn ip(s: &str) -> IpAddr {
s.parse().unwrap()
}
#[test]
fn a_reverse_name_round_trips_through_the_address_it_names() {
for address in [
ip("192.168.0.1"),
ip("10.0.0.255"),
ip("0.0.0.0"),
ip("255.255.255.255"),
ip("2a02:908:8c1:b880:ca52:61ff:fec7:594"),
ip("fe80::1"),
ip("::"),
] {
let name = reverse_pointer_name(address);
assert_eq!(
address_from_pointer_name(&name),
Some(address),
"round trip failed through {name}"
);
}
}
#[test]
fn reverse_names_are_spelled_out_backwards_under_their_zone() {
assert_eq!(
reverse_pointer_name(ip("192.168.0.1")),
"1.0.168.192.in-addr.arpa"
);
assert_eq!(
reverse_pointer_name(ip("2001:db8::1")),
"1.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.8.b.d.0.1.0.0.2.ip6.arpa"
);
}
#[test]
fn a_reverse_name_is_read_regardless_of_case() {
assert_eq!(
address_from_pointer_name("1.0.168.192.IN-ADDR.ARPA."),
Some(ip("192.168.0.1"))
);
assert_eq!(
address_from_pointer_name(
"1.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.8.B.D.0.1.0.0.2.IP6.ARPA"
),
Some(ip("2001:db8::1"))
);
}
#[test]
fn a_name_that_is_not_a_reverse_name_names_no_address() {
for name in [
"example.com",
"in-addr.arpa",
"1.0.168.in-addr.arpa",
"1.0.168.192.0.in-addr.arpa",
"256.0.168.192.in-addr.arpa",
"x.0.168.192.in-addr.arpa",
"1.0.0.2.ip6.arpa",
"1.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.8.b.d.0.1.0.0.zz.ip6.arpa",
] {
assert_eq!(address_from_pointer_name(name), None, "accepted {name}");
}
}
#[test]
fn a_response_reports_the_address_asked_about_and_the_name_returned() {
let response = parse_ptr_response(&ptr_response(
0x1234,
"1.0.168.192.in-addr.arpa",
Some("kabelbox.local"),
))
.unwrap();
assert_eq!(
response,
PtrResponse {
id: 0x1234,
subject: Some(ip("192.168.0.1")),
hostname: Some("kabelbox.local".to_string()),
}
);
}
#[test]
fn a_negative_response_still_names_the_address_it_answers_for() {
let response =
parse_ptr_response(&ptr_response(7, "30.0.168.192.in-addr.arpa", None)).unwrap();
assert_eq!(response.id, 7);
assert_eq!(response.subject, Some(ip("192.168.0.30")));
assert_eq!(response.hostname, None);
}
#[test]
fn a_reverse_name_is_read_only_as_it_would_be_written() {
let address = ip("192.0.2.1");
assert_eq!(
address_from_pointer_name(&reverse_pointer_name(address)),
Some(address)
);
for spelling in [
"001.002.000.192.in-addr.arpa",
"+1.2.0.192.in-addr.arpa",
"1.2.0.0192.in-addr.arpa",
"01.2.0.192.in-addr.arpa",
] {
assert_eq!(
address_from_pointer_name(spelling),
None,
"{spelling} is not a name this writes"
);
}
assert_eq!(
address_from_pointer_name("1.0.0.10.in-addr.arpa"),
Some(ip("10.0.0.1"))
);
}
#[test]
fn a_forward_lookup_concerns_no_address() {
let mut bytes = build_query(1, true, &[("example.com", record_type::A)]).unwrap();
bytes[2] |= 0x80;
let response = parse_ptr_response(&bytes).unwrap();
assert_eq!(response.subject, None);
assert_eq!(response.hostname, None);
}
#[test]
fn a_query_is_not_a_response() {
let query = build_ptr_packet(ip("192.168.0.1"), 9);
assert!(parse_ptr_response(&query).is_err());
}
#[test]
fn bytes_that_are_not_dns_are_rejected() {
assert!(parse_ptr_response(b"not dns").is_err());
}
pub(crate) fn ptr_response(id: u16, question: &str, answer: Option<&str>) -> Vec<u8> {
let mut bytes = Vec::new();
bytes.extend_from_slice(&id.to_be_bytes());
bytes.extend_from_slice(&0x8180u16.to_be_bytes()); bytes.extend_from_slice(&1u16.to_be_bytes()); bytes.extend_from_slice(&u16::from(answer.is_some()).to_be_bytes()); bytes.extend_from_slice(&0u16.to_be_bytes()); bytes.extend_from_slice(&0u16.to_be_bytes());
write_name(&mut bytes, question);
bytes.extend_from_slice(&12u16.to_be_bytes()); bytes.extend_from_slice(&1u16.to_be_bytes());
if let Some(answer) = answer {
bytes.extend_from_slice(&[0xC0, 0x0C]); bytes.extend_from_slice(&12u16.to_be_bytes()); bytes.extend_from_slice(&1u16.to_be_bytes()); bytes.extend_from_slice(&60u32.to_be_bytes());
let mut rdata = Vec::new();
write_name(&mut rdata, answer);
bytes.extend_from_slice(&(rdata.len() as u16).to_be_bytes());
bytes.extend_from_slice(&rdata);
}
bytes
}
fn write_name(bytes: &mut Vec<u8>, name: &str) {
for label in name.split('.') {
bytes.push(label.len() as u8);
bytes.extend_from_slice(label.as_bytes());
}
bytes.push(0);
}
}