use std::net::IpAddr;
use std::time::{Duration, Instant};
use async_trait::async_trait;
use tokio::sync::mpsc;
use tokio::time::timeout;
use crate::config::ProbeTuning;
use crate::fingerprint;
use crate::fingerprint::os::{IdClass, SeriesClasses, SeriesSample};
use crate::info;
use crate::journal::settle::Outcome;
use crate::model::capture::IpObservation;
use crate::model::host::{HostStatus, StatusProtocol, StatusReason};
use crate::model::port::{PortState, Protocol};
use crate::model::target::PlannedTarget;
use crate::model::technique::TcpScanTechnique;
use crate::protocols::tcp::{self, flags};
use crate::report::ScannerKind;
use crate::report::StopReason;
use crate::scanner::audit::ProbeAudit;
use crate::scanner::session::ScanContext;
use crate::scanner::strategy::{PortScanner, StrategyError, record_unasked};
use crate::system::interface::SourceResolver;
use crate::transport::probe::{Emission, ProbeKind, ProbeTransport};
const DEFAULT_ZOMBIE_PORT: u16 = 80;
const QUALIFICATION_SAMPLES: usize = 6;
const QUALIFICATION_SPACING: Duration = Duration::from_millis(5);
pub const SPOOFED_PROBES: u16 = 6;
pub const OPEN_MIN_DELTA: u16 = SPOOFED_PROBES / 2 + 1;
const ZOMBIE_REPLY_TIMEOUT: Duration = Duration::from_millis(500);
const ZOMBIE_READ_ATTEMPTS: usize = 3;
#[derive(Debug, Clone, Copy)]
struct Reading {
ip_id: u16,
at: Instant,
flags: u8,
sequence: u32,
}
pub struct IdlePortScanner {
ctx: ScanContext,
transport: ProbeTransport,
source: Option<IpAddr>,
zombie: IpAddr,
zombie_port: u16,
reply_port: u16,
audit: ProbeAudit,
}
impl IdlePortScanner {
pub fn new(
ctx: ScanContext,
zombie: IpAddr,
zombie_port: Option<u16>,
tuning: ProbeTuning,
) -> Result<Self, StrategyError> {
let _ = tuning;
let reply_port: u16 = rand::random_range(50_000..u16::MAX);
let transport = ProbeTransport::open_ethernet_capturing(
ProbeKind::TcpProbe {
reply_port,
icmp_errors: false,
},
&ctx.capture_links(),
)?;
let source = SourceResolver::from_system().resolve(zombie);
Ok(Self {
ctx,
transport,
source,
zombie,
zombie_port: zombie_port.unwrap_or(DEFAULT_ZOMBIE_PORT),
reply_port,
audit: ProbeAudit::new(),
})
}
#[cfg(test)]
fn with_transport(
ctx: ScanContext,
zombie: IpAddr,
zombie_port: Option<u16>,
source: IpAddr,
transport: ProbeTransport,
) -> Self {
Self {
ctx,
transport,
source: Some(source),
zombie,
zombie_port: zombie_port.unwrap_or(DEFAULT_ZOMBIE_PORT),
reply_port: rand::random_range(50_000..u16::MAX),
audit: ProbeAudit::new(),
}
}
async fn read_counter(&mut self, source: IpAddr) -> Option<Reading> {
for _ in 0..ZOMBIE_READ_ATTEMPTS {
let nonce: u32 = rand::random();
let Ok(probe) = tcp::build_probe_with_flags(
flags::SYN | flags::ACK,
source,
self.zombie,
self.reply_port,
self.zombie_port,
nonce,
None,
false,
) else {
return None;
};
let sent = self
.transport
.tx
.send(&probe, source, self.zombie, None, Emission::routed())
.is_ok();
self.audit.record_send(sent);
if !sent {
continue;
}
if let Some(reading) = self.await_reset(nonce).await {
return Some(reading);
}
}
None
}
async fn await_reset(&mut self, nonce: u32) -> Option<Reading> {
let deadline = Instant::now() + ZOMBIE_REPLY_TIMEOUT;
loop {
let remaining = deadline.saturating_duration_since(Instant::now());
if remaining.is_zero() {
return None;
}
let reply = match timeout(remaining, self.transport.rx.recv()).await {
Ok(Some(reply)) => reply,
Ok(None) | Err(_) => return None,
};
self.audit.record_segment();
if reply.source != self.zombie {
self.audit.record_off_target();
continue;
}
let Ok(tcp) = tcp::parse(&reply.bytes) else {
continue;
};
if tcp::echoed_nonce_with_flags(flags::SYN | flags::ACK, &tcp, 0) != nonce {
self.audit.record_off_target();
continue;
}
let Some(IpObservation::V4(observation)) = reply.observation else {
return None;
};
return Some(Reading {
ip_id: observation.identification,
at: Instant::now(),
flags: tcp.flags(),
sequence: tcp.sequence(),
});
}
}
async fn qualify(&mut self, source: IpAddr) -> Result<(), IdClass> {
let mut samples = Vec::with_capacity(QUALIFICATION_SAMPLES);
for sample in 0..QUALIFICATION_SAMPLES {
if sample > 0 {
tokio::time::sleep(QUALIFICATION_SPACING).await;
}
let Some(reading) = self.read_counter(source).await else {
return Err(IdClass::TooFew);
};
samples.push(SeriesSample {
at: reading.at,
flags: reading.flags,
sequence: reading.sequence,
ip_id: Some(reading.ip_id),
tsval: None,
});
}
match SeriesClasses::from_samples(&samples).identifiers {
IdClass::Counting => Ok(()),
other => Err(other),
}
}
async fn measure(&mut self, source: IpAddr, target: IpAddr, port: u16) -> PortState {
let Some(before) = self.read_counter(source).await else {
return PortState::Filtered;
};
for _ in 0..SPOOFED_PROBES {
let nonce: u32 = rand::random();
let spoofed_port: u16 = rand::random_range(50_000..u16::MAX);
let Ok(probe) = tcp::build_probe(
TcpScanTechnique::Syn,
self.zombie,
target,
spoofed_port,
port,
nonce,
) else {
continue;
};
let sent = self
.transport
.tx
.send(&probe, self.zombie, target, None, Emission::routed())
.is_ok();
self.audit.record_send(sent);
}
let Some(after) = self.read_counter(source).await else {
return PortState::Filtered;
};
verdict(before.ip_id, after.ip_id)
}
fn record(&self, target: IpAddr, port: u16, state: PortState) {
let recorded = fingerprint::baseline_port(port, Protocol::Tcp, state);
self.ctx.update_host(target, |host| {
host.add_port(recorded.clone());
if state == PortState::Open {
host.record_evidence(
HostStatus::Up,
StatusReason::new(
StatusProtocol::TcpSyn,
"the target answered a forged probe, read through the zombie's counter",
),
);
}
});
}
}
#[async_trait]
impl PortScanner for IdlePortScanner {
fn kind(&self) -> ScannerKind {
ScannerKind::Idle
}
fn supported_protocols(&self) -> Vec<Protocol> {
vec![Protocol::Tcp]
}
async fn scan(
&mut self,
mut targets: mpsc::Receiver<PlannedTarget>,
) -> Result<(), StrategyError> {
let Some(source) = self.source else {
self.ctx.record_failure(
ScannerKind::Idle,
format!(
"no route to the zombie {} to run an idle scan through",
self.zombie
),
);
refuse(&self.ctx, targets).await;
return Ok(());
};
if let Err(class) = self.qualify(source).await {
self.ctx.record_failure(
ScannerKind::Idle,
format!(
"zombie {} unusable ({})",
self.zombie,
unsuitable_zombie(class)
),
);
refuse(&self.ctx, targets).await;
return Ok(());
}
info!(
"idle-scanning through the zombie {} on port {}",
self.zombie, self.zombie_port
);
let mut probes = 0u128;
let mut reason = StopReason::AttemptsSpent;
while let Some(planned) = targets.recv().await {
if let Some(cause) = self.ctx.handle.stopped() {
reason = cause.into();
record_unasked(&self.ctx, &planned);
break;
}
let target = planned.target;
if target.protocol != Protocol::Tcp || !target.ip.is_ipv4() || !self.zombie.is_ipv4() {
record_unasked(&self.ctx, &planned);
continue;
}
probes += 1;
let state = self.measure(source, target.ip, target.port).await;
self.record(target.ip, target.port, state);
self.ctx.record_outcome(Outcome::Answered {
position: planned.position,
});
}
targets.close();
while let Ok(planned) = targets.try_recv() {
record_unasked(&self.ctx, &planned);
}
let capture = self.transport.capture_counts();
self.audit.report("idle", probes, reason, capture, None);
self.ctx.record_probe_stats(self.audit.stats(
ScannerKind::Idle,
probes,
reason,
capture,
None,
));
Ok(())
}
}
async fn refuse(ctx: &ScanContext, mut targets: mpsc::Receiver<PlannedTarget>) {
while let Some(planned) = targets.recv().await {
record_unasked(ctx, &planned);
}
}
fn unsuitable_zombie(class: IdClass) -> &'static str {
match class {
IdClass::Absent => "IPv6, no IP-ID",
IdClass::TooFew => "too few replies",
IdClass::Unclear => "IP-ID unreadably slow",
IdClass::Zero => "IP-ID always zero",
IdClass::Constant => "IP-ID never advances",
IdClass::Scattered => "IP-ID randomised",
IdClass::Counting => "IP-ID counts",
}
}
fn verdict(before: u16, after: u16) -> PortState {
if after.wrapping_sub(before) >= OPEN_MIN_DELTA {
PortState::Open
} else {
PortState::ClosedFiltered
}
}
#[cfg(test)]
mod tests {
use std::net::Ipv4Addr;
use std::sync::atomic::{AtomicU16, Ordering};
use pnet_packet::ip::IpNextHeaderProtocols;
use super::*;
use crate::model::capture::Ipv4Observation;
use crate::model::target::Target;
use crate::scanner::session::ScanSession;
use crate::transport::capture::{CaptureStream, CapturedSegment};
use crate::transport::probe::{ProbeSender, SendError};
const ZOMBIE: IpAddr = IpAddr::V4(Ipv4Addr::new(192, 0, 2, 9));
const TARGET: IpAddr = IpAddr::V4(Ipv4Addr::new(192, 0, 2, 10));
const SOURCE: IpAddr = IpAddr::V4(Ipv4Addr::new(192, 0, 2, 1));
const OPEN_PORT: u16 = 22;
const CLOSED_PORT: u16 = 81;
#[test]
fn a_counter_advance_reads_open_only_when_it_clears_the_threshold() {
assert_eq!(verdict(100, 100 + SPOOFED_PROBES + 1), PortState::Open);
assert_eq!(verdict(100, 101), PortState::ClosedFiltered);
assert_eq!(verdict(100, 100 + OPEN_MIN_DELTA), PortState::Open);
assert_eq!(
verdict(100, 100 + OPEN_MIN_DELTA - 1),
PortState::ClosedFiltered
);
assert_eq!(verdict(65_530, 2), PortState::Open); assert_eq!(verdict(u16::MAX, 0), PortState::ClosedFiltered); }
enum Counter {
Counting,
Constant,
}
struct Zombie {
replies: mpsc::Sender<CapturedSegment>,
counter: AtomicU16,
kind: Counter,
open_ports: Vec<u16>,
}
impl Zombie {
fn next_id(&self) -> u16 {
match self.kind {
Counter::Counting => self.counter.fetch_add(1, Ordering::Relaxed),
Counter::Constant => 4242,
}
}
}
impl ProbeSender for Zombie {
fn send(
&self,
segment: &[u8],
_src: IpAddr,
dst: IpAddr,
_zone: Option<u32>,
_emission: Emission,
) -> Result<(), SendError> {
let Ok(tcp) = tcp::parse(segment) else {
return Ok(());
};
if dst == ZOMBIE {
let reset = reset(
tcp.destination_port(),
tcp.source_port(),
tcp.acknowledgement(),
);
let _ = self.replies.try_send(captured(reset, self.next_id()));
} else if dst == TARGET && self.open_ports.contains(&tcp.destination_port()) {
let _ = self.next_id();
}
Ok(())
}
}
fn reset(source_port: u16, destination_port: u16, sequence: u32) -> Vec<u8> {
let mut bytes = vec![0u8; 20];
bytes[0..2].copy_from_slice(&source_port.to_be_bytes());
bytes[2..4].copy_from_slice(&destination_port.to_be_bytes());
bytes[4..8].copy_from_slice(&sequence.to_be_bytes());
bytes[12] = 5 << 4; bytes[13] = flags::RST | flags::ACK;
bytes
}
fn captured(bytes: Vec<u8>, identification: u16) -> CapturedSegment {
CapturedSegment {
received_at: Instant::now(),
source: ZOMBIE,
destination: None,
protocol: IpNextHeaderProtocols::Tcp.0,
observation: Some(IpObservation::V4(Ipv4Observation {
ttl: 64,
identification,
dont_fragment: false,
more_fragments: false,
dscp: 0,
ecn: 0,
})),
source_mac: None,
bytes,
}
}
fn scanner(ctx: &ScanContext, kind: Counter, open_ports: Vec<u16>) -> IdlePortScanner {
let (tx, rx) = mpsc::channel(1024);
let zombie = Zombie {
replies: tx,
counter: AtomicU16::new(1000),
kind,
open_ports,
};
let transport = ProbeTransport::from_parts(Box::new(zombie), rx as CaptureStream);
IdlePortScanner::with_transport(ctx.clone(), ZOMBIE, None, SOURCE, transport)
}
async fn scan(scanner: &mut IdlePortScanner, ports: &[u16]) {
let (tx, rx) = mpsc::channel(ports.len().max(1));
for (position, &port) in ports.iter().enumerate() {
tx.send(PlannedTarget::new(
position as u64,
Target {
ip: TARGET,
port,
protocol: Protocol::Tcp,
},
))
.await
.expect("the target is admitted");
}
drop(tx);
scanner.scan(rx).await.expect("the idle scan runs");
}
fn port_state(session: &ScanSession, port: u16) -> Option<PortState> {
session
.hosts()
.get(TARGET)
.and_then(|host| host.ports().find(|p| p.number() == port).map(|p| p.state()))
}
#[tokio::test]
async fn an_open_and_a_closed_port_are_read_through_a_counting_zombie() {
let (session, ctx) = ScanSession::new();
let mut scanner = scanner(&ctx, Counter::Counting, vec![OPEN_PORT]);
scan(&mut scanner, &[OPEN_PORT, CLOSED_PORT]).await;
assert_eq!(port_state(&session, OPEN_PORT), Some(PortState::Open));
assert_eq!(
port_state(&session, CLOSED_PORT),
Some(PortState::ClosedFiltered)
);
}
#[tokio::test]
async fn a_zombie_whose_counter_does_not_move_is_refused() {
let (session, ctx) = ScanSession::new();
let mut scanner = scanner(&ctx, Counter::Constant, vec![OPEN_PORT]);
scan(&mut scanner, &[OPEN_PORT]).await;
assert_eq!(port_state(&session, OPEN_PORT), Some(PortState::Unasked));
let failures = ctx.failures_snapshot();
let refusal = failures
.iter()
.find(|failure| failure.scanner() == ScannerKind::Idle)
.expect("the refusal is recorded against the idle scanner");
assert!(
refusal.reason().contains("IP-ID never advances"),
"the refusal flags what the counter did, not \"a constant IP-ID counter\": {}",
refusal.reason()
);
}
#[tokio::test]
async fn a_refused_scan_records_every_target_it_is_handed_unasked() {
let (session, ctx) = ScanSession::new();
let mut scanner = scanner(&ctx, Counter::Constant, vec![OPEN_PORT]);
let (tx, rx) = mpsc::channel(4);
let target = |position, port| {
PlannedTarget::new(
position,
Target {
ip: TARGET,
port,
protocol: Protocol::Tcp,
},
)
};
tx.send(target(0, OPEN_PORT)).await.expect("queued");
let scan = tokio::spawn(async move {
scanner.scan(rx).await.expect("the idle scan runs");
});
while !ctx
.failures_snapshot()
.iter()
.any(|failure| failure.scanner() == ScannerKind::Idle)
{
tokio::task::yield_now().await;
}
let late = tx.send(target(1, CLOSED_PORT)).await;
drop(tx);
scan.await.expect("the scan task ends");
assert!(late.is_ok(), "a target routed after the refusal is taken");
assert_eq!(port_state(&session, OPEN_PORT), Some(PortState::Unasked));
assert_eq!(port_state(&session, CLOSED_PORT), Some(PortState::Unasked));
assert_eq!(ctx.settlements().count(Outcome::Unasked), 2);
}
}