use std::collections::HashMap;
use std::net::IpAddr;
use std::time::{Duration, Instant};
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::system::interface::SourceResolver;
use crate::transport::link::EthernetSender;
use crate::transport::probe::{Emission, ProbeKind, ProbeSender, ProbeTransport};
use crate::{counted, error, info};
const REPLY_WINDOW: Duration = Duration::from_secs(2);
const TRUSTED_SOURCE_PORT: u16 = 53;
const STATELESS_FRAGMENT_MTU: u16 = 28;
pub struct Subject {
pub host: IpAddr,
pub open_port: Option<u16>,
pub filtered_port: Option<u16>,
}
type Awaiting = HashMap<u32, (IpAddr, Filtering)>;
pub async fn characterise(ctx: &ScanContext, subjects: Vec<Subject>) {
if subjects.is_empty() {
return;
}
let mut transport = match ProbeTransport::open(ProbeKind::TcpSyn) {
Ok(transport) => transport,
Err(error) => {
ctx.record_failure(
ScannerKind::Routed,
format!("no transport to characterise a filter with: {error}"),
);
return;
}
};
let mut resolver = SourceResolver::from_system();
let ethernet = EthernetSender::from_system(ProbeKind::TcpSyn.ip_protocols());
info!(
"characterising the filter in front of {}",
counted(subjects.len() as u128, "host", "hosts")
);
let awaiting = send_diagnostics(
&subjects,
transport.tx.as_ref(),
ethernet.as_ref(),
&mut resolver,
);
collect_replies(ctx, &mut transport, &awaiting).await;
}
fn send_diagnostics(
subjects: &[Subject],
sender: &dyn ProbeSender,
ethernet: Option<&EthernetSender>,
resolver: &mut SourceResolver,
) -> Awaiting {
let mut awaiting = Awaiting::new();
for subject in subjects {
let Some(source) = resolver.resolve(subject.host) else {
continue;
};
if let Some(port) = subject.open_port {
probe_inline_middlebox(sender, &mut awaiting, source, subject.host, port);
}
let Some(port) = subject.filtered_port else {
continue;
};
probe_stateful_filter(sender, &mut awaiting, source, subject.host, port);
probe_port_trusting_acl(sender, &mut awaiting, source, subject.host, port);
if let Some(ethernet) = ethernet {
probe_stateless_filter(ethernet, &mut awaiting, source, subject.host, port);
}
}
awaiting
}
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(
ethernet: &EthernetSender,
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(
ethernet,
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);
}
}