use hickory_resolver::config::ProtocolConfig;
use std::net::SocketAddr;
use std::{
collections::{HashMap, HashSet, VecDeque, 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::resolve::{
DnsConfig, HostsTable, Reverse, ScopedServers, Snapshot, covers, reverse_name,
};
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 tokio::time::Instant;
use crate::model::ip::scoped::Zone;
use crate::model::ip::set::IpSet;
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);
const QUERY_PATIENCE: Duration = Duration::from_secs(2);
type Hostname = String;
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
enum Heard {
Overheard,
Answered,
Listed,
}
#[derive(Debug, Clone)]
struct Named {
hostname: Hostname,
heard: Heard,
}
type TransID = u16;
struct QueryTarget {
server: SocketAddr,
scope: Option<usize>,
socket: Arc<UdpSocket>,
answered: bool,
unanswered: usize,
}
impl QueryTarget {
fn is_asked(&self) -> bool {
self.answered || self.unanswered < REVERSE_LOOKUPS_IN_FLIGHT
}
}
#[derive(Debug, Clone, Copy)]
struct Query {
ip: IpAddr,
target: usize,
}
#[derive(Debug)]
struct Asking {
ids: Vec<TransID>,
until: Instant,
}
pub struct HostnameResolver {
transport: ProbeTransport,
query_targets: Vec<QueryTarget>,
scopes: Vec<ReverseScope>,
hosts: HostsTable,
dns_map: HashMap<TransID, Query>,
queried: HashSet<IpAddr>,
waiting: VecDeque<IpAddr>,
asking: HashMap<IpAddr, Asking>,
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 routes = Routes::from_system();
let transport = ProbeTransport::open_receiver(ProbeKind::UdpResolve)?;
Self::with_routes(dns_rx, transport, routes)
}
pub(crate) fn capturing_on(
dns_rx: UnboundedReceiver<IpAddr>,
links: &[Zone],
) -> Result<Self, ResolverError> {
let routes = Routes::from_system();
let mut servers = IpSet::new();
for (server, _) in &routes.servers {
servers.insert(server.ip());
}
let mut links = links.to_vec();
if !servers.is_empty() {
for link in crate::transport::probe::capture_links_toward(&servers, &[]) {
if !links.contains(&link) {
links.push(link);
}
}
}
let transport = ProbeTransport::open_receiver_capturing(ProbeKind::UdpResolve, &links)?;
Self::with_routes(dns_rx, transport, routes)
}
pub fn with_transport(
dns_rx: UnboundedReceiver<IpAddr>,
transport: ProbeTransport,
dns_servers: Vec<SocketAddr>,
) -> Result<Self, ResolverError> {
let routes = Routes {
hosts: HostsTable::default(),
servers: dns_servers.into_iter().map(|at| (at, None)).collect(),
scopes: Vec::new(),
};
let resolver = Self::with_routes(dns_rx, transport, routes)?;
if resolver.query_targets.is_empty() {
return Err(ResolverError::NoServer);
}
Ok(resolver)
}
fn with_routes(
dns_rx: UnboundedReceiver<IpAddr>,
transport: ProbeTransport,
routes: Routes,
) -> Result<Self, ResolverError> {
let query_targets = bind_query_targets(&routes.servers, &routes.scopes);
Ok(Self {
transport,
query_targets,
scopes: routes.scopes,
hosts: routes.hosts,
dns_map: HashMap::new(),
queried: HashSet::new(),
waiting: VecDeque::new(),
asking: HashMap::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;
let mut arriving = true;
loop {
self.ask_waiting(arriving).await;
if !arriving && self.waiting.is_empty() && self.asking.is_empty() {
break;
}
let next_expiry = self.asking.values().map(|asking| asking.until).min();
tokio::select! {
res = self.dns_rx.recv(), if arriving => {
match res {
Some(ip) => self.enqueue(ip),
None => {
arriving = false;
self.hurry(Instant::now() + REPLY_GRACE);
}
}
}
(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,
}
}
() = tokio::time::sleep_until(next_expiry.unwrap_or_else(Instant::now)),
if next_expiry.is_some() => self.expire(Instant::now()),
}
}
while let Ok(reply) = self.transport.rx.try_recv() {
self.absorb_sniffed(&reply.bytes, reply.source);
}
self
}
fn enqueue(&mut self, ip: IpAddr) {
if !self.queried.insert(ip) {
return;
}
if let Some(hostname) = self.hosts.name_of(ip) {
info!(verbosity = 2, "hosts file names {ip} {hostname}");
self.hostname_map.insert(
ip,
Named {
hostname: hostname.to_owned(),
heard: Heard::Listed,
},
);
} else if is_queryable(&ip) {
self.waiting.push_back(ip);
}
}
async fn ask_waiting(&mut self, arriving: bool) {
if !self.query_targets.iter().any(QueryTarget::is_asked) {
self.waiting.clear();
return;
}
let patience = if arriving {
QUERY_PATIENCE
} else {
REPLY_GRACE
};
while self.asking.len() < REVERSE_LOOKUPS_IN_FLIGHT
&& let Some(ip) = self.waiting.pop_front()
{
match self.send_dns_query(&ip).await {
Ok(ids) if ids.is_empty() => {}
Ok(ids) => {
info!(
outgoing,
verbosity = 2,
"reverse query for {ip} sent to {}",
counted(ids.len() as u128, "resolver", "resolvers")
);
let until = Instant::now() + patience;
self.asking.insert(ip, Asking { ids, until });
}
Err(e) => error!("reverse query for {ip} failed: {e}"),
}
}
}
fn hurry(&mut self, until: Instant) {
for asking in self.asking.values_mut() {
asking.until = asking.until.min(until);
}
}
fn expire(&mut self, now: Instant) {
let expired: Vec<IpAddr> = self
.asking
.iter()
.filter(|(_, asking)| asking.until <= now)
.map(|(ip, _)| *ip)
.collect();
for ip in expired {
let Some(asking) = self.asking.remove(&ip) else {
continue;
};
for id in asking.ids {
let Some(query) = self.dns_map.get(&id) else {
continue;
};
let target = &mut self.query_targets[query.target];
let was_asked = target.is_asked();
target.unanswered += 1;
if was_asked && !target.is_asked() {
info!(
verbosity = 1,
"{} answered no reverse query; asking it no more", target.server
);
}
}
}
}
async fn send_dns_query(&mut self, ip: &IpAddr) -> std::io::Result<Vec<TransID>> {
let name = reverse_name(*ip);
let scope = self
.scopes
.iter()
.position(|scope| covers(&scope.domain, &name));
if let Some(scope) = scope.map(|index| &mut self.scopes[index])
&& let Some(why) = &scope.unasked
{
if !scope.said {
scope.said = true;
warn!("DNS for {} not asked ({why})", scope.domain);
}
return Ok(Vec::new());
}
let mut sent = Vec::with_capacity(self.query_targets.len());
let mut last_error = None;
for (index, target) in self.query_targets.iter().enumerate() {
if target.scope != scope || !target.is_asked() {
continue;
}
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, index)),
Err(error) => {
last_error = Some(std::io::Error::new(
error.kind(),
format!("{}: {error}", target.server),
));
}
}
}
if let (true, Some(error)) = (sent.is_empty(), last_error) {
return Err(error);
}
for (id, target) in sent.iter().copied() {
self.dns_map.insert(id, Query { ip: *ip, target });
}
Ok(sent.into_iter().map(|(id, _)| id).collect())
}
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());
for target in self.query_targets.iter_mut().filter(|t| t.server == from) {
target.answered = true;
}
let Some(Query { ip, target }) = self.dns_map.get(&response.id).copied() else {
return;
};
if self.query_targets[target].server != from || response.subject != Some(ip) {
return;
}
self.dns_map.remove(&response.id);
if let Some(asking) = self.asking.get_mut(&ip) {
asking.ids.retain(|id| *id != response.id);
if asking.ids.is_empty() {
self.asking.remove(&ip);
}
}
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, Option<usize>)],
scopes: &[ReverseScope],
) -> Vec<QueryTarget> {
let addresses: Vec<SocketAddr> = servers.iter().map(|(at, _)| *at).collect();
let v4 = bind_family(&addresses, SocketAddr::is_ipv4, "0.0.0.0:0");
let v6 = bind_family(&addresses, SocketAddr::is_ipv6, "[::]:0");
let targets: Vec<QueryTarget> = servers
.iter()
.filter_map(|&(server, scope)| {
let socket = if server.is_ipv4() { &v4 } else { &v6 };
Some(QueryTarget {
server,
scope,
socket: Arc::clone(socket.as_ref()?),
answered: false,
unanswered: 0,
})
})
.collect();
if !targets.is_empty() {
info!(
verbosity = 1,
"reverse queries go to {}",
targets
.iter()
.map(|t| match t.scope {
Some(scope) => format!("{} (for {})", t.server, scopes[scope].domain),
None => t.server.to_string(),
})
.collect::<Vec<_>>()
.join(", ")
);
}
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)
}
struct ReverseScope {
domain: String,
unasked: Option<String>,
said: bool,
}
struct Routes {
hosts: HostsTable,
servers: Vec<(SocketAddr, Option<usize>)>,
scopes: Vec<ReverseScope>,
}
impl Routes {
fn from_system() -> Self {
Self::of(
HostsTable::read_system(),
DnsConfig::read_system(),
gateways(),
)
}
fn of(hosts: HostsTable, dns: DnsConfig, gateways: Vec<SocketAddr>) -> Self {
let mut servers = Vec::new();
match &dns.global {
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), None));
}
}
}
Err(why) if gateways.is_empty() => {
warn!("DNS lookups skipped (no DNS server configured)");
info!(
verbosity = 1,
"system resolver configuration unusable: {why}"
);
}
Err(why) => info!(
verbosity = 1,
"system resolver configuration unusable: {why}; asking gateways"
),
}
for gateway in gateways {
push_unique(&mut servers, (gateway, None));
}
let mut scoped: Vec<ScopedServers> = dns
.scoped
.into_iter()
.filter(|scope| scope.domain.ends_with(".arpa"))
.collect();
scoped.sort_by_key(|scope| std::cmp::Reverse(scope.domain.len()));
let mut scopes = Vec::with_capacity(scoped.len());
for (index, scope) in scoped.into_iter().enumerate() {
let unasked = match scope.servers {
Ok(zone_servers) => {
for at in zone_servers {
push_unique(&mut servers, (at, Some(index)));
}
None
}
Err(why) => Some(why),
};
scopes.push(ReverseScope {
domain: scope.domain,
unasked,
said: false,
});
}
Self {
hosts,
servers,
scopes,
}
}
}
fn gateways() -> Vec<SocketAddr> {
let mut servers = Vec::new();
for gateway in crate::system::interface::host_table()
.unwrap_or_default()
.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<T: PartialEq>(servers: &mut Vec<T>, server: T) {
if !servers.contains(&server) {
servers.push(server);
}
}
pub async fn resolve_hosts_async(ctx: &ScanContext) {
resolve(ctx, Unheard::Skipped).await;
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) enum Unheard {
Skipped,
Named,
}
fn to_resolve(ctx: &ScanContext, unheard: Unheard) -> Vec<crate::model::ip::scoped::ScopedIp> {
ctx.hosts_owed_passes()
.into_iter()
.filter(|key| {
ctx.read_host(key, |host| {
host.hostname().is_none()
&& (unheard == Unheard::Named
|| host.status() != crate::model::host::HostStatus::Unknown)
})
.unwrap_or(false)
})
.collect()
}
const REVERSE_LOOKUPS_IN_FLIGHT: usize = 32;
pub(crate) async fn resolve(ctx: &ScanContext, unheard: Unheard) {
let snapshot = Arc::new(crate::resolve::Resolver::from_system().snapshot());
resolve_from(ctx, unheard, snapshot).await;
}
async fn resolve_from(ctx: &ScanContext, unheard: Unheard, snapshot: Arc<Snapshot>) {
let routing = Arc::clone(&snapshot);
resolve_with(
ctx,
unheard,
REVERSE_LOOKUPS_IN_FLIGHT,
move |ip| routing.reverse_route(ip),
move |ip| {
let snapshot = Arc::clone(&snapshot);
async move { snapshot.reverse(ip).await }
},
)
.await;
}
async fn resolve_with<R, F, Fut>(
ctx: &ScanContext,
unheard: Unheard,
in_flight: usize,
route: impl Fn(IpAddr) -> R,
lookup: F,
) where
R: PartialEq,
F: Fn(IpAddr) -> Fut,
Fut: Future<Output = Reverse> + Send + 'static,
{
let in_flight = in_flight.max(1);
let mut routes: Vec<(R, Route)> = Vec::new();
for key in to_resolve(ctx, unheard) {
let way = route(key.addr());
match routes.iter_mut().find(|(known, _)| *known == way) {
Some((_, route)) => route.waiting.push_back(key),
None => routes.push((way, Route::holding(key))),
}
}
let mut set = tokio::task::JoinSet::new();
let mut spawned = std::collections::HashMap::new();
let mut turn = 0;
loop {
while set.len() < in_flight
&& let Some(index) = (0..routes.len())
.map(|offset| (turn + offset) % routes.len())
.find(|&index| routes[index].1.is_asked(in_flight))
{
turn = index + 1;
let route = &mut routes[index].1;
let Some(key) = route.waiting.pop_front() else {
break;
};
route.in_flight += 1;
let asked = lookup(key.addr());
let task = set.spawn(async move { (key, asked.await) });
spawned.insert(task.id(), index);
}
let Some(Some(joined)) = ctx.handle.or_stopped(set.join_next_with_id()).await else {
break;
};
let id = match &joined {
Ok((id, _)) => *id,
Err(error) => error.id(),
};
let Some(route) = spawned.remove(&id).map(|index| &mut routes[index].1) else {
continue;
};
route.in_flight -= 1;
let Ok((_, (key, reverse))) = joined else {
continue;
};
let name = match reverse {
Reverse::Listed(name) => name,
Reverse::Named(name) => {
route.answered = true;
name
}
Reverse::Unnamed => {
route.answered = true;
continue;
}
Reverse::Unanswered => {
route.unanswered += 1;
continue;
}
Reverse::Unasked => continue,
};
name_host(ctx, key, &name);
}
let unasked: usize = routes.iter().map(|(_, route)| route.waiting.len()).sum();
if unasked > 0 && !ctx.handle.should_stop() {
info!(
verbosity = 1,
"{} not looked up (resolver not answering)",
counted(unasked as u128, "name", "names")
);
}
}
pub(crate) fn name_from_hosts_file(ctx: &ScanContext, unheard: Unheard) {
name_listed(ctx, unheard, &HostsTable::read_system());
}
fn name_listed(ctx: &ScanContext, unheard: Unheard, hosts: &HostsTable) {
for key in to_resolve(ctx, unheard) {
if let Some(name) = hosts.name_of(key.addr()) {
let name = name.to_owned();
name_host(ctx, key, &name);
}
}
}
fn name_host(ctx: &ScanContext, key: crate::model::ip::scoped::ScopedIp, name: &str) {
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()
);
return;
}
ctx.write_host(key, |host| {
host.set_hostname(Some(name));
true
});
}
struct Route {
waiting: std::collections::VecDeque<crate::model::ip::scoped::ScopedIp>,
in_flight: usize,
answered: bool,
unanswered: usize,
}
impl Route {
fn holding(key: crate::model::ip::scoped::ScopedIp) -> Self {
Self {
waiting: std::collections::VecDeque::from([key]),
in_flight: 0,
answered: false,
unanswered: 0,
}
}
fn is_asked(&self, window: usize) -> bool {
!self.waiting.is_empty() && (self.answered || self.unanswered + self.in_flight < window)
}
}
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) => !ipv4_addr.is_loopback(),
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::model::host::HostStatus;
use crate::scanner::session::{ScanEvent, ScanSession};
use crate::testing::loopback::SilentUdpPort;
use crate::transport::probe::{Emission, ProbeSender, SendError};
use std::net::Ipv4Addr;
use tokio::sync::mpsc::UnboundedSender;
#[test]
fn a_reverse_lookup_names_only_the_hosts_that_answered_unless_asked_for_all() {
let (_session, ctx) = ScanSession::new();
let at = |last| IpAddr::V4(Ipv4Addr::new(192, 0, 2, last));
ctx.update_host(at(1), |host| host.set_status(HostStatus::Up));
ctx.update_host(at(2), |_| {});
ctx.update_host(at(3), |host| {
host.set_status(HostStatus::Up);
host.set_hostname(Some("named.example".to_string()));
});
let asked = |unheard| -> Vec<IpAddr> {
let mut asked: Vec<IpAddr> = to_resolve(&ctx, unheard)
.iter()
.map(|key| key.addr())
.collect();
asked.sort_unstable();
asked
};
assert_eq!(asked(Unheard::Skipped), [at(1)]);
assert_eq!(asked(Unheard::Named), [at(1), at(2)]);
}
#[tokio::test]
async fn reverse_lookups_are_bounded_in_flight_and_every_answer_is_read() {
use std::sync::atomic::AtomicUsize;
const BOUND: usize = 4;
let (session, ctx) = ScanSession::new();
let at = |last| IpAddr::V4(Ipv4Addr::new(192, 0, 2, last));
for last in 1..=40 {
ctx.update_host(at(last), |host| host.set_status(HostStatus::Up));
}
let in_flight = Arc::new(AtomicUsize::new(0));
let most = Arc::new(AtomicUsize::new(0));
resolve_with(
&ctx,
Unheard::Skipped,
BOUND,
|_| (),
|ip| {
let (in_flight, most) = (Arc::clone(&in_flight), Arc::clone(&most));
async move {
let now = in_flight.fetch_add(1, Ordering::SeqCst) + 1;
most.fetch_max(now, Ordering::SeqCst);
let IpAddr::V4(v4) = ip else {
return Reverse::Unnamed;
};
let last = v4.octets()[3];
let wait = if last % 2 == 0 { 1 } else { 5 };
tokio::time::sleep(Duration::from_millis(wait)).await;
in_flight.fetch_sub(1, Ordering::SeqCst);
match last % 2 {
1 => Reverse::Named(format!("host{last}.example.")),
_ => Reverse::Unnamed,
}
}
},
)
.await;
assert!(
most.load(Ordering::SeqCst) <= BOUND,
"{} lookups in flight at once",
most.load(Ordering::SeqCst)
);
let named = (1..=40)
.filter(|last| {
session
.hosts()
.read(at(*last), |host| host.hostname().is_some())
.unwrap_or(false)
})
.count();
assert_eq!(named, 20, "every host with a name was named");
}
#[tokio::test]
async fn with_no_dns_server_configured_the_hosts_file_still_names_hosts() {
let (_session, ctx) = ScanSession::new();
for last in [1, 2] {
ctx.update_host(IpAddr::V4(Ipv4Addr::new(192, 0, 2, last)), |host| {
host.set_status(HostStatus::Up)
});
}
let snapshot = crate::resolve::Resolver::given(Default::default(), || {
(
"192.0.2.1 box.example\n".to_string(),
DnsConfig {
global: Err("no nameservers found in config".into()),
scoped: Vec::new(),
},
)
})
.snapshot();
resolve_from(&ctx, Unheard::Skipped, Arc::new(snapshot)).await;
let name = |last| {
ctx.read_host(IpAddr::V4(Ipv4Addr::new(192, 0, 2, last)), |host| {
host.hostname().map(str::to_owned)
})
.flatten()
};
assert_eq!(name(1).as_deref(), Some("box.example"));
assert_eq!(name(2), None);
}
#[test]
fn the_hosts_file_names_found_hosts_without_a_query() {
let (_session, ctx) = ScanSession::new();
for last in [1, 2] {
ctx.update_host(v4(192, 0, 2, last), |host| host.set_status(HostStatus::Up));
}
ctx.update_host(v4(192, 0, 2, 3), |_| {});
let hosts = HostsTable::parse("192.0.2.1 box.example\n192.0.2.3 silent.example\n");
name_listed(&ctx, Unheard::Skipped, &hosts);
let name = |last| {
ctx.read_host(v4(192, 0, 2, last), |host| {
host.hostname().map(str::to_owned)
})
.flatten()
};
assert_eq!(name(1).as_deref(), Some("box.example"));
assert_eq!(name(2), None, "an unlisted host was named");
assert_eq!(name(3), None, "a host nothing was heard from was named");
}
#[tokio::test]
async fn a_stopped_scan_stops_looking_names_up() {
let (session, ctx) = ScanSession::new();
for last in 1..=4 {
ctx.update_host(IpAddr::V4(Ipv4Addr::new(192, 0, 2, last)), |host| {
host.set_status(HostStatus::Up)
});
}
let handle = session.handle().clone();
let stopper = tokio::spawn(async move {
tokio::task::yield_now().await;
handle.abort();
});
tokio::time::timeout(
Duration::from_secs(60),
resolve_with(
&ctx,
Unheard::Skipped,
2,
|_| (),
|_| std::future::pending::<Reverse>(),
),
)
.await
.expect("the stop ended the lookups");
stopper.await.expect("the stop was asked for");
}
#[tokio::test]
async fn a_resolver_that_answers_nothing_is_asked_one_window() {
use std::sync::atomic::AtomicUsize;
const BOUND: usize = 4;
let asked = |first_answers: bool| {
let asked = Arc::new(AtomicUsize::new(0));
let counted = Arc::clone(&asked);
let (_session, ctx) = ScanSession::new();
for last in 1..=40 {
ctx.update_host(IpAddr::V4(Ipv4Addr::new(192, 0, 2, last)), |host| {
host.set_status(HostStatus::Up)
});
}
async move {
resolve_with(
&ctx,
Unheard::Skipped,
BOUND,
|_| (),
move |_| {
let n = counted.fetch_add(1, Ordering::SeqCst);
async move {
match (first_answers, n) {
(true, 0) => Reverse::Unnamed,
_ => Reverse::Unanswered,
}
}
},
)
.await;
asked.load(Ordering::SeqCst)
}
};
assert_eq!(asked(false).await, BOUND, "a silent resolver was asked on");
assert_eq!(asked(true).await, 40, "one that answered was given up on");
}
#[tokio::test]
async fn a_silent_global_resolver_leaves_a_scoped_zone_asked() {
use std::sync::atomic::AtomicUsize;
const BOUND: usize = 4;
let (_session, ctx) = ScanSession::new();
for last in 1..=20 {
for network in [[192, 0, 2], [203, 0, 113]] {
ctx.update_host(v4(network[0], network[1], network[2], last), |host| {
host.set_status(HostStatus::Up)
});
}
}
let scoped = |ip: IpAddr| matches!(ip, IpAddr::V4(v4) if v4.octets()[0] == 203);
let asked_global = Arc::new(AtomicUsize::new(0));
let counted = Arc::clone(&asked_global);
resolve_with(&ctx, Unheard::Skipped, BOUND, scoped, move |ip| {
if !scoped(ip) {
counted.fetch_add(1, Ordering::SeqCst);
}
async move {
if scoped(ip) {
Reverse::Named("box.corp.example.".into())
} else {
Reverse::Unanswered
}
}
})
.await;
let named = (1..=20)
.filter(|&last| {
ctx.read_host(v4(203, 0, 113, last), |host| host.hostname().is_some())
.unwrap_or(false)
})
.count();
assert_eq!(named, 20, "the scoped zone stopped being asked");
assert_eq!(
asked_global.load(Ordering::SeqCst),
BOUND,
"the silent resolver was asked past its window"
);
}
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> {
answer(&dns::build_ptr_packet(subject, 0x1234), name)
}
fn answer(query: &[u8], name: &str) -> Vec<u8> {
let mut message = query.to_vec();
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
}
fn resolver_fed(server: SocketAddr) -> (UnboundedSender<IpAddr>, HostnameResolver) {
let (tx, dns_rx) = tokio::sync::mpsc::unbounded_channel();
let (_, reply_rx) = tokio::sync::mpsc::channel(1);
let resolver = HostnameResolver::with_transport(
dns_rx,
ProbeTransport::from_parts(Box::new(Silent), reply_rx),
vec![server],
)
.expect("a query target binds");
(tx, resolver)
}
fn resolver_routed(routes: Routes) -> (UnboundedSender<IpAddr>, HostnameResolver) {
let (tx, dns_rx) = tokio::sync::mpsc::unbounded_channel();
let (_, reply_rx) = tokio::sync::mpsc::channel(1);
let resolver = HostnameResolver::with_routes(
dns_rx,
ProbeTransport::from_parts(Box::new(Silent), reply_rx),
routes,
)
.expect("the resolver builds");
(tx, resolver)
}
fn questions_asked(server: &SilentUdpPort) -> Vec<String> {
server
.datagrams()
.into_iter()
.filter_map(|datagram| {
let message = hickory_resolver::proto::op::Message::from_vec(&datagram).ok()?;
Some(message.queries.first()?.name().to_ascii())
})
.collect()
}
#[tokio::test]
async fn an_address_under_a_scoped_reverse_zone_is_asked_of_its_servers_alone() {
let (global, scoped) = (SilentUdpPort::open(), SilentUdpPort::open());
let (global_at, scoped_at) = (global.addr(), scoped.addr());
let routes = Routes {
hosts: HostsTable::default(),
servers: vec![(global_at, None), (scoped_at, Some(0))],
scopes: vec![
ReverseScope {
domain: "100.51.198.in-addr.arpa".into(),
unasked: None,
said: false,
},
ReverseScope {
domain: "2.0.192.in-addr.arpa".into(),
unasked: Some("utun9 not found".into()),
said: false,
},
],
};
let (tx, resolver) = resolver_routed(routes);
for ip in [v4(198, 51, 100, 7), v4(203, 0, 113, 7), v4(192, 0, 2, 7)] {
tx.send(ip).expect("the resolver is listening");
}
drop(tx);
tokio::time::timeout(Duration::from_secs(60), resolver.run())
.await
.expect("the resolver finishes");
assert_eq!(questions_asked(&scoped), vec!["7.100.51.198.in-addr.arpa."]);
assert_eq!(questions_asked(&global), vec!["7.113.0.203.in-addr.arpa."]);
}
#[tokio::test]
async fn an_address_the_hosts_file_lists_is_named_without_a_query() {
let server = SilentUdpPort::open();
let at = server.addr();
let routes = Routes {
hosts: HostsTable::parse("198.51.100.23 box.example\n"),
servers: vec![(at, None)],
scopes: Vec::new(),
};
let (tx, resolver) = resolver_routed(routes);
for ip in [v4(198, 51, 100, 23), v4(127, 0, 0, 9)] {
tx.send(ip).expect("the resolver is listening");
}
drop(tx);
let resolver = tokio::time::timeout(Duration::from_secs(60), resolver.run())
.await
.expect("the resolver finishes");
assert_eq!(questions_asked(&server), Vec::<String>::new());
let named = resolver.hostname_map.get(&v4(198, 51, 100, 23));
assert_eq!(
named.map(|n| (n.hostname.as_str(), n.heard)),
Some(("box.example", Heard::Listed))
);
assert!(!resolver.hostname_map.contains_key(&v4(127, 0, 0, 9)));
}
#[tokio::test]
async fn the_privileged_resolver_asks_about_a_bounded_number_of_addresses_at_once() {
let server = SilentUdpPort::open();
let (tx, resolver) = resolver_fed(server.addr());
for last in 1..=100 {
tx.send(v4(198, 51, 100, last))
.expect("the resolver is listening");
}
let running = tokio::spawn(resolver.run());
server.arrived(REVERSE_LOOKUPS_IN_FLIGHT).await;
tokio::time::sleep(QUERY_PATIENCE / 10).await;
assert_eq!(
server.datagrams().len(),
REVERSE_LOOKUPS_IN_FLIGHT,
"more than {REVERSE_LOOKUPS_IN_FLIGHT} addresses were asked about at once"
);
drop(tx);
tokio::time::timeout(Duration::from_secs(60), running)
.await
.expect("the resolver finishes")
.expect("the resolver does not panic");
}
#[tokio::test]
async fn a_resolver_that_answers_nothing_is_asked_one_window_and_no_more() {
let server = SilentUdpPort::open();
let (tx, resolver) = resolver_fed(server.addr());
for last in 1..=100 {
tx.send(v4(198, 51, 100, last))
.expect("the resolver is listening");
}
drop(tx);
tokio::time::timeout(Duration::from_secs(60), resolver.run())
.await
.expect("the resolver finishes");
assert_eq!(server.datagrams().len(), REVERSE_LOOKUPS_IN_FLIGHT);
}
#[tokio::test]
async fn every_address_behind_the_bound_is_asked_and_named() {
let server = Arc::new(
UdpSocket::bind("127.0.0.1:0")
.await
.expect("a loopback socket binds"),
);
let at = server.local_addr().expect("a bound socket has an address");
let answering = Arc::clone(&server);
let answerer = tokio::spawn(async move {
let mut buf = [0u8; MAX_DNS_DATAGRAM];
loop {
let (len, from) =
crate::testing::loopback::recv_from_this_process(&answering, &mut buf)
.await
.expect("a query reads");
let reply = answer(&buf[..len], "host.example.com");
answering
.send_to(&reply, from)
.await
.expect("a reply sends");
}
});
let (tx, resolver) = resolver_fed(at);
for last in 1..=100 {
tx.send(v4(198, 51, 100, last))
.expect("the resolver is listening");
}
drop(tx);
let resolver = tokio::time::timeout(Duration::from_secs(60), resolver.run())
.await
.expect("the resolver finishes");
answerer.abort();
assert_eq!(resolver.hostname_map.len(), 100);
}
#[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, Query { ip, target: 0 });
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 (target, (server, name)) in
[(first, "first.example.com"), (second, "second.example.com")]
.into_iter()
.enumerate()
{
resolver.dns_map.insert(0x1234, Query { ip, target });
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")
);
}
}