use std::net::{IpAddr, SocketAddr};
use std::time::Duration;
use tokio::net::TcpStream;
use tokio::task::JoinSet;
use tokio::time::timeout;
use crate::core::models::port::{Port, PortState, Protocol, Service};
use crate::core::session::{ScanContext, ScanEvent};
const CONNECT_TIMEOUT: Duration = Duration::from_millis(1_000);
const CONCURRENCY: usize = 50;
pub async fn detect(ctx: &ScanContext) {
let targets = open_tcp_ports(ctx);
if targets.is_empty() {
return;
}
let mut set: JoinSet<Option<(IpAddr, Port)>> = JoinSet::new();
let mut targets = targets.into_iter();
loop {
while set.len() < CONCURRENCY {
if ctx.handle.should_stop() {
break;
}
let Some((ip, port)) = targets.next() else {
break;
};
set.spawn(fingerprint_one(ip, port));
}
match set.join_next().await {
Some(joined) => {
if let Ok(Some((ip, port))) = joined {
write_back(ctx, ip, port);
}
}
None => break,
}
}
}
fn open_tcp_ports(ctx: &ScanContext) -> Vec<(IpAddr, u16)> {
let mut targets = Vec::new();
for host in ctx.store.iter() {
let ip = *host.key();
for port in host.value().ports() {
if port.protocol() == Protocol::Tcp && port.state() == PortState::Open {
targets.push((ip, port.number()));
}
}
}
targets
}
async fn fingerprint_one(ip: IpAddr, port_number: u16) -> Option<(IpAddr, Port)> {
let addr = SocketAddr::new(ip, port_number);
let stream = timeout(CONNECT_TIMEOUT, TcpStream::connect(addr))
.await
.ok()?
.ok()?;
let mut port = Port::new(port_number, Protocol::Tcp, PortState::Open);
port.set_service(Service::new(
crate::fingerprinting::lookup_service_name(port_number, Protocol::Tcp)
.unwrap_or_else(|| "???".to_string()),
0,
));
let port = crate::fingerprinting::fingerprint_tcp(stream, port).await;
Some((ip, port))
}
fn write_back(ctx: &ScanContext, ip: IpAddr, port: Port) {
if let Some(mut host) = ctx.store.get_mut(&ip) {
host.add_port(port);
}
let _ = ctx.events_tx.send(ScanEvent::HostUpdated(ip));
}
#[cfg(test)]
mod tests {
use super::*;
use crate::core::models::host::Host;
use crate::core::session::ScanSession;
use tokio::io::AsyncWriteExt;
use tokio::net::TcpListener;
#[tokio::test]
async fn detect_fingerprints_an_open_tcp_port_end_to_end() {
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
let addr = listener.local_addr().unwrap();
tokio::spawn(async move {
if let Ok((mut sock, _)) = listener.accept().await {
let _ = sock.write_all(b"SSH-2.0-OpenSSH_9.6p1 Debian-3\r\n").await;
}
});
let (session, ctx) = ScanSession::new();
let ip = addr.ip();
let mut host = Host::new(ip);
host.add_port(Port::new(addr.port(), Protocol::Tcp, PortState::Open));
session.store.insert(ip, host);
detect(&ctx).await;
let host = session.store.get(&ip).unwrap();
let port = host
.ports()
.find(|p| p.number() == addr.port())
.expect("port present");
let service = port.service().expect("service identified");
assert_eq!(service.name(), "ssh");
assert_eq!(service.product(), Some("OpenSSH"));
assert_eq!(service.version(), Some("9.6p1"));
}
#[tokio::test]
async fn detect_is_a_no_op_with_no_open_ports() {
let (session, ctx) = ScanSession::new();
let ip: IpAddr = "127.0.0.1".parse().unwrap();
let mut host = Host::new(ip);
host.add_port(Port::new(9, Protocol::Tcp, PortState::Closed));
session.store.insert(ip, host);
detect(&ctx).await;
let host = session.store.get(&ip).unwrap();
let port = host.ports().find(|p| p.number() == 9).unwrap();
assert!(port.service().is_none());
}
}