use std::net::SocketAddr;
use std::time::Instant;
use crate::detect::compute::Budget;
use crate::detect::exchange;
use crate::fingerprint::Tunnel;
use crate::model::port::Protocol;
use super::{Probe, ProbeRefusal};
pub struct SocketProbe {
addr: SocketAddr,
protocol: Protocol,
tunnel: Option<Tunnel>,
bytes_left: u64,
deadline: Instant,
connections_left: u32,
last_refusal: Option<ProbeRefusal>,
last_complete: bool,
}
impl SocketProbe {
pub fn new(
addr: SocketAddr,
protocol: Protocol,
tunnel: Option<Tunnel>,
budget: &Budget,
) -> Self {
Self {
addr,
protocol,
tunnel,
bytes_left: budget.max_bytes,
deadline: Instant::now() + budget.deadline,
connections_left: budget.max_connections,
last_refusal: None,
last_complete: false,
}
}
}
impl Probe for SocketProbe {
fn speak(&mut self, bytes: &[u8]) -> Option<Vec<u8>> {
self.last_refusal = None;
if self.connections_left == 0 {
self.last_refusal = Some(ProbeRefusal::Connections);
return None;
}
if exchange::remaining(self.deadline).is_none() {
self.last_refusal = Some(ProbeRefusal::Deadline);
return None;
}
let sent = bytes.len() as u64;
if sent > self.bytes_left {
self.last_refusal = Some(ProbeRefusal::Bytes);
return None;
}
self.bytes_left -= sent;
self.connections_left -= 1;
let reply = match self.protocol {
Protocol::Tcp => exchange::tcp(
self.addr,
self.tunnel,
bytes,
self.deadline,
self.bytes_left,
),
Protocol::Udp => exchange::udp(self.addr, bytes, self.deadline, self.bytes_left),
Protocol::Sctp => return None,
}
.ok()
.filter(|reply| !reply.bytes.is_empty())?;
self.bytes_left -= reply.bytes.len() as u64;
self.last_complete = reply.complete;
Some(reply.bytes)
}
fn last_refusal(&self) -> Option<ProbeRefusal> {
self.last_refusal
}
fn reply_complete(&self) -> bool {
self.last_complete
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::time::Duration;
fn budget(max_bytes: u64, millis: u64, max_connections: u32) -> Budget {
Budget::new(0, Duration::from_millis(millis))
.with_max_bytes(max_bytes)
.with_max_connections(max_connections)
}
#[test]
fn a_reply_is_capped_at_the_flows_byte_budget() {
use std::io::{Read as _, Write as _};
let listener = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
let addr = listener.local_addr().unwrap();
std::thread::spawn(move || {
if let Ok((mut sock, _)) = listener.accept() {
let _ = sock.read(&mut [0u8; 64]);
let _ = sock.write_all(&vec![b'A'; 4096]);
}
});
let mut probe = SocketProbe::new(addr, Protocol::Tcp, None, &budget(20, 5_000, 8));
let reply = probe.speak(b"x").expect("a reply within budget");
assert!(
reply.len() <= 19,
"reply was not capped, got {}",
reply.len()
);
}
#[test]
fn a_flow_cannot_open_more_connections_than_its_budget() {
use std::io::Write as _;
let listener = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
let addr = listener.local_addr().unwrap();
std::thread::spawn(move || {
if let Ok((mut sock, _)) = listener.accept() {
let _ = sock.write_all(b"ok");
}
});
let mut probe = SocketProbe::new(addr, Protocol::Tcp, None, &budget(4096, 5_000, 1));
assert!(
probe.speak(b"a").is_some(),
"the one permitted exchange failed"
);
assert!(
probe.speak(b"b").is_none(),
"a second connection was opened past the budget"
);
assert_eq!(probe.last_refusal(), Some(ProbeRefusal::Connections));
}
#[test]
fn an_expired_time_budget_refuses_the_exchange() {
let addr: SocketAddr = "192.0.2.1:9".parse().unwrap();
let mut probe = SocketProbe::new(addr, Protocol::Tcp, None, &budget(4096, 0, 8));
assert!(probe.speak(b"anything").is_none());
assert_eq!(probe.last_refusal(), Some(ProbeRefusal::Deadline));
}
#[test]
fn a_send_past_the_byte_budget_is_refused_and_names_the_budget() {
let addr: SocketAddr = "192.0.2.1:9".parse().unwrap();
let mut probe = SocketProbe::new(addr, Protocol::Tcp, None, &budget(4, 5_000, 8));
assert!(probe.speak(b"far too long").is_none());
assert_eq!(probe.last_refusal(), Some(ProbeRefusal::Bytes));
}
#[test]
fn an_sctp_port_is_unanswered_rather_than_refused() {
let addr: SocketAddr = "192.0.2.1:9".parse().unwrap();
let mut probe = SocketProbe::new(addr, Protocol::Sctp, None, &budget(4096, 5_000, 8));
assert!(probe.speak(b"anything").is_none());
assert_eq!(probe.last_refusal(), None);
}
}