use hickory_resolver::config::ProtocolConfig;
use hickory_resolver::system_conf::read_system_conf;
use std::net::SocketAddr;
use std::{
collections::{HashMap, HashSet, hash_map::Entry},
net::IpAddr,
sync::atomic::{AtomicU16, Ordering},
time::Duration,
};
use crate::logging::error;
use crate::model::host::NetworkRole;
use crate::protocols::{
dns,
mdns::{self, MdnsHost},
};
use crate::scanner::session::ScanContext;
use crate::{counted, info, model::ip, warn};
use pnet_packet::{Packet, udp::UdpPacket};
use std::sync::Arc;
use tokio::net::UdpSocket;
use tokio::sync::mpsc::UnboundedReceiver;
use crate::transport::probe::{ProbeKind, ProbeTransport, TransportError};
const DNS_PORT: u16 = 53;
use crate::protocols::mdns::PORT as MDNS_PORT;
const MAX_DNS_DATAGRAM: usize = 4096;
const REPLY_GRACE: Duration = Duration::from_millis(250);
type Hostname = String;
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
enum Heard {
Overheard,
Answered,
}
#[derive(Debug, Clone)]
struct Named {
hostname: Hostname,
heard: Heard,
}
type TransID = u16;
struct QueryTarget {
server: SocketAddr,
socket: Arc<UdpSocket>,
}
pub struct HostnameResolver {
transport: ProbeTransport,
query_targets: Vec<QueryTarget>,
dns_map: HashMap<TransID, IpAddr>,
queried: HashSet<IpAddr>,
mdns_cache: HashMap<IpAddr, MdnsHost>,
hostname_map: HashMap<IpAddr, Named>,
name_servers: HashSet<IpAddr>,
dns_rx: UnboundedReceiver<IpAddr>,
id_counter: AtomicU16,
}
#[non_exhaustive]
#[derive(Debug, thiserror::Error)]
pub enum ResolverError {
#[error("no reachable DNS server to send reverse queries to")]
NoServer,
#[error("the resolver's receive path could not be opened: {0}")]
Transport(#[from] TransportError),
}
impl HostnameResolver {
pub fn new(dns_rx: UnboundedReceiver<IpAddr>) -> Result<Self, ResolverError> {
let dns_servers = dns_server_candidates();
let transport = ProbeTransport::open_receiver(ProbeKind::UdpResolve)?;
Self::with_transport(dns_rx, transport, dns_servers)
}
pub fn with_transport(
dns_rx: UnboundedReceiver<IpAddr>,
transport: ProbeTransport,
dns_servers: Vec<SocketAddr>,
) -> Result<Self, ResolverError> {
let query_targets = bind_query_targets(&dns_servers)?;
Ok(Self {
transport,
query_targets,
dns_map: HashMap::new(),
queried: HashSet::new(),
mdns_cache: HashMap::new(),
hostname_map: HashMap::new(),
name_servers: HashSet::new(),
dns_rx,
id_counter: AtomicU16::new(0),
})
}
pub async fn run(mut self) -> Self {
let (v4, v6) = self.reply_sockets();
let mut sniffing = true;
loop {
tokio::select! {
res = self.dns_rx.recv() => {
match res {
Some(ip) => self.query(ip).await,
None => break,
}
}
(payload, from) = recv_reply(&v4) => self.absorb_reply(&payload, from),
(payload, from) = recv_reply(&v6) => self.absorb_reply(&payload, from),
pkt = self.transport.rx.recv(), if sniffing => {
match pkt {
Some(reply) => self.absorb_sniffed(&reply.bytes, reply.source),
None => sniffing = false,
}
}
}
}
if !self.dns_map.is_empty() {
let _ = tokio::time::timeout(REPLY_GRACE, async {
while !self.dns_map.is_empty() {
tokio::select! {
(payload, from) = recv_reply(&v4) => self.absorb_reply(&payload, from),
(payload, from) = recv_reply(&v6) => self.absorb_reply(&payload, from),
pkt = self.transport.rx.recv(), if sniffing => {
match pkt {
Some(reply) => self.absorb_sniffed(&reply.bytes, reply.source),
None => sniffing = false,
}
}
}
}
})
.await;
}
while let Ok(reply) = self.transport.rx.try_recv() {
self.absorb_sniffed(&reply.bytes, reply.source);
}
self
}
async fn query(&mut self, ip: IpAddr) {
if !is_queryable(&ip) || !self.queried.insert(ip) {
return;
}
match self.send_dns_query(&ip).await {
Ok(count) => info!(
outgoing,
verbosity = 2,
"reverse query for {ip} sent to {}",
counted(count as u128, "resolver", "resolvers")
),
Err(e) => error!("reverse query for {ip} failed: {e}"),
}
}
async fn send_dns_query(&mut self, ip: &IpAddr) -> std::io::Result<usize> {
let mut sent = Vec::with_capacity(self.query_targets.len());
let mut last_error = None;
for target in &self.query_targets {
let id = self.get_next_trans_id();
let packet = dns::build_ptr_packet(*ip, id);
match target.socket.send_to(&packet, target.server).await {
Ok(_) => sent.push(id),
Err(error) => {
last_error = Some(std::io::Error::new(
error.kind(),
format!("{}: {error}", target.server),
));
}
}
}
if sent.is_empty() {
return Err(last_error.unwrap_or_else(|| {
std::io::Error::other("no resolver to send a reverse query to")
}));
}
for id in sent.iter().copied() {
self.dns_map.insert(id, *ip);
}
Ok(sent.len())
}
fn absorb_reply(&mut self, payload: &[u8], from: SocketAddr) {
if !self.query_targets.iter().any(|t| t.server == from) {
return;
}
let response = match dns::parse_ptr_response(payload) {
Ok(response) => response,
Err(e) => {
error!(verbosity = 2, "unreadable reply from resolver {from}: {e}");
return;
}
};
self.name_servers.insert(from.ip());
let Some(ip) = self.dns_map.get(&response.id).copied() else {
return;
};
if response.subject != Some(ip) {
return;
}
self.dns_map.remove(&response.id);
match response.hostname {
Some(hostname) if restates(&hostname, ip) => info!(
verbosity = 2,
"{from} named {ip} after itself ({hostname}), so it has no name"
),
Some(hostname) => match self.hostname_map.entry(ip) {
Entry::Occupied(slot) if slot.get().heard == Heard::Answered => info!(
verbosity = 2,
"{from} resolved {ip} to {hostname}; an earlier answer stands"
),
Entry::Occupied(mut slot) => {
info!(
incoming,
verbosity = 2,
"{from} resolved {ip} to {hostname}, over a name only overheard"
);
slot.insert(Named {
hostname,
heard: Heard::Answered,
});
}
Entry::Vacant(slot) => {
info!(
incoming,
verbosity = 2,
"{from} resolved {ip} to {hostname}"
);
slot.insert(Named {
hostname,
heard: Heard::Answered,
});
}
},
None => info!(verbosity = 2, "{from} has no name for {ip}"),
}
}
fn absorb_sniffed(&mut self, segment: &[u8], source: IpAddr) {
let Some(udp_packet) = UdpPacket::new(segment) else {
return;
};
match udp_packet.get_source() {
DNS_PORT => {
if dns::is_response(udp_packet.payload()) {
self.name_servers.insert(source);
}
self.absorb_sniffed_dns(udp_packet.payload());
}
MDNS_PORT => self.absorb_sniffed_mdns(udp_packet.payload()),
_ => {}
}
}
fn absorb_sniffed_dns(&mut self, payload: &[u8]) {
let Ok(response) = dns::parse_ptr_response(payload) else {
return;
};
let (Some(ip), Some(hostname)) = (response.subject, response.hostname) else {
return;
};
if restates(&hostname, ip) {
return;
}
if let Entry::Vacant(slot) = self.hostname_map.entry(ip) {
info!(verbosity = 2, "overheard {ip} named {hostname}");
slot.insert(Named {
hostname,
heard: Heard::Overheard,
});
}
}
fn absorb_sniffed_mdns(&mut self, payload: &[u8]) {
let Ok(hosts) = mdns::extract_hosts(payload) else {
return;
};
for host in hosts {
self.file_mdns(host);
}
}
fn file_mdns(&mut self, host: MdnsHost) {
info!(
verbosity = 2,
"mDNS names {} as {}",
host.ips
.iter()
.map(IpAddr::to_string)
.collect::<Vec<_>>()
.join(", "),
host.hostname
);
for ip in &host.ips {
self.mdns_cache.insert(*ip, host.clone());
}
}
pub fn resolve_hosts(&mut self, ctx: &ScanContext) {
for key in ctx.host_addresses() {
let (hostname_map, mdns_cache) = (&mut self.hostname_map, &mut self.mdns_cache);
let name_servers = &self.name_servers;
ctx.write_host(key, |host| {
let mut named = false;
let ips = host.ips().clone();
for ip in &ips {
if name_servers.contains(ip) {
named |= host.add_network_role(NetworkRole::DnsServer);
}
if host.hostname().is_none()
&& let Some(Named { hostname, .. }) = hostname_map.remove(ip)
{
host.set_hostname(Some(hostname));
named = true;
}
}
for ip in &ips {
if let Some(mdns_host) = mdns_cache.remove(ip) {
if host.hostname().is_none() {
host.set_hostname(Some(mdns_host.hostname));
}
host.extend_ips(mdns_host.ips);
named = true;
}
}
named
});
}
}
fn reply_sockets(&self) -> (Option<Arc<UdpSocket>>, Option<Arc<UdpSocket>>) {
let socket_for = |ipv4: bool| {
self.query_targets
.iter()
.find(|t| t.server.is_ipv4() == ipv4)
.map(|t| Arc::clone(&t.socket))
};
(socket_for(true), socket_for(false))
}
fn get_next_trans_id(&self) -> u16 {
self.id_counter.fetch_add(1, Ordering::Relaxed)
}
}
async fn recv_reply(socket: &Option<Arc<UdpSocket>>) -> (Vec<u8>, SocketAddr) {
let socket = match socket {
Some(socket) => socket,
None => return std::future::pending().await,
};
let mut buf = [0u8; MAX_DNS_DATAGRAM];
match socket.recv_from(&mut buf).await {
Ok((len, from)) => (buf[..len].to_vec(), from),
Err(e) => {
error!("reverse query socket failed: {e}");
std::future::pending().await
}
}
}
fn bind_query_targets(servers: &[SocketAddr]) -> Result<Vec<QueryTarget>, ResolverError> {
let v4 = bind_family(servers, SocketAddr::is_ipv4, "0.0.0.0:0");
let v6 = bind_family(servers, SocketAddr::is_ipv6, "[::]:0");
let targets: Vec<QueryTarget> = servers
.iter()
.filter_map(|server| {
let socket = if server.is_ipv4() { &v4 } else { &v6 };
Some(QueryTarget {
server: *server,
socket: Arc::clone(socket.as_ref()?),
})
})
.collect();
if targets.is_empty() {
return Err(ResolverError::NoServer);
}
info!(
verbosity = 1,
"reverse queries go to {}",
targets
.iter()
.map(|t| t.server.to_string())
.collect::<Vec<_>>()
.join(", ")
);
Ok(targets)
}
fn bind_family(
servers: &[SocketAddr],
wanted: fn(&SocketAddr) -> bool,
bind_addr: &str,
) -> Option<Arc<UdpSocket>> {
if !servers.iter().any(wanted) {
return None;
}
match bind_ephemeral(bind_addr) {
Ok(socket) => Some(Arc::new(socket)),
Err(e) => {
warn!("could not bind {bind_addr} for reverse queries: {e}");
None
}
}
}
fn bind_ephemeral(bind_addr: &str) -> std::io::Result<UdpSocket> {
let socket = std::net::UdpSocket::bind(bind_addr)?;
socket.set_nonblocking(true)?;
UdpSocket::from_std(socket)
}
fn dns_server_candidates() -> Vec<SocketAddr> {
let mut servers = Vec::new();
match read_system_conf() {
Ok((config, _options)) => {
for name_server in config.name_servers() {
if let Some(port) = udp_port(name_server) {
push_unique(&mut servers, SocketAddr::new(name_server.ip, port));
}
}
}
Err(e) => warn!("could not read the system resolver configuration: {e}"),
}
for gateway in netdev::get_interfaces()
.into_iter()
.filter_map(|i| i.gateway)
{
for ip in &gateway.ipv4 {
push_unique(&mut servers, SocketAddr::new(IpAddr::V4(*ip), DNS_PORT));
}
for ip in &gateway.ipv6 {
if !ip.is_unicast_link_local() {
push_unique(&mut servers, SocketAddr::new(IpAddr::V6(*ip), DNS_PORT));
}
}
}
servers
}
fn udp_port(name_server: &hickory_resolver::config::NameServerConfig) -> Option<u16> {
if name_server.connections.is_empty() {
return Some(DNS_PORT);
}
name_server
.connections
.iter()
.find(|connection| matches!(connection.protocol, ProtocolConfig::Udp))
.map(|connection| connection.port)
}
fn push_unique(servers: &mut Vec<SocketAddr>, server: SocketAddr) {
if !servers.contains(&server) {
servers.push(server);
}
}
pub async fn resolve_hosts_async(ctx: &ScanContext) {
use hickory_resolver::TokioResolver;
let Ok(builder) = TokioResolver::builder_tokio() else {
return;
};
let Ok(resolver) = builder.build() else {
return;
};
let mut set = tokio::task::JoinSet::new();
let mut ips_to_resolve = Vec::new();
for key in ctx.host_addresses() {
let unnamed = ctx
.read_host(&key, |host| host.hostname().is_none())
.unwrap_or(false);
if unnamed {
ips_to_resolve.push(key);
}
}
for key in ips_to_resolve {
let resolver = resolver.clone();
set.spawn(async move {
use hickory_resolver::proto::rr::RData;
if let Ok(lookup) = resolver.reverse_lookup(key.addr()).await
&& let Some(name) = lookup.answers().iter().find_map(|r| match &r.data {
RData::PTR(ptr) => Some(ptr.to_string()),
_ => None,
})
{
return (key, Some(name));
}
(key, None)
});
}
while let Some(Ok((key, Some(name)))) = set.join_next().await {
let name = name.trim_end_matches('.').to_string();
if restates(&name, key.addr()) {
info!(
verbosity = 2,
"{} was named after itself ({name}), so it has no name",
key.addr()
);
continue;
}
ctx.write_host(key, |host| {
host.set_hostname(Some(name));
true
});
}
}
fn restates(name: &str, ip: IpAddr) -> bool {
address_written_as_a_label(name) == Some(ip)
}
fn address_written_as_a_label(name: &str) -> Option<IpAddr> {
let label = name.split('.').next()?;
let substituted = [
label.replace('-', "."),
label.replace('_', "."),
label.replace('-', ":"),
];
if let Some(ip) = substituted
.iter()
.find_map(|spelling| spelling.parse().ok())
{
return Some(ip);
}
let labels: Vec<&str> = name.split('.').collect();
(2..=labels.len()).find_map(|take| labels[..take].join(".").parse().ok())
}
fn is_queryable(ip: &IpAddr) -> bool {
match ip {
IpAddr::V6(ipv6_addr) => ip::is_global_unicast(ipv6_addr),
IpAddr::V4(_ipv4_addr) => true,
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::model::host::HostStatus;
use crate::scanner::session::{ScanEvent, ScanSession};
use crate::transport::probe::{Emission, ProbeSender, SendError};
use std::net::Ipv4Addr;
fn v4(a: u8, b: u8, c: u8, d: u8) -> IpAddr {
IpAddr::V4(Ipv4Addr::new(a, b, c, d))
}
#[test]
fn an_address_written_into_a_label_is_recognised_as_one() {
let subject = v4(203, 0, 113, 26);
for name in [
"203-0-113-26.lan",
"203-0-113-26.fritz.box",
"203_0_113_26.lan",
"203.0.113.26.lan",
"203-0-113-26",
] {
assert!(
restates(name, subject),
"{name} was not read as its address"
);
}
}
#[test]
fn an_ipv6_address_written_into_a_label_is_recognised_too() {
let subject: IpAddr = "2001:db8::1".parse().expect("an address");
assert!(restates("2001-db8--1.lan", subject));
let link_local: IpAddr = "fe80::1".parse().expect("an address");
assert!(restates("fe80--1.example", link_local));
}
#[test]
fn a_real_name_is_not_mistaken_for_an_address() {
let subject = v4(203, 0, 113, 26);
for name in [
"epson928262.lan",
"10-4-good-buddy.lan",
"gateway.local",
"MacBook-Pro.local",
"host-1.example",
"203-0-113.lan",
] {
assert!(!restates(name, subject), "{name} was taken for an address");
}
}
#[test]
fn a_label_naming_some_other_address_is_left_alone() {
assert!(!restates("198-51-100-1.lan", v4(203, 0, 113, 26)));
}
#[tokio::test]
async fn a_synthesised_name_overheard_is_never_recorded() {
let mut resolver = resolver_asking(vec![
"127.0.0.1:53".parse().expect("a valid socket address"),
]);
let ip = v4(203, 0, 113, 26);
resolver.absorb_sniffed_dns(&overheard(ip, "203-0-113-26.lan"));
assert!(
!resolver.hostname_map.contains_key(&ip),
"the address written again was recorded as a name"
);
resolver.absorb_sniffed_dns(&overheard(ip, "epson928262.lan"));
assert_eq!(
resolver
.hostname_map
.get(&ip)
.map(|named| named.hostname.as_str()),
Some("epson928262.lan"),
"a real name overheard for the same address was refused too"
);
}
fn overheard(ip: IpAddr, name: &str) -> Vec<u8> {
let IpAddr::V4(v4) = ip else {
unreachable!("this helper writes in-addr.arpa questions")
};
let octets = v4.octets();
let question = format!(
"{}.{}.{}.{}.in-addr.arpa",
octets[3], octets[2], octets[1], octets[0]
);
crate::protocols::dns::tests::ptr_response(1, &question, Some(name))
}
struct Silent;
impl ProbeSender for Silent {
fn send(
&self,
_: &[u8],
_: IpAddr,
_: IpAddr,
_: Option<u32>,
_emission: Emission,
) -> Result<(), SendError> {
Ok(())
}
}
fn resolver_asking(servers: Vec<SocketAddr>) -> HostnameResolver {
let (_tx, dns_rx) = tokio::sync::mpsc::unbounded_channel();
let (_reply_tx, reply_rx) = tokio::sync::mpsc::channel(1024);
HostnameResolver::with_transport(
dns_rx,
ProbeTransport::from_parts(Box::new(Silent), reply_rx),
servers,
)
.expect("a query target binds")
}
fn resolver_holding(ip: IpAddr, hostname: &str) -> HostnameResolver {
let mut resolver = resolver_asking(vec![
"127.0.0.1:53".parse().expect("a valid socket address"),
]);
resolver.hostname_map.insert(
ip,
Named {
hostname: hostname.to_string(),
heard: Heard::Answered,
},
);
resolver
}
fn dns_response(subject: IpAddr) -> Vec<u8> {
let mut message = dns::build_ptr_packet(subject, 0x1234);
message[2] |= 0b1000_0000; message
}
fn from_port(port: u16, message: Vec<u8>) -> Vec<u8> {
crate::protocols::craft::Udp::new(port, 40_000)
.with_payload(message)
.to_bytes(None)
.expect("a datagram")
}
#[tokio::test]
async fn a_machine_that_answers_dns_is_a_name_server_and_an_mdns_responder_is_not() {
let server = IpAddr::V4(Ipv4Addr::new(192, 0, 2, 53));
let responder = IpAddr::V4(Ipv4Addr::new(192, 0, 2, 60));
let subject = IpAddr::V4(Ipv4Addr::new(192, 0, 2, 10));
let (session, ctx) = ScanSession::new();
for ip in [server, responder] {
ctx.update_host(ip, |host| host.set_status(HostStatus::Up));
}
let mut resolver = resolver_holding(subject, "printer.local");
resolver.absorb_sniffed(&from_port(DNS_PORT, dns_response(subject)), server);
resolver.absorb_sniffed(&from_port(MDNS_PORT, dns_response(subject)), responder);
resolver.resolve_hosts(&ctx);
assert!(
session
.hosts()
.get(server)
.expect("the server is a scanned host")
.network_roles()
.contains(&NetworkRole::DnsServer),
"it answered a lookup in front of us"
);
assert!(
session
.hosts()
.get(responder)
.expect("the responder is a scanned host")
.network_roles()
.is_empty(),
"answering mDNS is not serving DNS"
);
}
#[tokio::test]
async fn an_mdns_record_does_not_carry_an_excluded_address_into_a_host() {
use crate::model::exclusion::Exclusions;
let found = IpAddr::V4(Ipv4Addr::new(192, 0, 2, 60));
let excluded = IpAddr::V4(Ipv4Addr::new(192, 0, 2, 61));
let mut forbidden = crate::model::ip::set::IpSet::new();
forbidden.insert(excluded);
let (_session, ctx) = ScanSession::builder()
.excluding(Exclusions::new(forbidden))
.build();
ctx.update_host(found, |host| host.set_status(HostStatus::Up));
let mut resolver = resolver_asking(vec![
"127.0.0.1:53".parse().expect("a valid socket address"),
]);
resolver.mdns_cache.insert(
found,
mdns::MdnsHost {
hostname: "tv.local".to_string(),
ips: [found, excluded].into_iter().collect(),
},
);
resolver.resolve_hosts(&ctx);
let (hostname, ips) = ctx
.read_host(found, |host| {
(host.hostname().map(str::to_owned), host.ips().clone())
})
.expect("the host is in the store");
assert_eq!(
hostname.as_deref(),
Some("tv.local"),
"test premise: the record applied"
);
assert!(!ips.contains(&excluded), "{ips:?}");
}
#[tokio::test]
async fn a_device_named_at_an_excluded_address_keeps_its_name_at_the_others() {
use crate::model::exclusion::Exclusions;
let excluded = IpAddr::V4(Ipv4Addr::new(192, 0, 2, 60));
let link_local: IpAddr = "fe80::60".parse().expect("literal");
let mut forbidden = crate::model::ip::set::IpSet::new();
forbidden.insert(excluded);
let (_session, ctx) = ScanSession::builder()
.excluding(Exclusions::new(forbidden))
.build();
ctx.update_host(link_local, |host| host.set_status(HostStatus::Up));
let mut resolver = resolver_asking(vec![
"127.0.0.1:53".parse().expect("a valid socket address"),
]);
resolver.file_mdns(mdns::MdnsHost {
hostname: "tv.local".to_string(),
ips: [excluded, link_local].into_iter().collect(),
});
resolver.resolve_hosts(&ctx);
let (hostname, ips) = ctx
.read_host(link_local, |host| {
(host.hostname().map(str::to_owned), host.ips().clone())
})
.expect("the host is in the store");
assert_eq!(hostname.as_deref(), Some("tv.local"));
assert!(!ips.contains(&excluded), "{ips:?}");
}
#[tokio::test]
async fn a_resolved_name_is_preferred_to_an_announced_one_at_any_address() {
let announced_at = IpAddr::V4(Ipv4Addr::new(192, 0, 2, 61));
let resolved_at = IpAddr::V4(Ipv4Addr::new(192, 0, 2, 62));
let (_session, ctx) = ScanSession::new();
ctx.update_host(announced_at, |host| {
host.add_ip(resolved_at);
host.set_status(HostStatus::Up);
});
let mut resolver = resolver_holding(resolved_at, "tv.example");
resolver.file_mdns(mdns::MdnsHost {
hostname: "tv.local".to_string(),
ips: [announced_at].into_iter().collect(),
});
resolver.resolve_hosts(&ctx);
let hostname = ctx
.read_host(announced_at, |host| host.hostname().map(str::to_owned))
.expect("the host is in the store");
assert_eq!(hostname.as_deref(), Some("tv.example"));
}
#[tokio::test]
async fn only_a_resolver_the_scan_asked_is_named_by_its_answer() {
let asked = IpAddr::V4(Ipv4Addr::new(192, 0, 2, 53));
let stranger = IpAddr::V4(Ipv4Addr::new(192, 0, 2, 99));
let subject = IpAddr::V4(Ipv4Addr::new(192, 0, 2, 10));
let (session, ctx) = ScanSession::new();
for ip in [asked, stranger] {
ctx.update_host(ip, |host| host.set_status(HostStatus::Up));
}
let mut resolver = resolver_asking(vec![SocketAddr::new(asked, DNS_PORT)]);
resolver.absorb_reply(&dns_response(subject), SocketAddr::new(asked, DNS_PORT));
resolver.absorb_reply(&dns_response(subject), SocketAddr::new(stranger, DNS_PORT));
resolver.resolve_hosts(&ctx);
let hosts = session.hosts();
assert!(
hosts
.get(asked)
.expect("scanned")
.network_roles()
.contains(&NetworkRole::DnsServer)
);
assert!(
hosts
.get(stranger)
.expect("scanned")
.network_roles()
.is_empty(),
"nothing was asked of it, so its datagram answers nothing"
);
}
#[tokio::test]
async fn attaching_a_hostname_announces_it_like_any_other_finding() {
let ip = IpAddr::V4(Ipv4Addr::new(192, 0, 2, 10));
let (mut session, ctx) = ScanSession::new();
ctx.update_host(ip, |host| host.set_status(HostStatus::Up));
while session.events().try_recv().is_some() {}
resolver_holding(ip, "printer.local").resolve_hosts(&ctx);
assert_eq!(
session
.hosts()
.get(ip)
.and_then(|h| h.hostname().map(String::from)),
Some("printer.local".to_string())
);
assert!(
matches!(session.events().try_recv(), Some(ScanEvent::HostUpdated(at)) if at.addr() == ip),
"the name reached the store without reaching the stream"
);
}
#[tokio::test]
async fn a_host_the_resolver_has_nothing_for_is_left_alone() {
let ip = IpAddr::V4(Ipv4Addr::new(192, 0, 2, 11));
let (mut session, ctx) = ScanSession::new();
ctx.update_host(ip, |host| host.set_status(HostStatus::Up));
while session.events().try_recv().is_some() {}
resolver_holding(IpAddr::V4(Ipv4Addr::new(192, 0, 2, 99)), "other").resolve_hosts(&ctx);
assert!(
session
.hosts()
.get(ip)
.and_then(|h| h.hostname().map(String::from))
.is_none()
);
assert!(session.events().try_recv().is_none(), "nothing changed");
}
fn named_response(subject: IpAddr, name: &str) -> Vec<u8> {
let mut message = dns::build_ptr_packet(subject, 0x1234);
message[2] |= 0b1000_0000; message[6..8].copy_from_slice(&1u16.to_be_bytes());
message.extend_from_slice(&[0xC0, 0x0C]); message.extend_from_slice(&12u16.to_be_bytes()); message.extend_from_slice(&1u16.to_be_bytes()); message.extend_from_slice(&300u32.to_be_bytes());
let mut rdata = Vec::new();
for label in name.split('.') {
rdata.push(label.len() as u8);
rdata.extend_from_slice(label.as_bytes());
}
rdata.push(0);
message.extend_from_slice(&(rdata.len() as u16).to_be_bytes());
message.extend_from_slice(&rdata);
message
}
#[tokio::test]
async fn an_overheard_name_does_not_displace_a_resolved_one() {
let ip = v4(203, 0, 113, 40);
let mut resolver = resolver_holding(ip, "resolver-confirmed.example.com");
resolver.absorb_sniffed(
&from_port(DNS_PORT, named_response(ip, "attacker-chosen.example.com")),
v4(198, 51, 100, 99),
);
assert_eq!(
resolver
.hostname_map
.get(&ip)
.map(|named| named.hostname.as_str()),
Some("resolver-confirmed.example.com"),
"a datagram off the wire outranked a resolver this scan asked"
);
}
#[tokio::test]
async fn an_overheard_name_that_arrives_first_gives_way_to_the_resolver() {
let ip = v4(203, 0, 113, 42);
let server: SocketAddr = "127.0.0.1:53".parse().expect("a valid socket address");
let (session, ctx) = ScanSession::new();
ctx.update_host(ip, |host| host.set_status(HostStatus::Up));
let mut resolver = resolver_asking(vec![server]);
resolver.dns_map.insert(0x1234, ip);
resolver.absorb_sniffed(
&from_port(DNS_PORT, named_response(ip, "attacker-chosen.example.com")),
v4(198, 51, 100, 99),
);
resolver.absorb_reply(
&named_response(ip, "resolver-confirmed.example.com"),
server,
);
resolver.resolve_hosts(&ctx);
assert_eq!(
session
.hosts()
.get(ip)
.and_then(|host| host.hostname().map(str::to_owned))
.as_deref(),
Some("resolver-confirmed.example.com"),
"a datagram that merely arrived first outranked the resolver this scan asked"
);
}
#[tokio::test]
async fn between_two_resolvers_asked_the_first_answer_stands() {
let ip = v4(203, 0, 113, 43);
let first: SocketAddr = "127.0.0.1:53".parse().expect("a valid socket address");
let second: SocketAddr = "127.0.0.2:53".parse().expect("a valid socket address");
let mut resolver = resolver_asking(vec![first, second]);
for (server, name) in [(first, "first.example.com"), (second, "second.example.com")] {
resolver.dns_map.insert(0x1234, ip);
resolver.absorb_reply(&named_response(ip, name), server);
}
assert_eq!(
resolver
.hostname_map
.get(&ip)
.map(|named| named.hostname.as_str()),
Some("first.example.com")
);
}
#[tokio::test]
async fn an_overheard_name_still_names_an_address_nothing_else_has() {
let ip = v4(203, 0, 113, 41);
let mut resolver = resolver_asking(vec![
"127.0.0.1:53".parse().expect("a valid socket address"),
]);
resolver.absorb_sniffed(
&from_port(DNS_PORT, named_response(ip, "overheard.example.com")),
v4(198, 51, 100, 99),
);
assert_eq!(
resolver
.hostname_map
.get(&ip)
.map(|named| named.hostname.as_str()),
Some("overheard.example.com")
);
}
}