use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
use crate::model::mac::MacAddr;
use crate::model::ip::range::{Ipv4Range, Ipv6Range};
use crate::model::ip::set::IpSet;
use crate::protocols::{arp, ndp};
use crate::scanner::dispatcher::WalkOrder;
type Bytes = Vec<u8>;
pub(super) type PacketIter = Box<dyn Iterator<Item = (Bytes, IpAddr)> + Send>;
pub fn eth_packet_iter(
local_mac: &MacAddr,
src_v4: &Option<Ipv4Addr>,
link_local: &Option<Ipv6Addr>,
ip_set: &IpSet,
walk: Option<&WalkOrder>,
) -> PacketIter {
let arp_iter = src_v4
.as_ref()
.map(|v4| build_arp_iter(local_mac, v4, ip_set, walk))
.into_iter()
.flatten();
let ndp_iter = link_local
.as_ref()
.map(|v6| build_ndp_iter(local_mac, v6, ip_set, walk))
.into_iter()
.flatten();
Box::new(Interleave::new(
Box::new(arp_iter),
ip_set.v4_len(),
Box::new(ndp_iter),
ip_set.v6_len(),
))
}
struct Interleave {
left: PacketIter,
right: PacketIter,
credit: i128,
left_len: i128,
right_len: i128,
}
impl Interleave {
fn new(left: PacketIter, left_len: u128, right: PacketIter, right_len: u128) -> Self {
Self {
left,
right,
credit: 0,
left_len: left_len.min(i128::MAX as u128) as i128,
right_len: right_len.min(i128::MAX as u128) as i128,
}
}
}
impl Iterator for Interleave {
type Item = (Bytes, IpAddr);
fn next(&mut self) -> Option<Self::Item> {
if self.left_len <= 0 || self.right_len <= 0 {
return self.left.next().or_else(|| self.right.next());
}
if self.credit >= 0 {
self.credit -= self.right_len;
if let Some(item) = self.left.next() {
return Some(item);
}
}
self.credit += self.left_len;
self.right.next().or_else(|| self.left.next())
}
}
fn build_ndp_iter(
local_mac: &MacAddr,
src_addr: &Ipv6Addr,
ip_set: &IpSet,
walk: Option<&WalkOrder>,
) -> PacketIter {
let local_mac = *local_mac;
let src_addr = *src_addr;
let ranges: Vec<Ipv6Range> = ip_set.v6().to_vec();
let targets = ranges.into_iter().flat_map(|range| {
let start: u128 = range.start_addr().into();
let end: u128 = range.end_addr().into();
(start..=end).map(Ipv6Addr::from)
});
let held = ip_set.clone();
let owed = move |address| match address {
IpAddr::V6(v6) if held.contains(&address) => Some(v6),
_ => None,
};
let iter = in_order(targets, ip_set.v6_len(), walk, owed).map(move |target| {
let packet = ndp::build_neighbor_solicitation(local_mac, src_addr, target);
(packet, IpAddr::V6(target))
});
Box::new(iter)
}
pub fn build_arp_iter(
local_mac: &MacAddr,
src_ip: &Ipv4Addr,
ip_set: &IpSet,
walk: Option<&WalkOrder>,
) -> PacketIter {
let local_mac = *local_mac;
let src_ip = *src_ip;
let ranges: Vec<Ipv4Range> = ip_set.v4().to_vec();
let targets = ranges.into_iter().flat_map(|range| {
let start: u32 = range.start_addr().into();
let end: u32 = range.end_addr().into();
(start..=end).map(Ipv4Addr::from)
});
let held = ip_set.clone();
let owed = move |address| match address {
IpAddr::V4(v4) if held.contains(&address) => Some(v4),
_ => None,
};
let iter = in_order(targets, ip_set.v4_len(), walk, owed).map(move |dst_addr| {
let packet = arp::build_request(local_mac, src_ip, dst_addr);
(packet, IpAddr::V4(dst_addr))
});
Box::new(iter)
}
fn in_order<A>(
targets: impl Iterator<Item = A> + Send + 'static,
count: u128,
walk: Option<&WalkOrder>,
owed: impl Fn(IpAddr) -> Option<A> + Send + 'static,
) -> Box<dyn Iterator<Item = A> + Send>
where
A: Copy + Into<IpAddr> + Send + 'static,
{
match walk {
Some(walk) if walk.draws(count) => {
let numbered = walk.clone();
let unnumbered = targets.filter(move |target| !numbered.numbers((*target).into()));
Box::new(walk.addresses().filter_map(owed).chain(unnumbered))
}
Some(walk) => {
let mut targets: Vec<A> = targets.collect();
walk.arrange(&mut targets);
Box::new(targets.into_iter())
}
None => Box::new(targets),
}
}
#[cfg(test)]
mod tests {
use super::*;
fn stream(count: u32, v6: bool) -> PacketIter {
Box::new((0..count).map(move |i| {
let ip = if v6 {
IpAddr::V6(Ipv6Addr::new(0xfe80, 0, 0, 0, 0, 0, 0, i as u16))
} else {
IpAddr::V4(Ipv4Addr::new(10, 0, 0, i as u8))
};
(Vec::new(), ip)
}))
}
fn interleaved(left: u32, right: u32) -> Vec<IpAddr> {
Interleave::new(
stream(left, false),
left as u128,
stream(right, true),
right as u128,
)
.map(|(_, ip)| ip)
.collect()
}
#[test]
fn interleaving_emits_every_probe_exactly_once() {
for (left, right) in [(254, 27), (27, 254), (1, 1), (0, 5), (5, 0), (0, 0), (7, 3)] {
let out = interleaved(left, right);
assert_eq!(out.len(), (left + right) as usize, "{left} and {right}");
assert_eq!(
out.iter().filter(|ip| ip.is_ipv4()).count(),
left as usize,
"{left} and {right}"
);
}
}
#[test]
fn interleaving_spreads_the_smaller_stream_across_the_whole_sweep() {
let out = interleaved(254, 27);
let positions: Vec<usize> = out
.iter()
.enumerate()
.filter(|(_, ip)| ip.is_ipv6())
.map(|(i, _)| i)
.collect();
assert_eq!(positions.len(), 27);
let smallest_gap = positions
.windows(2)
.map(|pair| pair[1] - pair[0])
.min()
.expect("more than one solicitation");
assert!(
smallest_gap >= 8,
"solicitations {smallest_gap} apart is a burst, not a spread: {positions:?}"
);
assert!(
positions.last().expect("a last solicitation") > &(out.len() - 20),
"the stream should reach the end of the sweep, not finish early"
);
}
fn walked(plan: &str, ips: &str) -> (Vec<Ipv4Addr>, Vec<Ipv4Addr>, usize) {
use crate::model::ip::set::Positions;
use crate::scanner::session::ScanSession;
use std::sync::Arc;
use std::sync::atomic::{AtomicUsize, Ordering};
let plan: IpSet = plan.parse().expect("a plan");
let ips: IpSet = ips.parse().expect("a sweep");
let (_session, ctx) = ScanSession::builder()
.ordering(Some(0x5EED))
.counting(Positions::of(&plan))
.build();
let walk = WalkOrder::of(&ips, &ctx).expect("a seeded scan walks");
let expand = |ips: &IpSet| {
let ranges: Vec<Ipv4Range> = ips.v4().to_vec();
ranges.into_iter().flat_map(|range| {
(u32::from(range.start_addr())..=u32::from(range.end_addr())).map(Ipv4Addr::from)
})
};
let mut sorted: Vec<Ipv4Addr> = expand(&ips).collect();
walk.arrange(&mut sorted);
let drawn = Arc::new(AtomicUsize::new(0));
let counter = Arc::clone(&drawn);
let source = expand(&ips).inspect(move |_| {
counter.fetch_add(1, Ordering::SeqCst);
});
let held = ips.clone();
let owed = move |address| match address {
IpAddr::V4(v4) if held.contains(&address) => Some(v4),
_ => None,
};
let mut order = in_order(source, ips.v4_len(), Some(&walk), owed);
let first = order.next().expect("a first probe");
let before_first = drawn.load(Ordering::SeqCst);
(
sorted,
std::iter::once(first).chain(order).collect(),
before_first,
)
}
#[test]
fn a_seeded_sweep_leaves_in_the_walk_however_it_is_arranged() {
let (sorted, drawn, _) = walked("192.0.2.0/24", "192.0.2.0-192.0.2.200, 198.51.100.7");
assert_eq!(drawn, sorted);
assert_eq!(drawn.last(), Some(&Ipv4Addr::new(198, 51, 100, 7)));
let (sorted, collected, _) = walked("10.0.0.0/16", "10.0.0.1-10.0.0.9");
assert_eq!(collected, sorted);
}
#[test]
fn a_dense_seeded_sweep_draws_its_first_probe_without_expanding_the_rest() {
let (_, order, before_first) = walked("10.0.0.0/16", "10.0.0.0/16");
assert_eq!(order.len(), 1 << 16, "every address, once");
assert_eq!(before_first, 0, "addresses expanded before the first left");
}
}