use hickory_resolver::config::ProtocolConfig;
use hickory_resolver::system_conf::read_system_conf;
use std::net::SocketAddr;
use std::{
collections::{HashMap, HashSet},
net::IpAddr,
sync::atomic::{AtomicU16, Ordering},
time::Duration,
};
use crate::protocols::{
dns,
mdns::{self, MdnsHost},
};
use crate::scanner::session::ScanContext;
use crate::{error, info, model::ip, warn};
use anyhow::Context;
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};
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;
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, Hostname>,
dns_rx: UnboundedReceiver<IpAddr>,
id_counter: AtomicU16,
}
impl HostnameResolver {
pub fn new(dns_rx: UnboundedReceiver<IpAddr>) -> anyhow::Result<Self> {
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>,
) -> anyhow::Result<Self> {
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(),
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),
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),
None => sniffing = false,
}
}
}
}
})
.await;
}
while let Ok(reply) = self.transport.rx.try_recv() {
self.absorb_sniffed(&reply.bytes);
}
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 = 1,
"Reverse query for {ip} sent to {count} resolver(s)"
),
Err(e) => error!("Reverse query for {ip} failed: {e}"),
}
}
async fn send_dns_query(&mut self, ip: &IpAddr) -> anyhow::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();
match dns::create_ptr_packet(ip, id) {
Ok(packet) => match target.socket.send_to(&packet, target.server).await {
Ok(_) => sent.push(id),
Err(e) => last_error = Some(anyhow::Error::from(e).context(target.server)),
},
Err(e) => last_error = Some(e),
}
}
if sent.is_empty() {
return Err(last_error.unwrap_or_else(|| anyhow::anyhow!("no resolver to query")));
}
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;
}
};
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) => {
info!(
incoming,
verbosity = 1,
"{from} resolved {ip} to {hostname}"
);
self.hostname_map.entry(ip).or_insert(hostname);
}
None => info!(verbosity = 2, "{from} has no name for {ip}"),
}
}
fn absorb_sniffed(&mut self, segment: &[u8]) {
let Some(udp_packet) = UdpPacket::new(segment) else {
return;
};
match udp_packet.get_source() {
DNS_PORT => 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 self.hostname_map.insert(ip, hostname.clone()).is_none() {
info!(verbosity = 1, "Overheard {ip} named {hostname}");
}
}
fn absorb_sniffed_mdns(&mut self, payload: &[u8]) {
let Ok(hosts) = mdns::extract_hosts(payload) else {
return;
};
for host in hosts {
let Some(ip) = preferred_ip(&host) else {
continue;
};
info!(verbosity = 1, "mDNS names {ip} as {}", host.hostname);
self.mdns_cache.insert(ip, host);
}
}
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);
ctx.write_host(key, |host| {
let mut named = false;
for ip in host.ips().clone() {
if host.hostname().is_none()
&& let Some(hostname) = hostname_map.remove(&ip)
{
host.set_hostname(Some(hostname));
named = true;
}
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 preferred_ip(host: &MdnsHost) -> Option<IpAddr> {
host.ips
.iter()
.find(|ip| ip.is_ipv4())
.or_else(|| {
host.ips.iter().find(|ip| match ip {
IpAddr::V6(v6) => v6.is_unicast_link_local(),
IpAddr::V4(_) => false,
})
})
.or_else(|| host.ips.iter().next())
.copied()
}
fn bind_query_targets(servers: &[SocketAddr]) -> anyhow::Result<Vec<QueryTarget>> {
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() {
anyhow::bail!("no reachable DNS server to send reverse queries to");
}
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) -> anyhow::Result<UdpSocket> {
let socket =
std::net::UdpSocket::bind(bind_addr).with_context(|| format!("binding {bind_addr}"))?;
socket.set_nonblocking(true)?;
Ok(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 ip 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(ip).await
&& let Some(name) = lookup.answers().iter().find_map(|r| match &r.data {
RData::PTR(ptr) => Some(ptr.to_string()),
_ => None,
})
{
return (ip, Some(name));
}
(ip, None)
});
}
while let Some(Ok((ip, Some(name)))) = set.join_next().await {
ctx.write_host(ip, |host| {
host.set_hostname(Some(name.trim_end_matches('.').to_string()));
true
});
}
}
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::{ProbeSender, SendError};
use std::net::Ipv4Addr;
struct Silent;
impl ProbeSender for Silent {
fn send(&self, _: &[u8], _: IpAddr, _: IpAddr) -> Result<(), SendError> {
Ok(())
}
}
fn resolver_holding(ip: IpAddr, hostname: &str) -> HostnameResolver {
let (_tx, dns_rx) = tokio::sync::mpsc::unbounded_channel();
let (_reply_tx, reply_rx) = tokio::sync::mpsc::unbounded_channel();
let mut resolver = HostnameResolver::with_transport(
dns_rx,
ProbeTransport::from_parts(Box::new(Silent), reply_rx),
vec!["127.0.0.1:53".parse().expect("a valid socket address")],
)
.expect("a loopback query target binds");
resolver.hostname_map.insert(ip, hostname.to_string());
resolver
}
#[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 == 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");
}
}