use std::collections::HashMap;
use std::net::IpAddr;
use std::time::Instant;
use async_trait::async_trait;
use pnet::packet::tcp::TcpPacket;
use tokio::sync::mpsc;
use crate::core::config::SendMode;
use crate::core::models::deadline::AdaptiveDeadline;
use crate::core::models::port::{PortState, Protocol};
use crate::core::models::target::Target;
use crate::core::session::{ScanContext, ScannerKind};
use crate::error;
use crate::network::probe::{ProbeKind, ProbeTransport};
use crate::protocols::tcp::{self, ProbeResponse};
use crate::scanner::{PortScanner, service};
use crate::system::interface::SourceResolver;
use super::{DEADLINE_CONFIG, SeqNum, send_syn};
type PendingProbes = HashMap<(IpAddr, u16), (SeqNum, Instant)>;
pub struct SynPortScanner {
resolver: SourceResolver,
ctx: ScanContext,
transport: ProbeTransport,
deadline: AdaptiveDeadline,
pending: PendingProbes,
}
impl SynPortScanner {
pub fn new(
resolver: SourceResolver,
ctx: ScanContext,
target_count: usize,
send_mode: SendMode,
) -> anyhow::Result<Self> {
let transport = ProbeTransport::open_with(ProbeKind::TcpSyn, send_mode)?;
let deadline = AdaptiveDeadline::new(DEADLINE_CONFIG, target_count);
Ok(Self {
resolver,
ctx,
transport,
deadline,
pending: PendingProbes::new(),
})
}
#[cfg(test)]
pub(crate) fn with_transport(
resolver: SourceResolver,
ctx: ScanContext,
transport: ProbeTransport,
target_count: usize,
) -> Self {
Self {
resolver,
ctx,
transport,
deadline: AdaptiveDeadline::new(DEADLINE_CONFIG, target_count),
pending: PendingProbes::new(),
}
}
fn send_probe(&mut self, target: Target) {
if target.protocol != Protocol::Tcp {
return;
}
let Some(src_addr) = self.resolver.resolve(target.ip) else {
error!(
verbosity = 2,
"No route to {}; skipping {}:{}", target.ip, target.ip, target.port
);
return;
};
if let Some(seq_num) =
send_syn(self.transport.tx.as_ref(), src_addr, target.ip, target.port)
{
self.pending
.insert((target.ip, target.port), (seq_num, Instant::now()));
}
}
fn handle_reply(&mut self, ip: IpAddr, bytes: &[u8]) {
let Some(tcp_packet) = TcpPacket::new(bytes) else {
return;
};
let key = (ip, tcp_packet.get_source());
let Some(&(sent_seq, sent_at)) = self.pending.get(&key) else {
return;
};
if tcp_packet.get_acknowledgement().wrapping_sub(1) != sent_seq {
return;
}
let Some(response) = tcp::classify_probe_response(&tcp_packet) else {
return;
};
self.pending.remove(&key);
self.deadline.mark_activity();
self.deadline.record_rtt(sent_at.elapsed());
let state = match response {
ProbeResponse::Open => PortState::Open,
ProbeResponse::Closed => PortState::Closed,
};
self.record_port(ip, key.1, state);
}
fn resolve_remaining_as_filtered(&mut self) {
let remaining: Vec<(IpAddr, u16)> = self.pending.drain().map(|(key, _)| key).collect();
for (ip, port) in remaining {
self.record_port(ip, port, PortState::Filtered);
}
}
fn record_port(&mut self, ip: IpAddr, port_num: u16, state: PortState) {
let port = crate::fingerprinting::baseline_port(port_num, Protocol::Tcp, state);
self.ctx.update_host(ip, |host| host.add_port(port));
}
}
#[async_trait]
impl PortScanner for SynPortScanner {
fn kind(&self) -> ScannerKind {
ScannerKind::SynPort
}
fn supported_protocols(&self) -> Vec<Protocol> {
vec![Protocol::Tcp]
}
async fn scan(&mut self, mut targets: mpsc::Receiver<Target>) -> anyhow::Result<()> {
let mut sending_finished = false;
loop {
if self.ctx.handle.should_stop() || self.deadline.has_expired() {
break;
}
if sending_finished && self.pending.is_empty() {
break;
}
tokio::select! {
target = targets.recv(), if !sending_finished => {
match target {
Some(target) => self.send_probe(target),
None => sending_finished = true,
}
}
res = self.transport.rx.recv() => {
match res {
Some((bytes, ip)) => self.handle_reply(ip, &bytes),
None => break,
}
}
_ = tokio::time::sleep(self.deadline.time_until_next_tick()) => {}
}
}
self.resolve_remaining_as_filtered();
Ok(())
}
async fn detect_services(&mut self, ctx: &ScanContext) {
service::detect(ctx).await;
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::net::Ipv4Addr;
use pnet::ipnetwork::{IpNetwork, Ipv4Network};
use pnet::packet::tcp::MutableTcpPacket;
use crate::core::session::ScanSession;
use crate::network::capture::CaptureGuard;
use crate::network::probe::{MockSender, ProbeTransport};
const SYN: u8 = 1 << 1;
const RST: u8 = 1 << 2;
const ACK: u8 = 1 << 4;
const TARGET: IpAddr = IpAddr::V4(Ipv4Addr::new(192, 168, 1, 200));
fn on_link_interface() -> pnet::datalink::NetworkInterface {
pnet::datalink::NetworkInterface {
name: "test0".to_string(),
description: String::new(),
index: 0,
mac: None,
ips: vec![IpNetwork::V4(
Ipv4Network::new(Ipv4Addr::new(192, 168, 1, 50), 24).unwrap(),
)],
flags: 0,
}
}
fn tcp_segment(src_port: u16, ack: u32, flags: u8) -> Vec<u8> {
let mut buf = vec![0u8; 20];
let mut tcp = MutableTcpPacket::new(&mut buf).unwrap();
tcp.set_source(src_port);
tcp.set_destination(40_000);
tcp.set_data_offset(5);
tcp.set_acknowledgement(ack);
tcp.set_flags(flags);
buf
}
fn scanner_with_mock() -> (SynPortScanner, ScanSession) {
let (session, ctx) = ScanSession::new();
let (_reply_tx, reply_rx) = tokio::sync::mpsc::unbounded_channel();
let transport = ProbeTransport::from_parts(
Box::new(MockSender::default()),
reply_rx,
CaptureGuard::noop(),
);
let resolver = SourceResolver::from_interfaces(&[on_link_interface()]);
let scanner = SynPortScanner::with_transport(resolver, ctx, transport, 8);
(scanner, session)
}
fn probe(scanner: &mut SynPortScanner, port: u16) -> SeqNum {
scanner.send_probe(Target {
ip: TARGET,
port,
protocol: Protocol::Tcp,
});
scanner
.pending
.get(&(TARGET, port))
.expect("probe recorded")
.0
}
fn port_state(session: &ScanSession, port: u16) -> Option<PortState> {
session
.store
.get(&TARGET)
.and_then(|h| h.ports().find(|p| p.number() == port).map(|p| p.state()))
}
#[test]
fn syn_ack_matching_probe_is_open() {
let (mut scanner, session) = scanner_with_mock();
let seq = probe(&mut scanner, 80);
scanner.handle_reply(TARGET, &tcp_segment(80, seq.wrapping_add(1), SYN | ACK));
assert_eq!(port_state(&session, 80), Some(PortState::Open));
assert!(!scanner.pending.contains_key(&(TARGET, 80)));
}
#[test]
fn rst_matching_probe_is_closed() {
let (mut scanner, session) = scanner_with_mock();
let seq = probe(&mut scanner, 81);
scanner.handle_reply(TARGET, &tcp_segment(81, seq.wrapping_add(1), RST | ACK));
assert_eq!(port_state(&session, 81), Some(PortState::Closed));
}
#[test]
fn reply_with_wrong_ack_is_ignored() {
let (mut scanner, session) = scanner_with_mock();
let seq = probe(&mut scanner, 82);
scanner.handle_reply(TARGET, &tcp_segment(82, seq.wrapping_add(999), SYN | ACK));
assert_eq!(port_state(&session, 82), None);
assert!(scanner.pending.contains_key(&(TARGET, 82)));
}
#[test]
fn reply_for_unprobed_port_is_ignored() {
let (mut scanner, session) = scanner_with_mock();
let seq = probe(&mut scanner, 80);
scanner.handle_reply(TARGET, &tcp_segment(1234, seq.wrapping_add(1), SYN | ACK));
assert_eq!(port_state(&session, 1234), None);
assert!(scanner.pending.contains_key(&(TARGET, 80)));
}
#[test]
fn unanswered_probes_resolve_as_filtered() {
let (mut scanner, session) = scanner_with_mock();
probe(&mut scanner, 443);
scanner.resolve_remaining_as_filtered();
assert_eq!(port_state(&session, 443), Some(PortState::Filtered));
assert!(scanner.pending.is_empty());
}
#[test]
fn non_tcp_targets_are_not_probed() {
let (mut scanner, _session) = scanner_with_mock();
scanner.send_probe(Target {
ip: TARGET,
port: 53,
protocol: Protocol::Udp,
});
assert!(scanner.pending.is_empty());
}
}