use std::collections::{BTreeMap, HashMap};
use std::net::IpAddr;
use std::time::{Duration, Instant};
use crate::logging::error;
use crate::model::host::Filtering;
use crate::model::technique::TcpScanTechnique;
use crate::protocols::tcp;
use crate::report::ScannerKind;
use crate::scanner::session::ScanContext;
use crate::scanner::strategy::raw::neighbors::{resolve_ahead, send_when_admitted};
use crate::system::interface::SourceResolver;
use crate::transport::link::EthernetSender;
use crate::transport::probe::{
Emission, NeighborWatch, ProbeKind, ProbeSender, ProbeTransport, SendMode,
};
use crate::{counted, info};
const REPLY_WINDOW: Duration = Duration::from_secs(2);
const TRUSTED_SOURCE_PORT: u16 = 53;
const STATELESS_FRAGMENT_MTU: u16 = 28;
pub(crate) struct Subject {
pub(crate) host: IpAddr,
pub(crate) open_port: Option<u16>,
pub(crate) filtered_port: Option<u16>,
}
type Awaiting = HashMap<u32, (IpAddr, Filtering)>;
pub(crate) async fn characterise(ctx: &ScanContext, subjects: Vec<Subject>) {
if subjects.is_empty() {
return;
}
let mut transport = match ProbeTransport::open_capturing(
ProbeKind::TcpSyn,
SendMode::Auto,
&ctx.capture_links(),
) {
Ok(transport) => transport,
Err(error) => {
ctx.record_failure(
ScannerKind::Routed,
format!("no transport to characterise a filter with: {error}"),
);
return;
}
};
let ethernet = EthernetSender::from_system(ProbeKind::TcpSyn.ip_protocols());
let fragmenting = ethernet.as_ref().map(|sender| Fragmenting {
sender,
neighbors: NeighborWatch::Frames(sender.neighbors()),
});
info!(
"characterising the filter in front of {}",
counted(subjects.len() as u128, "host", "hosts")
);
run(
ctx,
&mut transport,
fragmenting.as_ref(),
&mut SourceResolver::from_system(),
subjects,
)
.await;
}
struct Fragmenting<'a> {
sender: &'a dyn ProbeSender,
neighbors: NeighborWatch,
}
async fn run(
ctx: &ScanContext,
transport: &mut ProbeTransport,
fragmenting: Option<&Fragmenting<'_>>,
resolver: &mut SourceResolver,
subjects: Vec<Subject>,
) {
let hosts = subjects.iter().map(|subject| subject.host);
let (mut gates, unreached) = resolve_ahead(ctx, transport.neighbors(), resolver, hosts).await;
let mut subjects: Vec<Subject> = subjects
.into_iter()
.filter(|subject| !unreached.contains_key(&subject.host))
.collect();
let unframed = match fragmenting {
Some(fragmenting) => {
let filtered = subjects
.iter()
.filter(|subject| subject.filtered_port.is_some())
.map(|subject| subject.host);
resolve_ahead(ctx, Some(&fragmenting.neighbors), resolver, filtered)
.await
.1
}
None => BTreeMap::new(),
};
let mut awaiting = Awaiting::new();
let planned = plan_diagnostics(&subjects, resolver);
let sender = transport.tx.as_ref();
let unadmitted = send_when_admitted(
&mut gates,
ctx,
transport.neighbors(),
resolver,
planned,
|host, diagnostic| diagnostic.send(sender, &mut awaiting, host),
)
.await;
subjects.retain(|subject| !unadmitted.contains_key(&subject.host));
for (host, why) in unreached.iter().chain(&unadmitted) {
info!(
verbosity = 2,
"{host} not characterised: unreachable ({why})"
);
}
if let Some(fragmenting) = fragmenting
&& !ctx.handle.should_stop()
{
send_fragmented(
&subjects,
fragmenting.sender,
&unframed,
resolver,
&mut awaiting,
);
}
collect_replies(ctx, transport, &awaiting).await;
}
#[derive(Debug, Clone, Copy)]
struct Diagnostic {
source: IpAddr,
port: u16,
conclusion: Filtering,
}
impl Diagnostic {
fn send(self, sender: &dyn ProbeSender, awaiting: &mut Awaiting, host: IpAddr) {
let Self {
source,
port,
conclusion,
} = self;
match conclusion {
Filtering::InlineMiddlebox => {
probe_inline_middlebox(sender, awaiting, source, host, port);
}
Filtering::StatefulFilter => {
probe_stateful_filter(sender, awaiting, source, host, port);
}
Filtering::PortTrustingAcl => {
probe_port_trusting_acl(sender, awaiting, source, host, port);
}
_ => {}
}
}
}
fn plan_diagnostics(
subjects: &[Subject],
resolver: &mut SourceResolver,
) -> Vec<(IpAddr, Diagnostic)> {
let mut planned = Vec::new();
for subject in subjects {
let Some(source) = resolver.resolve(subject.host) else {
continue;
};
let diagnostic = |port, conclusion| {
(
subject.host,
Diagnostic {
source,
port,
conclusion,
},
)
};
if let Some(port) = subject.open_port {
planned.push(diagnostic(port, Filtering::InlineMiddlebox));
}
if let Some(port) = subject.filtered_port {
planned.push(diagnostic(port, Filtering::StatefulFilter));
planned.push(diagnostic(port, Filtering::PortTrustingAcl));
}
}
planned
}
fn send_fragmented(
subjects: &[Subject],
sender: &dyn ProbeSender,
unframed: &BTreeMap<IpAddr, String>,
resolver: &mut SourceResolver,
awaiting: &mut Awaiting,
) {
for subject in subjects {
let Some(port) = subject.filtered_port else {
continue;
};
if unframed.contains_key(&subject.host) {
continue;
}
let Some(source) = resolver.resolve(subject.host) else {
continue;
};
probe_stateless_filter(sender, awaiting, source, subject.host, port);
}
}
fn probe_inline_middlebox(
sender: &dyn ProbeSender,
awaiting: &mut Awaiting,
source: IpAddr,
host: IpAddr,
port: u16,
) {
let nonce: u32 = rand::random();
let src_port: u16 = rand::random_range(50_000..u16::MAX);
send_diagnostic(
sender,
awaiting,
source,
host,
nonce,
tcp::build_probe_shaped(
TcpScanTechnique::Syn,
source,
host,
src_port,
port,
nonce,
None,
true,
),
Emission::routed(),
Filtering::InlineMiddlebox,
);
}
fn probe_stateful_filter(
sender: &dyn ProbeSender,
awaiting: &mut Awaiting,
source: IpAddr,
host: IpAddr,
port: u16,
) {
let nonce: u32 = rand::random();
let src_port: u16 = rand::random_range(50_000..u16::MAX);
send_diagnostic(
sender,
awaiting,
source,
host,
nonce,
tcp::build_probe(TcpScanTechnique::Ack, source, host, src_port, port, nonce),
Emission::routed(),
Filtering::StatefulFilter,
);
}
fn probe_port_trusting_acl(
sender: &dyn ProbeSender,
awaiting: &mut Awaiting,
source: IpAddr,
host: IpAddr,
port: u16,
) {
let nonce: u32 = rand::random();
send_diagnostic(
sender,
awaiting,
source,
host,
nonce,
tcp::build_probe(
TcpScanTechnique::Syn,
source,
host,
TRUSTED_SOURCE_PORT,
port,
nonce,
),
Emission::routed(),
Filtering::PortTrustingAcl,
);
}
fn probe_stateless_filter(
sender: &dyn ProbeSender,
awaiting: &mut Awaiting,
source: IpAddr,
host: IpAddr,
port: u16,
) {
let nonce: u32 = rand::random();
let src_port: u16 = rand::random_range(50_000..u16::MAX);
send_diagnostic(
sender,
awaiting,
source,
host,
nonce,
tcp::build_probe(TcpScanTechnique::Syn, source, host, src_port, port, nonce),
Emission {
fragment: Some(STATELESS_FRAGMENT_MTU),
..Emission::routed()
},
Filtering::StatelessFilter,
);
}
#[allow(clippy::too_many_arguments)]
fn send_diagnostic(
sender: &dyn ProbeSender,
awaiting: &mut Awaiting,
source: IpAddr,
host: IpAddr,
nonce: u32,
packet: crate::protocols::error::Result<Vec<u8>>,
emission: Emission,
conclusion: Filtering,
) {
let packet = match packet {
Ok(packet) => packet,
Err(e) => {
error!(
verbosity = 2,
"cannot build a diagnostic probe for {host}: {e}"
);
return;
}
};
if sender.send(&packet, source, host, None, emission).is_ok() {
awaiting.insert(nonce, (host, conclusion));
}
}
async fn collect_replies(ctx: &ScanContext, transport: &mut ProbeTransport, awaiting: &Awaiting) {
let deadline = Instant::now() + REPLY_WINDOW;
loop {
if ctx.handle.should_stop() {
return;
}
let remaining = deadline.saturating_duration_since(Instant::now());
if remaining.is_zero() {
return;
}
match tokio::time::timeout(remaining, transport.rx.recv()).await {
Ok(Some(reply)) => {
if let Some((host, conclusion)) = matched_conclusion(&reply.bytes, awaiting) {
ctx.update_host(host, |host| {
host.add_filtering(conclusion);
});
}
}
Ok(None) | Err(_) => return,
}
}
}
fn matched_conclusion(reply: &[u8], awaiting: &Awaiting) -> Option<(IpAddr, Filtering)> {
let tcp = tcp::parse(reply).ok()?;
let as_syn = tcp::echoed_nonce(TcpScanTechnique::Syn, &tcp, 0);
let as_ack = tcp::echoed_nonce(TcpScanTechnique::Ack, &tcp, 0);
awaiting
.get(&as_syn)
.or_else(|| awaiting.get(&as_ack))
.copied()
}
#[cfg(test)]
mod tests {
use super::*;
use crate::protocols::craft;
use std::net::Ipv4Addr;
const HOST: IpAddr = IpAddr::V4(Ipv4Addr::new(192, 0, 2, 1));
fn syn_ack_echoing(nonce: u32) -> Vec<u8> {
let mut segment = craft::Tcp::new(80, 50_000).with_flags(tcp::flags::SYN | tcp::flags::ACK);
segment.acknowledgement = nonce.wrapping_add(1);
segment
.to_bytes(Some((HOST, HOST)))
.expect("a segment builds")
}
fn rst_echoing_ack(nonce: u32) -> Vec<u8> {
let mut segment = craft::Tcp::new(80, 50_000).with_flags(tcp::flags::RST);
segment.sequence = nonce;
segment
.to_bytes(Some((HOST, HOST)))
.expect("a segment builds")
}
#[test]
fn a_reply_names_the_host_and_conclusion_of_the_probe_it_answers() {
let syn_nonce = 0xDEAD_BEEF;
let ack_nonce = 0x0BAD_F00D;
let awaiting = HashMap::from([
(syn_nonce, (HOST, Filtering::PortTrustingAcl)),
(ack_nonce, (HOST, Filtering::StatefulFilter)),
]);
assert_eq!(
matched_conclusion(&syn_ack_echoing(syn_nonce), &awaiting),
Some((HOST, Filtering::PortTrustingAcl))
);
assert_eq!(
matched_conclusion(&rst_echoing_ack(ack_nonce), &awaiting),
Some((HOST, Filtering::StatefulFilter))
);
assert_eq!(
matched_conclusion(&syn_ack_echoing(0x1234_5678), &awaiting),
None
);
assert_eq!(matched_conclusion(&[0u8; 4], &awaiting), None);
}
#[tokio::test]
async fn neighbours_behind_the_fragmenting_sender_are_asked_for_before_the_first_probe() {
use crate::scanner::session::ScanSession;
use crate::system::interface::{Link, LinkAddress};
use crate::transport::link::{LinkNeighbors, SIMULATED_HOST};
use crate::transport::probe::MockSender;
const LIVE: Ipv4Addr = Ipv4Addr::new(192, 0, 2, 64);
let dead: Vec<IpAddr> = (211..=220)
.map(|last| IpAddr::V4(Ipv4Addr::new(192, 0, 2, last)))
.collect();
let (_session, ctx) = ScanSession::new();
let (_tx, rx) = tokio::sync::mpsc::channel(1024);
let raw = MockSender::default();
let asked = raw.sent.clone();
let mut transport = ProbeTransport::from_parts(Box::new(raw), rx);
let frames = MockSender::default();
let framed = frames.sent.clone();
let fragmenting = Fragmenting {
sender: &frames,
neighbors: NeighborWatch::Frames(LinkNeighbors::on_simulated_segment(
"sim-filter0",
&[LIVE],
)),
};
let subjects = dead
.iter()
.copied()
.chain([IpAddr::V4(LIVE)])
.map(|host| Subject {
host,
open_port: Some(80),
filtered_port: Some(81),
})
.collect();
let mut resolver = SourceResolver::from_links(&[Link::new("test0", 0)
.with_addresses(vec![LinkAddress::new(IpAddr::V4(SIMULATED_HOST), 24)])]);
run(
&ctx,
&mut transport,
Some(&fragmenting),
&mut resolver,
subjects,
)
.await;
let framed = framed.lock().unwrap();
assert!(
!framed.is_empty(),
"the live neighbour is sent the fragmented probe"
);
assert!(
framed.iter().all(|(_, _, dst)| *dst == IpAddr::V4(LIVE)),
"a fragmented probe was handed to the sender for a neighbour nobody had resolved"
);
assert_eq!(
asked.lock().unwrap().len(),
(dead.len() + 1) * 3,
"the raw probes, through a transport with nothing to read, go to every host"
);
}
#[tokio::test]
async fn probes_behind_the_kernel_asking_for_a_neighbour_wait_on_its_verdict() {
use crate::scanner::session::ScanSession;
use crate::system::interface::{Link, LinkAddress};
use crate::transport::kernel_neighbors::KernelNeighbors;
use crate::transport::probe::MockSender;
let held = IpAddr::V4(Ipv4Addr::new(192, 0, 2, 67));
let live = IpAddr::V4(Ipv4Addr::new(192, 0, 2, 68));
let dead: Vec<IpAddr> = (225..=228)
.map(|last| IpAddr::V4(Ipv4Addr::new(192, 0, 2, last)))
.collect();
let (_session, ctx) = ScanSession::new();
let (_tx, rx) = tokio::sync::mpsc::channel(1024);
let sender = MockSender::default();
let sent = sender.sent.clone();
let table = KernelNeighbors::asking_on_write(sent.clone(), &[held], &[live]);
let mut transport =
ProbeTransport::from_parts(Box::new(sender), rx).with_kernel_neighbors(table);
let subjects = dead
.iter()
.copied()
.chain([held, live])
.map(|host| Subject {
host,
open_port: Some(80),
filtered_port: Some(81),
})
.collect();
let mut resolver =
SourceResolver::from_links(&[Link::new("test0", 1).with_addresses(vec![
LinkAddress::new(IpAddr::V4(Ipv4Addr::new(192, 0, 2, 1)), 24),
])]);
run(&ctx, &mut transport, None, &mut resolver, subjects).await;
let sent = sent.lock().unwrap();
let to = |address: IpAddr| sent.iter().filter(|(_, _, dst)| *dst == address).count();
for &address in &dead {
assert_eq!(
to(address),
1,
"{address} was sent past the write that asked"
);
}
assert_eq!(to(held), 3, "a neighbour the kernel held");
assert_eq!(to(live), 3, "a neighbour that answered");
}
}