use std::net::IpAddr;
use std::time::Instant;
use async_trait::async_trait;
use pnet::packet::ip::IpNextHeaderProtocols;
use pnet::packet::tcp::TcpPacket;
use tokio::sync::mpsc;
use crate::config::OsDetection;
use crate::config::ProbeTuning;
use crate::error;
use crate::fingerprint::os;
use crate::model::host::{HostStatus, StatusProtocol, StatusReason};
use crate::model::port::{PortState, Protocol};
use crate::model::target::Target;
use crate::model::technique::{TcpReply, TcpScanTechnique};
use crate::protocols::tcp;
use crate::scanner::pacing::deadline::AdaptiveDeadline;
use crate::scanner::pacing::retry::{ProbeLedger, RetryPolicy};
use crate::scanner::service;
use crate::scanner::session::{ScanContext, ScannerKind};
use crate::scanner::strategy::{PortScanner, StrategyError};
use crate::success;
use crate::system::interface::SourceResolver;
use crate::transport::capture::CapturedSegment;
use crate::transport::probe::{ProbeKind, ProbeSender, ProbeTransport};
use super::icmp_error::{self, Unreachable};
use super::probe_scan::{self, AuditLabels, ProbeTarget, RawPortScan, RawProbeScan};
use super::{DEADLINE_CONFIG, RETRY_POLICY};
use crate::scanner::audit::ProbeAudit;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct TcpToken {
nonce: u32,
}
type Ledger = ProbeLedger<ProbeTarget, TcpToken>;
const MAX_IN_FLIGHT: usize = 4_096;
pub struct TcpPortScanner {
technique: TcpScanTechnique,
core: RawProbeScan<TcpToken>,
os_detection: OsDetection,
}
impl TcpPortScanner {
pub fn new(
resolver: SourceResolver,
ctx: ScanContext,
technique: TcpScanTechnique,
target_count: usize,
tuning: ProbeTuning,
) -> Result<Self, StrategyError> {
let src_port: u16 = rand::random_range(50_000..u16::MAX);
let transport = ProbeTransport::open_with(
ProbeKind::TcpProbe {
reply_port: src_port,
icmp_errors: technique.reads_icmp_errors(),
},
tuning.send_mode,
)?;
Ok(Self::build(
resolver,
ctx,
technique,
transport,
target_count,
src_port,
RETRY_POLICY.configured(tuning.retry),
tuning.os_detection,
))
}
pub fn with_transport(
resolver: SourceResolver,
ctx: ScanContext,
technique: TcpScanTechnique,
transport: ProbeTransport,
target_count: usize,
) -> Self {
Self::build(
resolver,
ctx,
technique,
transport,
target_count,
rand::random_range(50_000..u16::MAX),
RETRY_POLICY,
OsDetection::default(),
)
}
#[allow(clippy::too_many_arguments)]
fn build(
resolver: SourceResolver,
ctx: ScanContext,
technique: TcpScanTechnique,
transport: ProbeTransport,
target_count: usize,
src_port: u16,
retry: RetryPolicy,
os_detection: OsDetection,
) -> Self {
let deadline_config = DEADLINE_CONFIG.allowing_for(retry.worst_case_probe_lifetime());
Self {
technique,
os_detection,
core: RawProbeScan {
resolver,
ctx,
transport,
deadline: AdaptiveDeadline::new(deadline_config, target_count),
ledger: Ledger::new(retry, target_count.min(MAX_IN_FLIGHT)),
due: Vec::new(),
src_port,
send_failure: None,
audit: ProbeAudit::new(),
max_in_flight: MAX_IN_FLIGHT,
},
}
}
fn handle_tcp_reply(&mut self, captured: &CapturedSegment, now: Instant) {
let (ip, bytes) = (captured.source, &captured.bytes);
let Some(tcp_packet) = TcpPacket::new(bytes) else {
self.core.audit.record_off_target();
return;
};
if tcp_packet.get_destination() != self.core.src_port {
self.core.audit.record_off_target();
return;
}
let Some(reply) = tcp::classify_probe_response(&tcp_packet) else {
self.core.audit.record_off_target();
return;
};
let Some(state) = self.technique.verdict(reply) else {
return;
};
let token = TcpToken {
nonce: tcp::echoed_nonce(self.technique, &tcp_packet),
};
let key = (ip, tcp_packet.get_source());
self.resolve_probe(key, Some(token), state, None, Some(reply), now);
self.identify_stack(ip, state, captured);
}
fn identify_stack(&self, ip: IpAddr, state: PortState, captured: &CapturedSegment) {
if !self.os_detection.is_enabled() || state != PortState::Open {
return;
}
let Some(observation) = captured.observation else {
return;
};
let Some(stack) = os::classify_reply(observation, &captured.bytes) else {
return;
};
self.core.ctx.update_host(ip, |host| {
os::identify(host, [stack.as_evidence()]);
});
}
fn handle_icmp_error(&mut self, reply: &CapturedSegment, now: Instant) {
let Some(error) = icmp_error::parse(reply) else {
return;
};
if error.quoted.protocol != IpNextHeaderProtocols::Tcp {
return;
}
let Some(quoted) = tcp::quoted_probe(error.quoted.payload) else {
return;
};
if quoted.source != self.core.src_port {
return;
}
let key = (error.quoted.destination, quoted.destination);
let token = tcp::quoted_nonce(self.technique, "ed).map(|nonce| TcpToken { nonce });
match error.reason {
Unreachable::Host => self.core.record_host_down(key.0, reply.source),
Unreachable::Port | Unreachable::Prohibited => {
self.resolve_probe(
key,
token,
PortState::Filtered,
Some(reply.source),
None,
now,
);
}
}
}
fn resolve_probe(
&mut self,
key: ProbeTarget,
token: Option<TcpToken>,
state: PortState,
sender: Option<IpAddr>,
drawn_by: Option<TcpReply>,
now: Instant,
) {
let Some(resolution) = self.core.ledger.resolve(&key, token, now) else {
self.core.audit.record_reply_without_rtt();
return;
};
self.core.deadline.mark_activity();
if let Some(rtt) = resolution.rtt {
self.core.deadline.record_rtt(rtt);
}
self.core
.audit
.record_host_found(resolution.answered_attempt);
self.record_port_drawn_by(key.0, key.1, state, sender, drawn_by);
}
const fn status_protocol(&self) -> StatusProtocol {
match self.technique {
TcpScanTechnique::Syn => StatusProtocol::TcpSyn,
_ => StatusProtocol::Tcp,
}
}
}
impl RawPortScan for TcpPortScanner {
type Token = TcpToken;
fn core(&self) -> &RawProbeScan<TcpToken> {
&self.core
}
fn core_mut(&mut self) -> &mut RawProbeScan<TcpToken> {
&mut self.core
}
fn protocol(&self) -> Protocol {
Protocol::Tcp
}
fn silence_means(&self) -> PortState {
self.technique.silence_means()
}
fn audit_labels(&self) -> AuditLabels {
AuditLabels {
tag: "tcp-port",
silence: "unanswered",
}
}
fn probe(&mut self, ip: IpAddr, port: u16, now: Instant) {
let Some(src_addr) = self.core.resolver.resolve(ip) else {
error!(verbosity = 2, "No route to {ip}; skipping {ip}:{port}");
return;
};
let token = send_tcp_probe(
self.core.transport.tx.as_ref(),
self.technique,
self.core.src_port,
src_addr,
ip,
port,
&mut self.core.send_failure,
);
self.core.audit.record_send(token.is_some());
if let Some(token) = token {
self.core.ledger.arm(ip, (ip, port), token, now);
}
}
fn handle_reply(&mut self, reply: &CapturedSegment, now: Instant) {
match reply.protocol {
IpNextHeaderProtocols::Tcp => self.handle_tcp_reply(reply, now),
_ => self.handle_icmp_error(reply, now),
}
}
fn record_port(&mut self, ip: IpAddr, port_num: u16, state: PortState, sender: Option<IpAddr>) {
self.record_port_drawn_by(ip, port_num, state, sender, None);
}
}
impl TcpPortScanner {
fn record_port_drawn_by(
&mut self,
ip: IpAddr,
port_num: u16,
state: PortState,
sender: Option<IpAddr>,
drawn_by: Option<TcpReply>,
) {
let port = crate::fingerprint::baseline_port(port_num, Protocol::Tcp, state);
let evidence = match (state, sender) {
(PortState::Open, _) => Some((
HostStatus::Up,
StatusReason::new(
StatusProtocol::TcpSyn,
match drawn_by {
Some(TcpReply::ChallengeAck) => {
"challenge ack from a probed port, so a listener holds it half-open"
}
_ => "syn-ack from a probed port",
},
),
)),
(PortState::Closed | PortState::Unfiltered, _) => Some((
HostStatus::Up,
StatusReason::new(self.status_protocol(), rst_evidence(self.technique)),
)),
(PortState::Filtered, Some(sender)) if sender == ip => Some((
HostStatus::Up,
StatusReason::new(
StatusProtocol::IcmpUnreachable,
"unreachable for a probed port, from the host",
),
)),
(PortState::Filtered, Some(sender)) => Some((
HostStatus::Filtered,
StatusReason::new(
StatusProtocol::IcmpUnreachable,
"unreachable for a probed port, from the path",
)
.from_source(sender),
)),
_ => None,
};
self.core.ctx.update_host(ip, |host| {
host.add_port(port);
if let Some((status, reason)) = evidence {
host.record_evidence(status, reason);
}
});
}
}
const fn rst_evidence(technique: TcpScanTechnique) -> &'static str {
match technique {
TcpScanTechnique::Syn => "rst from a probed port",
TcpScanTechnique::Fin => "rst to a fin probe",
TcpScanTechnique::Null => "rst to a flagless probe",
TcpScanTechnique::Xmas => "rst to a fin-psh-urg probe",
TcpScanTechnique::Maimon => "rst to a fin-ack probe",
TcpScanTechnique::Ack => "rst to an ack probe",
}
}
fn send_tcp_probe(
sender: &dyn ProbeSender,
technique: TcpScanTechnique,
src_port: u16,
src_addr: IpAddr,
dst_addr: IpAddr,
dst_port: u16,
reason: &mut Option<String>,
) -> Option<TcpToken> {
let nonce: u32 = rand::random();
let packet = match tcp::create_probe(technique, &src_addr, &dst_addr, src_port, dst_port, nonce)
{
Ok(packet) => packet,
Err(e) => {
error!(
verbosity = 2,
"Failed to create {technique} probe for {dst_addr}:{dst_port}: {e}"
);
return None;
}
};
match sender.send(&packet, src_addr, dst_addr) {
Ok(()) => {
success!(
verbosity = 2,
"Sent {technique} probe to {dst_addr}:{dst_port}"
);
Some(TcpToken { nonce })
}
Err(e) => {
error!(
verbosity = 2,
"Failed to send {technique} probe to {dst_addr}:{dst_port}: {e:#}"
);
*reason = Some(format!("{e:#}"));
None
}
}
}
#[async_trait]
impl PortScanner for TcpPortScanner {
fn kind(&self) -> ScannerKind {
ScannerKind::for_raw_tcp(self.technique)
}
fn supported_protocols(&self) -> Vec<Protocol> {
vec![Protocol::Tcp]
}
async fn scan(&mut self, targets: mpsc::Receiver<Target>) -> Result<(), StrategyError> {
probe_scan::run(self, targets).await;
Ok(())
}
async fn detect_services(&mut self, ctx: &ScanContext) {
service::detect(ctx).await;
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::net::Ipv4Addr;
use std::time::Duration;
use pnet::ipnetwork::{IpNetwork, Ipv4Network};
use pnet::packet::icmp::destination_unreachable::{
DestinationUnreachablePacket, IcmpCodes, MutableDestinationUnreachablePacket,
};
use pnet::packet::icmp::{IcmpCode, IcmpTypes};
use pnet::packet::tcp::MutableTcpPacket;
use crate::protocols::ip;
use crate::scanner::session::ScanSession;
use crate::transport::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));
const LOCAL: Ipv4Addr = Ipv4Addr::new(192, 168, 1, 50);
const LOCAL_IP: IpAddr = IpAddr::V4(LOCAL);
const ROUTER: IpAddr = IpAddr::V4(Ipv4Addr::new(192, 168, 1, 1));
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 segment_to(
from_port: u16,
to_port: u16,
technique: TcpScanTechnique,
token: TcpToken,
flags: u8,
) -> Vec<u8> {
let mut buf = vec![0u8; 20];
let mut tcp = MutableTcpPacket::new(&mut buf).unwrap();
tcp.set_source(from_port);
tcp.set_destination(to_port);
tcp.set_data_offset(5);
tcp.set_flags(flags);
match technique {
TcpScanTechnique::Maimon | TcpScanTechnique::Ack => tcp.set_sequence(token.nonce),
TcpScanTechnique::Null => tcp.set_acknowledgement(token.nonce),
_ => tcp.set_acknowledgement(token.nonce.wrapping_add(1)),
}
buf
}
fn tcp_segment(
scanner: &TcpPortScanner,
from_port: u16,
token: TcpToken,
flags: u8,
) -> Vec<u8> {
segment_to(
from_port,
scanner.core.src_port,
scanner.technique,
token,
flags,
)
}
type SentProbes = std::sync::Arc<std::sync::Mutex<Vec<crate::transport::probe::SentProbe>>>;
fn scanner_with_mock() -> (TcpPortScanner, ScanSession, SentProbes) {
scanner_for(TcpScanTechnique::Syn)
}
fn scanner_for(technique: TcpScanTechnique) -> (TcpPortScanner, ScanSession, SentProbes) {
let (session, ctx) = ScanSession::new();
let (_reply_tx, reply_rx) = tokio::sync::mpsc::unbounded_channel();
let sender = MockSender::default();
let sent = sender.sent.clone();
let transport = ProbeTransport::from_parts(Box::new(sender), reply_rx);
let resolver = SourceResolver::from_interfaces(&[on_link_interface()]);
let scanner = TcpPortScanner::with_transport(resolver, ctx, technique, transport, 8);
(scanner, session, sent)
}
fn probe(scanner: &mut TcpPortScanner, sent: &SentProbes, port: u16) -> TcpToken {
let before = sent.lock().unwrap().len();
scanner.send_probe(Target {
ip: TARGET,
port,
protocol: Protocol::Tcp,
});
let sent = sent.lock().unwrap();
let (segment, _, _) = sent.get(before).expect("probe reached the wire");
token_of(scanner.technique, segment)
}
fn token_of(technique: TcpScanTechnique, segment: &[u8]) -> TcpToken {
let tcp = TcpPacket::new(segment).expect("probe is a TCP segment");
TcpToken {
nonce: match technique {
TcpScanTechnique::Maimon | TcpScanTechnique::Ack => tcp.get_acknowledgement(),
_ => tcp.get_sequence(),
},
}
}
fn last_probe(technique: TcpScanTechnique, sent: &SentProbes) -> TcpToken {
let sent = sent.lock().unwrap();
let (segment, _, _) = sent.last().expect("a probe reached the wire");
token_of(technique, segment)
}
fn port_state(session: &ScanSession, port: u16) -> Option<PortState> {
session
.hosts()
.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, sent) = scanner_with_mock();
let token = probe(&mut scanner, &sent, 80);
let reply = tcp_segment(&scanner, 80, token, SYN | ACK);
scanner.handle_tcp_reply(
&CapturedSegment::synthetic(TARGET, IpNextHeaderProtocols::Tcp, reply.clone()),
Instant::now(),
);
assert_eq!(port_state(&session, 80), Some(PortState::Open));
assert!(!scanner.core.ledger.contains(&(TARGET, 80)));
}
#[test]
fn rst_matching_probe_is_closed() {
let (mut scanner, session, sent) = scanner_with_mock();
let token = probe(&mut scanner, &sent, 81);
let reply = tcp_segment(&scanner, 81, token, RST | ACK);
scanner.handle_tcp_reply(
&CapturedSegment::synthetic(TARGET, IpNextHeaderProtocols::Tcp, reply.clone()),
Instant::now(),
);
assert_eq!(port_state(&session, 81), Some(PortState::Closed));
}
#[test]
fn reply_carrying_the_wrong_nonce_is_ignored() {
let (mut scanner, session, sent) = scanner_with_mock();
let token = probe(&mut scanner, &sent, 82);
let stray = TcpToken {
nonce: token.nonce.wrapping_add(999),
};
let reply = tcp_segment(&scanner, 82, stray, SYN | ACK);
scanner.handle_tcp_reply(
&CapturedSegment::synthetic(TARGET, IpNextHeaderProtocols::Tcp, reply.clone()),
Instant::now(),
);
assert_eq!(port_state(&session, 82), None);
assert!(scanner.core.ledger.contains(&(TARGET, 82)));
}
#[test]
fn reply_addressed_to_another_port_on_this_host_is_ignored() {
let (mut scanner, session, sent) = scanner_with_mock();
let token = probe(&mut scanner, &sent, 83);
let elsewhere = scanner.core.src_port.wrapping_add(1);
let reply = segment_to(83, elsewhere, scanner.technique, token, SYN | ACK);
scanner.handle_tcp_reply(
&CapturedSegment::synthetic(TARGET, IpNextHeaderProtocols::Tcp, reply.clone()),
Instant::now(),
);
assert_eq!(port_state(&session, 83), None);
assert!(scanner.core.ledger.contains(&(TARGET, 83)));
}
#[test]
fn reply_for_unprobed_port_is_ignored() {
let (mut scanner, session, sent) = scanner_with_mock();
let token = probe(&mut scanner, &sent, 80);
let reply = tcp_segment(&scanner, 1234, token, SYN | ACK);
scanner.handle_tcp_reply(
&CapturedSegment::synthetic(TARGET, IpNextHeaderProtocols::Tcp, reply.clone()),
Instant::now(),
);
assert_eq!(port_state(&session, 1234), None);
assert!(scanner.core.ledger.contains(&(TARGET, 80)));
}
#[test]
fn unanswered_probes_resolve_as_filtered() {
let (mut scanner, session, sent) = scanner_with_mock();
probe(&mut scanner, &sent, 443);
scanner.resolve_remaining();
assert_eq!(port_state(&session, 443), Some(PortState::Filtered));
assert!(scanner.core.ledger.is_empty());
}
#[test]
fn a_rst_is_read_according_to_the_probe_that_drew_it() {
for (technique, expected) in [
(TcpScanTechnique::Syn, PortState::Closed),
(TcpScanTechnique::Fin, PortState::Closed),
(TcpScanTechnique::Null, PortState::Closed),
(TcpScanTechnique::Xmas, PortState::Closed),
(TcpScanTechnique::Maimon, PortState::Closed),
(TcpScanTechnique::Ack, PortState::Unfiltered),
] {
let (mut scanner, session, sent) = scanner_for(technique);
let token = probe(&mut scanner, &sent, 80);
let reply = tcp_segment(&scanner, 80, token, RST | ACK);
scanner.handle_tcp_reply(
&CapturedSegment::synthetic(TARGET, IpNextHeaderProtocols::Tcp, reply.clone()),
Instant::now(),
);
assert_eq!(port_state(&session, 80), Some(expected), "{technique}");
}
}
#[test]
fn a_rst_proves_the_host_is_up_whatever_it_says_about_the_port() {
let (mut scanner, session, sent) = scanner_for(TcpScanTechnique::Fin);
let token = probe(&mut scanner, &sent, 80);
let reply = tcp_segment(&scanner, 80, token, RST | ACK);
scanner.handle_tcp_reply(
&CapturedSegment::synthetic(TARGET, IpNextHeaderProtocols::Tcp, reply.clone()),
Instant::now(),
);
let host = session.hosts().get(&TARGET).expect("host recorded");
assert!(host.status().is_up());
}
#[test]
fn a_syn_ack_resolves_nothing_for_a_flag_probe() {
let (mut scanner, session, sent) = scanner_for(TcpScanTechnique::Fin);
let token = probe(&mut scanner, &sent, 80);
let reply = tcp_segment(&scanner, 80, token, SYN | ACK);
scanner.handle_tcp_reply(
&CapturedSegment::synthetic(TARGET, IpNextHeaderProtocols::Tcp, reply.clone()),
Instant::now(),
);
assert_eq!(port_state(&session, 80), None);
assert!(scanner.core.ledger.contains(&(TARGET, 80)));
}
#[test]
fn silence_is_filtered_or_open_filtered_by_technique() {
for (technique, expected) in [
(TcpScanTechnique::Syn, PortState::Filtered),
(TcpScanTechnique::Ack, PortState::Filtered),
(TcpScanTechnique::Fin, PortState::OpenFiltered),
(TcpScanTechnique::Null, PortState::OpenFiltered),
(TcpScanTechnique::Xmas, PortState::OpenFiltered),
(TcpScanTechnique::Maimon, PortState::OpenFiltered),
] {
let (mut scanner, session, sent) = scanner_for(technique);
probe(&mut scanner, &sent, 443);
scanner.resolve_remaining();
assert_eq!(port_state(&session, 443), Some(expected), "{technique}");
}
}
#[test]
fn an_unanswered_probe_says_nothing_about_the_host() {
let (mut scanner, session, sent) = scanner_for(TcpScanTechnique::Xmas);
probe(&mut scanner, &sent, 443);
scanner.resolve_remaining();
let host = session.hosts().get(&TARGET).expect("the port was recorded");
assert!(!host.status().is_up());
}
#[test]
fn the_reported_strategy_names_the_probe_that_was_sent() {
assert_eq!(
scanner_for(TcpScanTechnique::Syn).0.kind(),
ScannerKind::SynPort
);
assert_eq!(
scanner_for(TcpScanTechnique::Fin).0.kind(),
ScannerKind::TcpPort
);
}
fn icmp_error_quoting(code: IcmpCode, quoted: &[u8], from: IpAddr) -> CapturedSegment {
let quotation = quote(quoted);
let mut bytes =
vec![0u8; DestinationUnreachablePacket::minimum_packet_size() + quotation.len()];
let mut packet = MutableDestinationUnreachablePacket::new(&mut bytes).unwrap();
packet.set_icmp_type(IcmpTypes::DestinationUnreachable);
packet.set_icmp_code(code);
packet.set_payload("ation);
CapturedSegment::synthetic(from, IpNextHeaderProtocols::Icmp, bytes)
}
fn quote(probe: &[u8]) -> Vec<u8> {
let header = ip::create_ipv4_header(
LOCAL,
match TARGET {
IpAddr::V4(v4) => v4,
IpAddr::V6(_) => unreachable!("the fixture is v4"),
},
probe.len() as u16,
IpNextHeaderProtocols::Tcp,
)
.unwrap();
header.into_iter().chain(probe.iter().copied()).collect()
}
fn last_probe_bytes(sent: &SentProbes) -> Vec<u8> {
let sent = sent.lock().unwrap();
sent.last().expect("a probe reached the wire").0.clone()
}
#[test]
fn a_port_unreachable_about_a_tcp_probe_is_filtered_not_closed() {
let (mut scanner, session, sent) = scanner_for(TcpScanTechnique::Fin);
probe(&mut scanner, &sent, 80);
let error = icmp_error_quoting(
IcmpCodes::DestinationPortUnreachable,
&last_probe_bytes(&sent),
ROUTER,
);
scanner.handle_reply(&error, Instant::now());
assert_eq!(port_state(&session, 80), Some(PortState::Filtered));
assert!(scanner.core.ledger.is_empty());
}
#[test]
fn an_administrative_rejection_beats_the_silence_verdict() {
let (mut scanner, session, sent) = scanner_for(TcpScanTechnique::Xmas);
probe(&mut scanner, &sent, 80);
let error = icmp_error_quoting(
IcmpCodes::CommunicationAdministrativelyProhibited,
&last_probe_bytes(&sent),
ROUTER,
);
scanner.handle_reply(&error, Instant::now());
assert_eq!(port_state(&session, 80), Some(PortState::Filtered));
assert_ne!(port_state(&session, 80), Some(PortState::OpenFiltered));
}
#[test]
fn a_rejection_from_the_path_does_not_prove_the_host_is_up() {
let (mut scanner, session, sent) = scanner_for(TcpScanTechnique::Fin);
probe(&mut scanner, &sent, 80);
let error = icmp_error_quoting(
IcmpCodes::CommunicationAdministrativelyProhibited,
&last_probe_bytes(&sent),
ROUTER,
);
scanner.handle_reply(&error, Instant::now());
let host = session.hosts().get(&TARGET).expect("host recorded");
assert_eq!(host.status(), HostStatus::Filtered);
}
#[test]
fn a_rejection_from_the_host_proves_it_is_up() {
let (mut scanner, session, sent) = scanner_for(TcpScanTechnique::Fin);
probe(&mut scanner, &sent, 80);
let error = icmp_error_quoting(
IcmpCodes::CommunicationAdministrativelyProhibited,
&last_probe_bytes(&sent),
TARGET,
);
scanner.handle_reply(&error, Instant::now());
let host = session.hosts().get(&TARGET).expect("host recorded");
assert!(host.status().is_up());
}
#[test]
fn a_host_unreachable_leaves_the_port_undecided() {
let (mut scanner, session, sent) = scanner_for(TcpScanTechnique::Fin);
probe(&mut scanner, &sent, 80);
let error = icmp_error_quoting(
IcmpCodes::DestinationHostUnreachable,
&last_probe_bytes(&sent),
ROUTER,
);
scanner.handle_reply(&error, Instant::now());
assert_eq!(port_state(&session, 80), None);
assert!(scanner.core.ledger.contains(&(TARGET, 80)));
assert_eq!(
session.hosts().get(&TARGET).map(|host| host.status()),
Some(HostStatus::Down)
);
}
#[test]
fn an_error_quoting_somebody_elses_probe_is_ignored() {
let (mut scanner, session, sent) = scanner_for(TcpScanTechnique::Fin);
probe(&mut scanner, &sent, 80);
let theirs = tcp::create_probe(
TcpScanTechnique::Fin,
&LOCAL_IP,
&TARGET,
scanner.core.src_port.wrapping_add(1),
80,
0xABCD,
)
.unwrap();
let error = icmp_error_quoting(
IcmpCodes::CommunicationAdministrativelyProhibited,
&theirs,
ROUTER,
);
scanner.handle_reply(&error, Instant::now());
assert_eq!(port_state(&session, 80), None);
assert!(scanner.core.ledger.contains(&(TARGET, 80)));
}
#[test]
fn a_truncated_error_resolves_nothing() {
let (mut scanner, session, sent) = scanner_with_mock();
probe(&mut scanner, &sent, 80);
let mut error = icmp_error_quoting(
IcmpCodes::DestinationPortUnreachable,
&last_probe_bytes(&sent),
ROUTER,
);
error.bytes.truncate(12);
scanner.handle_reply(&error, Instant::now());
assert_eq!(port_state(&session, 80), None);
assert!(scanner.core.ledger.contains(&(TARGET, 80)));
}
#[test]
fn non_tcp_targets_are_not_probed() {
let (mut scanner, _session, _sent) = scanner_with_mock();
scanner.send_probe(Target {
ip: TARGET,
port: 53,
protocol: Protocol::Udp,
});
assert!(scanner.core.ledger.is_empty());
}
#[test]
fn an_unanswered_probe_is_sent_again() {
let (mut scanner, session, sent) = scanner_with_mock();
probe(&mut scanner, &sent, 80);
scanner.service_retries(Instant::now() + Duration::from_secs(1));
assert_eq!(sent.lock().unwrap().len(), 2, "the probe was not retried");
assert!(scanner.core.ledger.contains(&(TARGET, 80)));
assert_eq!(port_state(&session, 80), None, "no verdict has been earned");
}
#[test]
fn a_port_is_filtered_only_once_every_attempt_is_spent() {
let (mut scanner, session, sent) = scanner_with_mock();
probe(&mut scanner, &sent, 80);
let mut now = Instant::now();
for _ in 0..RETRY_POLICY.max_attempts + 2 {
now += Duration::from_secs(4);
scanner.service_retries(now);
}
assert_eq!(port_state(&session, 80), Some(PortState::Filtered));
assert_eq!(
sent.lock().unwrap().len(),
usize::from(RETRY_POLICY.max_attempts),
);
assert!(scanner.core.ledger.is_empty());
}
#[test]
fn an_answered_probe_is_never_retried() {
let (mut scanner, _session, sent) = scanner_with_mock();
let token = probe(&mut scanner, &sent, 80);
let reply = tcp_segment(&scanner, 80, token, SYN | ACK);
scanner.handle_tcp_reply(
&CapturedSegment::synthetic(TARGET, IpNextHeaderProtocols::Tcp, reply.clone()),
Instant::now(),
);
scanner.service_retries(Instant::now() + Duration::from_secs(10));
assert_eq!(sent.lock().unwrap().len(), 1);
}
#[test]
fn a_reply_to_a_superseded_attempt_still_resolves_the_port() {
let (mut scanner, session, sent) = scanner_with_mock();
let first = probe(&mut scanner, &sent, 80);
scanner.service_retries(Instant::now() + Duration::from_secs(1));
let second = last_probe(scanner.technique, &sent);
assert_ne!(
first.nonce, second.nonce,
"each attempt needs its own identity"
);
let reply = tcp_segment(&scanner, 80, first, SYN | ACK);
scanner.handle_tcp_reply(
&CapturedSegment::synthetic(TARGET, IpNextHeaderProtocols::Tcp, reply.clone()),
Instant::now(),
);
assert_eq!(port_state(&session, 80), Some(PortState::Open));
}
#[test]
fn every_attempt_leaves_from_the_scans_own_port() {
let (mut scanner, _session, sent) = scanner_with_mock();
probe(&mut scanner, &sent, 80);
scanner.service_retries(Instant::now() + Duration::from_secs(1));
let ports: Vec<u16> = sent
.lock()
.unwrap()
.iter()
.map(|(segment, _, _)| TcpPacket::new(segment).unwrap().get_source())
.collect();
assert_eq!(ports.len(), 2, "the probe was not retried");
assert!(
ports.iter().all(|port| *port == scanner.core.src_port),
"probes left from {ports:?}, not from {}",
scanner.core.src_port
);
}
#[test]
fn a_duplicate_reply_resolves_nothing_further() {
let (mut scanner, session, sent) = scanner_with_mock();
let token = probe(&mut scanner, &sent, 80);
let reply = tcp_segment(&scanner, 80, token, SYN | ACK);
scanner.handle_tcp_reply(
&CapturedSegment::synthetic(TARGET, IpNextHeaderProtocols::Tcp, reply.clone()),
Instant::now(),
);
scanner.handle_tcp_reply(
&CapturedSegment::synthetic(TARGET, IpNextHeaderProtocols::Tcp, reply.clone()),
Instant::now(),
);
let host = session.hosts().get(&TARGET).expect("host recorded");
assert_eq!(host.ports().filter(|p| p.number() == 80).count(), 1);
}
#[test]
fn the_scan_budget_covers_the_whole_retry_schedule() {
let lifetime = RETRY_POLICY.worst_case_probe_lifetime();
let budget = DEADLINE_CONFIG
.allowing_for(lifetime)
.max_budget
.for_target_count(1);
assert!(
budget > lifetime,
"a {budget:?} scan cannot finish a {lifetime:?} probe"
);
}
}