use async_trait::async_trait;
use tokio::sync::mpsc;
use crate::info;
use crate::journal::settle::Outcome;
use crate::model::port::Protocol;
use crate::model::target::PlannedTarget;
use crate::scanner::session::{ScanContext, ScannerKind};
use crate::scanner::strategy::{PortScanner, StrategyError};
pub struct CompositePortScanner {
scanners: Vec<Box<dyn PortScanner>>,
ctx: ScanContext,
}
impl CompositePortScanner {
pub fn new(scanners: Vec<Box<dyn PortScanner>>, ctx: ScanContext) -> Self {
Self { scanners, ctx }
}
}
#[async_trait]
impl PortScanner for CompositePortScanner {
fn kind(&self) -> ScannerKind {
ScannerKind::Composite
}
fn supported_protocols(&self) -> Vec<Protocol> {
let mut protocols = Vec::new();
for scanner in &self.scanners {
for proto in scanner.supported_protocols() {
if !protocols.contains(&proto) {
protocols.push(proto);
}
}
}
protocols
}
async fn scan(
&mut self,
mut targets: mpsc::Receiver<PlannedTarget>,
) -> Result<(), StrategyError> {
struct Route {
supported_protocols: Vec<Protocol>,
tx: mpsc::Sender<PlannedTarget>,
}
let mut routes = Vec::new();
let mut handles = Vec::new();
for mut scanner in self.scanners.drain(..) {
let (tx, rx) = mpsc::channel(1024);
let supported_protocols = scanner.supported_protocols();
let kind = scanner.kind();
let handle = tokio::spawn(async move {
let res = scanner.scan(rx).await;
(scanner, res)
});
handles.push((kind, handle));
routes.push(Route {
supported_protocols,
tx,
});
}
let mut unroutable = 0usize;
let mut undeliverable = 0usize;
while let Some(target) = targets.recv().await {
match routes
.iter()
.find(|route| route.supported_protocols.contains(&target.protocol()))
{
Some(route) => {
if route.tx.send(target).await.is_err() {
undeliverable += 1;
self.ctx.record_outcome(Outcome::Unroutable);
}
}
None => {
unroutable += 1;
self.ctx.record_outcome(Outcome::Unroutable);
}
}
}
let stopped = self.ctx.handle.should_stop();
let reportable = if stopped {
unroutable
} else {
unroutable + undeliverable
};
if reportable > 0 {
self.ctx
.record_failure(ScannerKind::Composite, missed(unroutable, undeliverable));
} else if undeliverable > 0 {
info!(
verbosity = 1,
"{undeliverable} target(s) were still queued when the scan was stopped"
);
}
drop(routes);
let mut failure: Option<StrategyError> = None;
for (kind, handle) in handles {
match handle.await {
Ok((scanner, res)) => {
self.scanners.push(scanner);
if let Err(e) = res {
failure.get_or_insert(e);
}
}
Err(e) => {
failure.get_or_insert_with(|| StrategyError::Panicked {
scanner: kind,
detail: e.to_string(),
});
}
}
}
match failure {
Some(e) => Err(e),
None => Ok(()),
}
}
async fn detect_services(&mut self, ctx: &ScanContext) {
for scanner in &mut self.scanners {
scanner.detect_services(ctx).await;
}
}
}
fn missed(unroutable: usize, undeliverable: usize) -> String {
let mut reasons = Vec::new();
if unroutable > 0 {
reasons.push(format!("{unroutable} had no scanner for their protocol"));
}
if undeliverable > 0 {
reasons.push(format!(
"{undeliverable} arrived after their scanner had finished"
));
}
format!(
"{} target(s) were never probed and are missing from the results: {}",
unroutable + undeliverable,
reasons.join(", ")
)
}
#[cfg(test)]
mod tests {
use super::*;
use crate::model::target::Target;
use crate::scanner::session::ScanSession;
use std::net::{IpAddr, Ipv4Addr};
use std::sync::{Arc, Mutex};
enum Behaviour {
Collect,
Fail(&'static str),
Panic,
}
struct MockPortScanner {
supported: Vec<Protocol>,
received: Arc<Mutex<Vec<Target>>>,
behaviour: Behaviour,
}
impl MockPortScanner {
fn new(supported: Vec<Protocol>) -> (Self, Arc<Mutex<Vec<Target>>>) {
Self::with_behaviour(supported, Behaviour::Collect)
}
fn with_behaviour(
supported: Vec<Protocol>,
behaviour: Behaviour,
) -> (Self, Arc<Mutex<Vec<Target>>>) {
let received = Arc::new(Mutex::new(Vec::new()));
(
Self {
supported,
received: received.clone(),
behaviour,
},
received,
)
}
}
#[async_trait]
impl PortScanner for MockPortScanner {
fn kind(&self) -> ScannerKind {
ScannerKind::Composite
}
fn supported_protocols(&self) -> Vec<Protocol> {
self.supported.clone()
}
async fn scan(
&mut self,
mut targets: mpsc::Receiver<PlannedTarget>,
) -> Result<(), StrategyError> {
match self.behaviour {
Behaviour::Fail(reason) => return Err(StrategyError::Probe(reason.into())),
Behaviour::Panic => panic!("scanner bug"),
Behaviour::Collect => {}
}
while let Some(t) = targets.recv().await {
self.received.lock().unwrap().push(t.target);
}
Ok(())
}
}
fn target(protocol: Protocol, port: u16) -> Target {
Target {
ip: IpAddr::V4(Ipv4Addr::LOCALHOST),
port,
protocol,
}
}
async fn run(
scanners: Vec<Box<dyn PortScanner>>,
targets: Vec<Target>,
) -> Result<(), StrategyError> {
let (_session, ctx) = ScanSession::new();
let mut composite = CompositePortScanner::new(scanners, ctx);
let (tx, rx) = mpsc::channel(16);
for (position, t) in targets.into_iter().enumerate() {
tx.send(PlannedTarget::new(position as u64, t))
.await
.unwrap();
}
drop(tx);
composite.scan(rx).await
}
#[tokio::test]
async fn composite_routes_by_protocol() {
let (tcp_scanner, tcp_rx) = MockPortScanner::new(vec![Protocol::Tcp]);
let (udp_scanner, udp_rx) = MockPortScanner::new(vec![Protocol::Udp]);
let (_session, ctx) = ScanSession::new();
let mut composite =
CompositePortScanner::new(vec![Box::new(tcp_scanner), Box::new(udp_scanner)], ctx);
let (tx, rx) = mpsc::channel(10);
let target_tcp = Target {
ip: IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)),
port: 80,
protocol: Protocol::Tcp,
};
let target_udp = Target {
ip: IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)),
port: 53,
protocol: Protocol::Udp,
};
tx.send(PlannedTarget::new(0, target_tcp)).await.unwrap();
tx.send(PlannedTarget::new(1, target_udp)).await.unwrap();
drop(tx);
composite.scan(rx).await.unwrap();
let tcp_received = tcp_rx.lock().unwrap();
assert_eq!(tcp_received.len(), 1);
assert_eq!(tcp_received[0].protocol, Protocol::Tcp);
let udp_received = udp_rx.lock().unwrap();
assert_eq!(udp_received.len(), 1);
assert_eq!(udp_received[0].protocol, Protocol::Udp);
}
#[tokio::test]
async fn a_failing_scanner_is_reported_without_losing_the_others() {
let (failing, _) =
MockPortScanner::with_behaviour(vec![Protocol::Tcp], Behaviour::Fail("transport died"));
let (working, udp_rx) = MockPortScanner::new(vec![Protocol::Udp]);
let (_session, ctx) = ScanSession::new();
let mut composite =
CompositePortScanner::new(vec![Box::new(failing), Box::new(working)], ctx);
let (tx, rx) = mpsc::channel(16);
tx.send(PlannedTarget::new(0, target(Protocol::Udp, 53)))
.await
.unwrap();
drop(tx);
let err = composite.scan(rx).await.expect_err("the failure surfaces");
assert!(err.to_string().contains("transport died"));
assert_eq!(udp_rx.lock().unwrap().len(), 1, "sibling still ran");
assert_eq!(composite.scanners.len(), 2, "both scanners restored");
}
#[tokio::test]
async fn a_panicking_scanner_surfaces_as_a_failure() {
let (panicking, _) = MockPortScanner::with_behaviour(vec![Protocol::Tcp], Behaviour::Panic);
let (working, udp_rx) = MockPortScanner::new(vec![Protocol::Udp]);
let err = run(
vec![Box::new(panicking), Box::new(working)],
vec![target(Protocol::Udp, 53)],
)
.await
.expect_err("a panic is a failure");
assert!(err.to_string().contains("panicked"), "got: {err}");
assert_eq!(udp_rx.lock().unwrap().len(), 1, "sibling still ran");
}
#[tokio::test]
async fn targets_with_no_route_do_not_stop_the_run() {
let (tcp_scanner, tcp_rx) = MockPortScanner::new(vec![Protocol::Tcp]);
run(
vec![Box::new(tcp_scanner)],
vec![target(Protocol::Tcp, 80), target(Protocol::Udp, 53)],
)
.await
.expect("unroutable targets are not a failure");
let received = tcp_rx.lock().unwrap();
assert_eq!(received.len(), 1);
assert_eq!(received[0].protocol, Protocol::Tcp);
}
#[tokio::test]
async fn targets_that_went_unprobed_reach_the_report() {
let (_session, ctx) = ScanSession::new();
let (tcp_scanner, _) = MockPortScanner::new(vec![Protocol::Tcp]);
let mut composite = CompositePortScanner::new(vec![Box::new(tcp_scanner)], ctx.clone());
let (tx, rx) = mpsc::channel(16);
for (position, t) in [target(Protocol::Udp, 53), target(Protocol::Udp, 161)]
.into_iter()
.enumerate()
{
tx.send(PlannedTarget::new(position as u64, t))
.await
.unwrap();
}
drop(tx);
composite
.scan(rx)
.await
.expect("not a failure, a narrowing");
let failures = ctx.take_failures();
assert_eq!(failures.len(), 1, "one cause, one entry");
assert_eq!(failures[0].scanner(), ScannerKind::Composite);
assert!(
failures[0].reason().contains('2'),
"the count is what says how much was missed: {}",
failures[0].reason()
);
}
#[tokio::test]
async fn a_scan_that_probed_everything_reports_no_narrowing() {
let (_session, ctx) = ScanSession::new();
let (tcp_scanner, _) = MockPortScanner::new(vec![Protocol::Tcp]);
let mut composite = CompositePortScanner::new(vec![Box::new(tcp_scanner)], ctx.clone());
let (tx, rx) = mpsc::channel(16);
tx.send(PlannedTarget::new(0, target(Protocol::Tcp, 80)))
.await
.unwrap();
drop(tx);
composite.scan(rx).await.unwrap();
assert!(ctx.take_failures().is_empty());
}
#[tokio::test]
async fn a_stopped_scan_does_not_report_a_failure() {
let (session, ctx) = ScanSession::new();
let (scanner, _received) = MockPortScanner::new(vec![Protocol::Tcp]);
let mut composite = CompositePortScanner::new(vec![Box::new(scanner)], ctx.clone());
session.handle().abort();
let (tx, rx) = mpsc::channel(16);
for (position, port) in [80u16, 443].into_iter().enumerate() {
tx.send(PlannedTarget::new(
position as u64,
target(Protocol::Tcp, port),
))
.await
.unwrap();
}
drop(tx);
composite.scan(rx).await.expect("a stop is not an error");
assert!(
ctx.take_failures().is_empty(),
"a stop was reported as a strategy failure"
);
assert_eq!(
ctx.settlements().settled_count(),
0,
"and nothing it could not hand over may be settled"
);
}
}