use crate::network::dpi::DpiResult;
use crate::network::link_layer;
#[cfg(target_os = "macos")]
use crate::network::link_layer::ethernet;
#[cfg(target_os = "macos")]
use crate::network::link_layer::pktap;
use crate::network::local_addresses::collect_local_ips;
use crate::network::oui::OuiLookup;
use crate::network::protocol;
use crate::network::protocol::TransportParams;
use crate::network::types::*;
use std::net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr};
use std::time::{Duration, Instant};
const AMBIGUOUS_ENDPOINT_REFRESH_INTERVAL: Duration = Duration::from_secs(1);
const AMBIGUOUS_ENDPOINT_REFRESH_MAX_INTERVAL: Duration = Duration::from_secs(60);
pub use crate::network::protocol::tcp::{TcpFlags, TcpHeaderInfo};
#[derive(Debug)]
pub struct ParsedPacket {
pub protocol: Protocol,
pub local_addr: SocketAddr,
pub remote_addr: SocketAddr,
pub tcp_header: Option<TcpHeaderInfo>, pub protocol_state: ProtocolState,
pub is_outgoing: bool,
pub packet_len: usize,
pub dpi_result: Option<DpiResult>, pub process_name: Option<String>, pub process_id: Option<u32>, }
impl ParsedPacket {
#[inline]
pub fn connection_key(&self) -> ConnectionKey {
ConnectionKey::new(self.protocol, self.local_addr, self.remote_addr)
}
}
#[derive(Clone)]
pub struct ParserConfig {
pub enable_dpi: bool,
pub dpi_packet_limit: usize,
}
impl Default for ParserConfig {
fn default() -> Self {
let config = Self {
enable_dpi: true,
dpi_packet_limit: 10, };
log::trace!(
"ParserConfig: DPI {} (limit: {} packets per connection)",
if config.enable_dpi {
"enabled"
} else {
"disabled"
},
config.dpi_packet_limit
);
if config.enable_dpi {
log::trace!(" - Packet 0: DPI = {}", config.should_perform_dpi(0));
log::trace!(
" - Packet {}: DPI = {}",
config.dpi_packet_limit - 1,
config.should_perform_dpi(config.dpi_packet_limit - 1)
);
log::trace!(
" - Packet {}: DPI = {}",
config.dpi_packet_limit,
config.should_perform_dpi(config.dpi_packet_limit)
);
}
config
}
}
impl ParserConfig {
pub fn should_perform_dpi(&self, packet_count: usize) -> bool {
let should_dpi = self.enable_dpi && packet_count < self.dpi_packet_limit;
if !should_dpi && self.enable_dpi {
log::trace!(
"DPI skipped: packet {} exceeds limit {}",
packet_count,
self.dpi_packet_limit
);
}
should_dpi
}
}
pub struct PacketParser {
local_ips: std::collections::HashSet<IpAddr>,
last_local_ip_refresh: Instant,
last_ambiguous_endpoint_refresh: Option<Instant>,
unchanged_ambiguous_refreshes: u32,
config: ParserConfig,
linktype: Option<i32>, oui_lookup: Option<OuiLookup>,
}
impl Default for PacketParser {
fn default() -> Self {
Self::new()
}
}
impl PacketParser {
pub fn new() -> Self {
Self {
local_ips: collect_local_ips(),
last_local_ip_refresh: Instant::now(),
last_ambiguous_endpoint_refresh: None,
unchanged_ambiguous_refreshes: 0,
config: ParserConfig::default(),
linktype: None,
oui_lookup: None,
}
}
pub fn with_config(config: ParserConfig) -> Self {
Self {
local_ips: collect_local_ips(),
last_local_ip_refresh: Instant::now(),
last_ambiguous_endpoint_refresh: None,
unchanged_ambiguous_refreshes: 0,
config,
linktype: None,
oui_lookup: None,
}
}
pub fn with_oui_lookup(mut self, oui_lookup: OuiLookup) -> Self {
self.oui_lookup = Some(oui_lookup);
self
}
pub fn with_linktype(mut self, linktype: i32) -> Self {
self.linktype = Some(linktype);
let link_type = link_layer::LinkLayerType::from_dlt(linktype);
if link_type.is_tunnel() {
log::debug!(
"Parser configured for tunnel interface: linktype {} ({:?})",
linktype,
link_type
);
log::trace!("TUN/TAP parsing available via link_layer::tun_tap module");
log::trace!(" - TUN interfaces (Layer 3): tun*, utun*");
log::trace!(" - TAP interfaces (Layer 2): tap*");
} else {
log::trace!(
"Parser configured with linktype {} ({:?})",
linktype,
link_type
);
}
self
}
pub fn refresh_local_ips(&mut self) -> bool {
self.refresh_local_ips_with(collect_local_ips)
}
pub fn refresh_local_ips_if_due(&mut self, interval: Duration) -> bool {
if self.last_local_ip_refresh.elapsed() < interval {
return false;
}
self.refresh_local_ips()
}
pub fn parse_packet_with_refresh(&mut self, data: &[u8]) -> Option<ParsedPacket> {
self.parse_packet_with_local_ip_collector(data, collect_local_ips)
}
pub fn parse_packet(&self, data: &[u8]) -> Option<ParsedPacket> {
if let Some(linktype) = self.linktype {
let link_type = link_layer::LinkLayerType::from_dlt(linktype);
log::trace!(
"Parsing packet with linktype {} ({:?})",
linktype,
link_type
);
match linktype {
#[cfg(target_os = "macos")]
149 | 258 if pktap::is_pktap_linktype(linktype) => {
log::debug!("Parsing as PKTAP (linktype {})", linktype);
return self.parse_pktap_packet(data);
}
113 => {
log::debug!("Parsing as Linux SLL (linktype 113)");
return link_layer::linux_sll::parse_sll(data, self, None, None);
}
276 => {
log::debug!("Parsing as Linux SLL2 (linktype 276)");
return link_layer::linux_sll::parse_sll2(data, self, None, None);
}
0
| 1
| 12
| 101
| link_layer::dlt::LINKTYPE_IPV4
| link_layer::dlt::LINKTYPE_IPV6 => {
log::debug!("Parsing TUN/TAP packet (linktype {})", linktype);
return link_layer::tun_tap::parse_by_dlt(data, linktype, self, None, None);
}
_ => {
log::debug!("Unknown linktype {}, trying Ethernet", linktype);
}
}
}
log::debug!("Using fallback Ethernet parsing");
link_layer::ethernet::parse(data, self, None, None)
}
fn parse_packet_with_local_ip_collector<F>(
&mut self,
data: &[u8],
collector: F,
) -> Option<ParsedPacket>
where
F: FnOnce() -> std::collections::HashSet<IpAddr>,
{
let parsed = self.parse_packet(data)?;
let local_ip = parsed.local_addr.ip();
let remote_ip = parsed.remote_addr.ip();
if self.local_ips.contains(&local_ip)
|| self.local_ips.contains(&remote_ip)
|| !is_unicast_endpoint(local_ip)
|| !is_unicast_endpoint(remote_ip)
{
return Some(parsed);
}
let now = Instant::now();
if self
.last_ambiguous_endpoint_refresh
.is_some_and(|last| now.duration_since(last) < self.ambiguous_refresh_interval())
{
return Some(parsed);
}
self.last_ambiguous_endpoint_refresh = Some(now);
if self.refresh_local_ips_with(collector) {
self.parse_packet(data)
} else {
self.unchanged_ambiguous_refreshes =
self.unchanged_ambiguous_refreshes.saturating_add(1);
Some(parsed)
}
}
fn ambiguous_refresh_interval(&self) -> Duration {
let factor = 1u32 << self.unchanged_ambiguous_refreshes.min(6);
AMBIGUOUS_ENDPOINT_REFRESH_INTERVAL
.saturating_mul(factor)
.min(AMBIGUOUS_ENDPOINT_REFRESH_MAX_INTERVAL)
}
fn refresh_local_ips_with<F>(&mut self, collector: F) -> bool
where
F: FnOnce() -> std::collections::HashSet<IpAddr>,
{
let refreshed = collector();
self.last_local_ip_refresh = Instant::now();
if refreshed == self.local_ips {
return false;
}
log::debug!(
"Local address set changed: {} -> {} address(es)",
self.local_ips.len(),
refreshed.len()
);
self.local_ips = refreshed;
self.unchanged_ambiguous_refreshes = 0;
true
}
#[cfg(target_os = "macos")]
fn parse_pktap_packet(&self, data: &[u8]) -> Option<ParsedPacket> {
let (pktap_header, payload) = pktap::parse_pktap_packet(data)?;
let (process_name, process_id) = pktap_header.get_process_info();
log::debug!(
"PKTAP packet: interface={}, process={:?}, pid={:?}, payload_len={}",
pktap_header.get_interface(),
process_name,
process_id,
payload.len()
);
match pktap_header.inner_dlt() {
1 => {
ethernet::parse(payload, self, process_name, process_id)
}
12 => {
if payload.is_empty() {
return None;
}
let version = payload[0] >> 4;
match version {
4 => self.parse_raw_ipv4_packet(payload, process_name, process_id),
6 => self.parse_raw_ipv6_packet(payload, process_name, process_id),
_ => None,
}
}
_ => {
log::debug!("Unsupported PKTAP inner DLT: {}", pktap_header.inner_dlt());
None
}
}
}
pub fn parse_ipv4_packet_inner(
&self,
data: &[u8],
offset: usize,
process_name: Option<String>,
process_id: Option<u32>,
) -> Option<ParsedPacket> {
let ip_data = &data[offset..];
if ip_data.len() < 20 {
return None;
}
let version = ip_data[0] >> 4;
if version != 4 {
return None;
}
let ip_total_length = u16::from_be_bytes([ip_data[2], ip_data[3]]) as usize;
let actual_packet_len = offset + ip_total_length;
let fragment_offset = u16::from_be_bytes([ip_data[6], ip_data[7]]) & 0x1FFF;
if fragment_offset != 0 {
return None;
}
let protocol_num = ip_data[9];
let src_ip = IpAddr::V4(Ipv4Addr::new(
ip_data[12],
ip_data[13],
ip_data[14],
ip_data[15],
));
let dst_ip = IpAddr::V4(Ipv4Addr::new(
ip_data[16],
ip_data[17],
ip_data[18],
ip_data[19],
));
let ihl = ip_data[0] & 0x0F;
if ihl < 5 {
return None;
}
let ip_header_len = (ihl as usize) * 4;
if ip_data.len() < ip_header_len {
return None;
}
let transport_data = &ip_data[ip_header_len..];
let transport_data = match ip_total_length.checked_sub(ip_header_len) {
Some(payload_len) => &transport_data[..payload_len.min(transport_data.len())],
None => transport_data,
};
let params =
TransportParams::new(src_ip, dst_ip, actual_packet_len, process_name, process_id);
match protocol_num {
1 => protocol::icmp::parse(transport_data, params, &self.local_ips),
2 => protocol::igmp::parse(transport_data, params, &self.local_ips),
6 => protocol::tcp::parse(transport_data, params, &self.config, &self.local_ips),
17 => protocol::udp::parse(transport_data, params, &self.config, &self.local_ips),
_ => None,
}
}
pub fn parse_ipv6_packet_inner(
&self,
data: &[u8],
offset: usize,
process_name: Option<String>,
process_id: Option<u32>,
) -> Option<ParsedPacket> {
let ip_data = &data[offset..];
if ip_data.len() < 40 {
return None;
}
let version = ip_data[0] >> 4;
if version != 6 {
return None;
}
let ipv6_payload_length = u16::from_be_bytes([ip_data[4], ip_data[5]]) as usize;
let actual_packet_len = offset + 40 + ipv6_payload_length;
let next_header = ip_data[6];
let src_ip = IpAddr::V6(Ipv6Addr::new(
u16::from_be_bytes([ip_data[8], ip_data[9]]),
u16::from_be_bytes([ip_data[10], ip_data[11]]),
u16::from_be_bytes([ip_data[12], ip_data[13]]),
u16::from_be_bytes([ip_data[14], ip_data[15]]),
u16::from_be_bytes([ip_data[16], ip_data[17]]),
u16::from_be_bytes([ip_data[18], ip_data[19]]),
u16::from_be_bytes([ip_data[20], ip_data[21]]),
u16::from_be_bytes([ip_data[22], ip_data[23]]),
));
let dst_ip = IpAddr::V6(Ipv6Addr::new(
u16::from_be_bytes([ip_data[24], ip_data[25]]),
u16::from_be_bytes([ip_data[26], ip_data[27]]),
u16::from_be_bytes([ip_data[28], ip_data[29]]),
u16::from_be_bytes([ip_data[30], ip_data[31]]),
u16::from_be_bytes([ip_data[32], ip_data[33]]),
u16::from_be_bytes([ip_data[34], ip_data[35]]),
u16::from_be_bytes([ip_data[36], ip_data[37]]),
u16::from_be_bytes([ip_data[38], ip_data[39]]),
));
let transport_data = &ip_data[40..];
let transport_data = if ipv6_payload_length == 0 {
transport_data
} else {
&transport_data[..ipv6_payload_length.min(transport_data.len())]
};
let (final_next_header, transport_offset) =
self.parse_ipv6_extension_headers(next_header, transport_data)?;
let final_transport_data = &transport_data[transport_offset.min(transport_data.len())..];
let params =
TransportParams::new(src_ip, dst_ip, actual_packet_len, process_name, process_id);
match final_next_header {
58 => protocol::icmp::parse_v6(final_transport_data, params, &self.local_ips),
6 => protocol::tcp::parse(final_transport_data, params, &self.config, &self.local_ips),
17 => protocol::udp::parse(final_transport_data, params, &self.config, &self.local_ips),
_ => None,
}
}
pub fn parse_arp_packet_inner(
&self,
data: &[u8],
offset: usize,
process_name: Option<String>,
process_id: Option<u32>,
) -> Option<ParsedPacket> {
self.parse_arp_packet_with_offset(data, offset, process_name, process_id)
}
pub fn parse_arp_packet_with_offset(
&self,
data: &[u8],
header_len: usize,
process_name: Option<String>,
process_id: Option<u32>,
) -> Option<ParsedPacket> {
let arp_data = &data[header_len..];
if arp_data.len() < 28 {
return None;
}
let hardware_type = u16::from_be_bytes([arp_data[0], arp_data[1]]);
let protocol_type = u16::from_be_bytes([arp_data[2], arp_data[3]]);
let opcode = u16::from_be_bytes([arp_data[6], arp_data[7]]);
if hardware_type != 1 || protocol_type != 0x0800 {
return None;
}
let sender_mac = format!(
"{:02x}:{:02x}:{:02x}:{:02x}:{:02x}:{:02x}",
arp_data[8], arp_data[9], arp_data[10], arp_data[11], arp_data[12], arp_data[13]
);
let target_mac = format!(
"{:02x}:{:02x}:{:02x}:{:02x}:{:02x}:{:02x}",
arp_data[18], arp_data[19], arp_data[20], arp_data[21], arp_data[22], arp_data[23]
);
let sender_ip = IpAddr::from([arp_data[14], arp_data[15], arp_data[16], arp_data[17]]);
let target_ip = IpAddr::from([arp_data[24], arp_data[25], arp_data[26], arp_data[27]]);
let operation = match opcode {
1 => ArpOperation::Request,
2 => ArpOperation::Reply,
_ => return None,
};
let sender_vendor = self
.oui_lookup
.as_ref()
.and_then(|oui| oui.lookup(&sender_mac).map(String::from));
let target_vendor = self
.oui_lookup
.as_ref()
.and_then(|oui| oui.lookup(&target_mac).map(String::from));
let arp_info = ArpInfo {
operation,
sender_mac,
sender_ip,
target_mac,
target_ip,
sender_vendor,
target_vendor,
};
let is_outgoing = self.local_ips.contains(&sender_ip);
let (local_addr, remote_addr) = if is_outgoing {
(SocketAddr::new(sender_ip, 0), SocketAddr::new(target_ip, 0))
} else {
(SocketAddr::new(target_ip, 0), SocketAddr::new(sender_ip, 0))
};
Some(ParsedPacket {
protocol: Protocol::Arp,
local_addr,
remote_addr,
tcp_header: None,
protocol_state: ProtocolState::Arp(arp_info),
is_outgoing,
packet_len: data.len(),
dpi_result: None,
process_name,
process_id,
})
}
pub fn parse_raw_ipv4_packet(
&self,
data: &[u8],
process_name: Option<String>,
process_id: Option<u32>,
) -> Option<ParsedPacket> {
if data.len() < 20 {
return None;
}
let version = data[0] >> 4;
if version != 4 {
return None;
}
let actual_packet_len = u16::from_be_bytes([data[2], data[3]]) as usize;
let fragment_offset = u16::from_be_bytes([data[6], data[7]]) & 0x1FFF;
if fragment_offset != 0 {
return None;
}
let protocol_num = data[9];
let src_ip = IpAddr::V4(Ipv4Addr::new(data[12], data[13], data[14], data[15]));
let dst_ip = IpAddr::V4(Ipv4Addr::new(data[16], data[17], data[18], data[19]));
let ihl = data[0] & 0x0F;
if ihl < 5 {
return None;
}
let ip_header_len = (ihl as usize) * 4;
if data.len() < ip_header_len {
return None;
}
let transport_data = &data[ip_header_len..];
let transport_data = match actual_packet_len.checked_sub(ip_header_len) {
Some(payload_len) => &transport_data[..payload_len.min(transport_data.len())],
None => transport_data,
};
let params =
TransportParams::new(src_ip, dst_ip, actual_packet_len, process_name, process_id);
match protocol_num {
1 => protocol::icmp::parse(transport_data, params, &self.local_ips),
2 => protocol::igmp::parse(transport_data, params, &self.local_ips),
6 => protocol::tcp::parse(transport_data, params, &self.config, &self.local_ips),
17 => protocol::udp::parse(transport_data, params, &self.config, &self.local_ips),
_ => None,
}
}
pub fn parse_raw_ipv6_packet(
&self,
data: &[u8],
process_name: Option<String>,
process_id: Option<u32>,
) -> Option<ParsedPacket> {
if data.len() < 40 {
return None;
}
let version = data[0] >> 4;
if version != 6 {
return None;
}
let ipv6_payload_length = u16::from_be_bytes([data[4], data[5]]) as usize;
let actual_packet_len = 40 + ipv6_payload_length;
let next_header = data[6];
let src_ip = IpAddr::V6(Ipv6Addr::new(
u16::from_be_bytes([data[8], data[9]]),
u16::from_be_bytes([data[10], data[11]]),
u16::from_be_bytes([data[12], data[13]]),
u16::from_be_bytes([data[14], data[15]]),
u16::from_be_bytes([data[16], data[17]]),
u16::from_be_bytes([data[18], data[19]]),
u16::from_be_bytes([data[20], data[21]]),
u16::from_be_bytes([data[22], data[23]]),
));
let dst_ip = IpAddr::V6(Ipv6Addr::new(
u16::from_be_bytes([data[24], data[25]]),
u16::from_be_bytes([data[26], data[27]]),
u16::from_be_bytes([data[28], data[29]]),
u16::from_be_bytes([data[30], data[31]]),
u16::from_be_bytes([data[32], data[33]]),
u16::from_be_bytes([data[34], data[35]]),
u16::from_be_bytes([data[36], data[37]]),
u16::from_be_bytes([data[38], data[39]]),
));
let transport_data = &data[40..];
let transport_data = if ipv6_payload_length == 0 {
transport_data
} else {
&transport_data[..ipv6_payload_length.min(transport_data.len())]
};
let (final_next_header, transport_offset) =
self.parse_ipv6_extension_headers(next_header, transport_data)?;
let final_transport_data = &transport_data[transport_offset.min(transport_data.len())..];
let params =
TransportParams::new(src_ip, dst_ip, actual_packet_len, process_name, process_id);
match final_next_header {
58 => protocol::icmp::parse_v6(final_transport_data, params, &self.local_ips),
6 => protocol::tcp::parse(final_transport_data, params, &self.config, &self.local_ips),
17 => protocol::udp::parse(final_transport_data, params, &self.config, &self.local_ips),
_ => None,
}
}
fn parse_ipv6_extension_headers(
&self,
mut next_header: u8,
data: &[u8],
) -> Option<(u8, usize)> {
let mut offset = 0;
const HOP_BY_HOP: u8 = 0;
const ROUTING: u8 = 43;
const FRAGMENT: u8 = 44;
const ENCAPSULATING_SECURITY: u8 = 50;
const AUTHENTICATION: u8 = 51;
const DESTINATION_OPTIONS: u8 = 60;
loop {
match next_header {
HOP_BY_HOP | ROUTING | DESTINATION_OPTIONS => {
if data.len() < offset + 2 {
return Some((next_header, offset));
}
next_header = data[offset];
let header_len = ((data[offset + 1] as usize) + 1) * 8;
offset += header_len;
}
FRAGMENT => {
if data.len() < offset + 8 {
return Some((next_header, offset));
}
let fragment_offset =
u16::from_be_bytes([data[offset + 2], data[offset + 3]]) >> 3;
if fragment_offset != 0 {
return None;
}
next_header = data[offset];
offset += 8;
}
AUTHENTICATION => {
if data.len() < offset + 2 {
return Some((next_header, offset));
}
next_header = data[offset];
let header_len = ((data[offset + 1] as usize) + 2) * 4;
offset += header_len;
}
ENCAPSULATING_SECURITY => {
return Some((next_header, offset));
}
_ => {
return Some((next_header, offset));
}
}
if offset >= data.len() {
return Some((next_header, offset));
}
}
}
}
fn is_unicast_endpoint(ip: IpAddr) -> bool {
match ip {
IpAddr::V4(ip) => !ip.is_unspecified() && !ip.is_multicast() && ip != Ipv4Addr::BROADCAST,
IpAddr::V6(ip) => !ip.is_unspecified() && !ip.is_multicast(),
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::net::IpAddr;
fn create_parser_with_linktype(linktype: i32) -> PacketParser {
let mut parser = PacketParser::with_config(ParserConfig::default()).with_linktype(linktype);
parser
.local_ips
.insert(IpAddr::V4(Ipv4Addr::new(192, 168, 1, 100)));
parser
}
fn ethernet_ipv4_tcp_syn() -> Vec<u8> {
vec![
0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff, 0x08, 0x00,
0x45, 0x00, 0x00, 0x28, 0x00, 0x01, 0x00, 0x00, 0x40, 0x06, 0x00, 0x00, 192, 168, 1,
100, 93, 184, 216, 34, 0x04, 0xd2, 0x00, 0x50, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x50, 0x02,
0x20, 0x00, 0x00, 0x00, 0x00, 0x00,
]
}
fn ethernet_ipv4_udp_dns() -> Vec<u8> {
vec![
0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff, 0x08, 0x00,
0x45, 0x00, 0x00, 0x20, 0x00, 0x01, 0x00, 0x00, 0x40, 0x11, 0x00, 0x00, 192, 168, 1,
100, 8, 8, 8, 8, 0x04, 0xd2, 0x00, 0x35, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04,
]
}
fn ethernet_ipv6_tcp() -> Vec<u8> {
vec![
0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff, 0x86, 0xdd,
0x60, 0x00, 0x00, 0x00, 0x00, 0x14, 0x06, 0x40, 0x20, 0x01, 0x0d, 0xb8, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x20, 0x01, 0x0d, 0xb8,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
0x04, 0xd2, 0x00, 0x50, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x50, 0x02,
0x20, 0x00, 0x00, 0x00, 0x00, 0x00,
]
}
fn linux_sll_ipv4_tcp() -> Vec<u8> {
vec![
0x00, 0x00, 0x00, 0x01, 0x00, 0x06, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff, 0x00, 0x00,
0x08, 0x00, 0x45, 0x00, 0x00, 0x28, 0x00, 0x01, 0x00, 0x00, 0x40, 0x06, 0x00, 0x00, 192, 168, 1,
100, 93, 184, 216, 34, 0x04, 0xd2, 0x00, 0x50, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x50, 0x02,
0x20, 0x00, 0x00, 0x00, 0x00, 0x00,
]
}
fn linux_sll2_ipv4_udp() -> Vec<u8> {
vec![
0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x06, 0xaa, 0xbb,
0xcc, 0xdd, 0xee, 0xff, 0x00, 0x00, 0x45, 0x00, 0x00, 0x20, 0x00, 0x01, 0x00, 0x00, 0x40, 0x11, 0x00, 0x00, 192, 168, 1,
100, 8, 8, 8, 8, 0x04, 0xd2, 0x00, 0x35, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04,
]
}
#[test]
fn test_ethernet_ipv4_tcp_parsing() {
let parser = create_parser_with_linktype(1); let packet = ethernet_ipv4_tcp_syn();
let parsed = parser.parse_packet(&packet);
assert!(
parsed.is_some(),
"Should parse valid Ethernet IPv4 TCP packet"
);
let p = parsed.unwrap();
assert_eq!(p.protocol, Protocol::Tcp);
assert_eq!(p.local_addr.port(), 1234, "Local port should be 1234");
assert_eq!(p.remote_addr.port(), 80, "Remote port should be 80");
assert!(p.tcp_header.is_some());
assert!(p.tcp_header.unwrap().flags.syn, "SYN flag should be set");
}
#[test]
fn test_ethernet_ipv4_udp_parsing() {
let parser = create_parser_with_linktype(1);
let packet = ethernet_ipv4_udp_dns();
let parsed = parser.parse_packet(&packet);
assert!(parsed.is_some());
let p = parsed.unwrap();
assert_eq!(p.protocol, Protocol::Udp);
assert_eq!(p.local_addr.port(), 1234);
assert_eq!(p.remote_addr.port(), 53, "Should detect DNS port");
}
#[test]
fn test_ethernet_ipv6_tcp_parsing() {
let parser = create_parser_with_linktype(1);
let packet = ethernet_ipv6_tcp();
let parsed = parser.parse_packet(&packet);
assert!(parsed.is_some(), "Should parse IPv6 packets");
let p = parsed.unwrap();
assert_eq!(p.protocol, Protocol::Tcp);
assert!(matches!(p.local_addr.ip(), IpAddr::V6(_)), "Should be IPv6");
}
#[test]
fn test_truncated_ethernet_packet() {
let parser = create_parser_with_linktype(1);
let truncated = vec![0x00, 0x11, 0x22];
let parsed = parser.parse_packet(&truncated);
assert!(parsed.is_none(), "Should reject truncated packets");
}
#[test]
fn test_unknown_ethertype() {
let parser = create_parser_with_linktype(1);
let packet = vec![
0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff, 0xff,
0xff, ];
let parsed = parser.parse_packet(&packet);
assert!(parsed.is_none(), "Should reject unknown EtherType");
}
#[test]
fn test_linux_sll_ipv4_tcp_parsing() {
let parser = create_parser_with_linktype(113); let packet = linux_sll_ipv4_tcp();
let parsed = parser.parse_packet(&packet);
assert!(parsed.is_some(), "Should parse Linux SLL packets");
let p = parsed.unwrap();
assert_eq!(p.protocol, Protocol::Tcp);
assert_eq!(p.local_addr.port(), 1234);
assert_eq!(p.remote_addr.port(), 80);
}
#[test]
fn test_linux_sll_truncated() {
let parser = create_parser_with_linktype(113);
let truncated = vec![0x00, 0x00, 0x00];
let parsed = parser.parse_packet(&truncated);
assert!(parsed.is_none(), "Should reject truncated SLL packets");
}
#[test]
fn test_linux_sll2_ipv4_udp_parsing() {
let parser = create_parser_with_linktype(276); let packet = linux_sll2_ipv4_udp();
let parsed = parser.parse_packet(&packet);
assert!(parsed.is_some(), "Should parse Linux SLL2 packets");
let p = parsed.unwrap();
assert_eq!(p.protocol, Protocol::Udp);
assert_eq!(p.local_addr.port(), 1234);
assert_eq!(p.remote_addr.port(), 53);
}
#[test]
fn test_linux_sll2_truncated() {
let parser = create_parser_with_linktype(276);
let truncated = vec![0x08, 0x00];
let parsed = parser.parse_packet(&truncated);
assert!(parsed.is_none(), "Should reject truncated SLL2 packets");
}
#[test]
fn test_tcp_flags_parsing() {
use crate::network::protocol::tcp::parse_tcp_flags;
let flags = parse_tcp_flags(0x02); assert!(flags.syn);
assert!(!flags.ack);
assert!(!flags.fin);
let flags = parse_tcp_flags(0x12); assert!(flags.syn);
assert!(flags.ack);
let flags = parse_tcp_flags(0x11); assert!(flags.fin);
assert!(flags.ack);
}
#[test]
fn test_parser_default_config() {
let config = ParserConfig::default();
assert!(config.enable_dpi, "DPI should be enabled by default");
assert_eq!(config.dpi_packet_limit, 10);
}
#[test]
fn test_parser_with_linktype() {
let parser = PacketParser::with_config(ParserConfig::default()).with_linktype(1);
assert_eq!(parser.linktype, Some(1));
}
#[test]
fn test_local_ip_detection() {
let parser = PacketParser::new();
assert!(!parser.local_ips.is_empty(), "Should detect local IPs");
}
#[test]
fn ambiguous_ipv6_packet_refreshes_local_addresses_and_reorients_endpoints() {
let mut parser = create_parser_with_linktype(1);
parser.local_ips.clear();
parser.local_ips.insert(IpAddr::V4(Ipv4Addr::LOCALHOST));
parser.local_ips.insert(IpAddr::V6(Ipv6Addr::LOCALHOST));
let packet = ethernet_ipv6_tcp();
let stale = parser.parse_packet(&packet).expect("packet should parse");
assert!(!stale.is_outgoing);
assert_eq!(stale.local_addr.port(), 80);
let new_local = IpAddr::V6("2001:db8::1".parse().expect("valid fixture address"));
let corrected = parser
.parse_packet_with_local_ip_collector(&packet, || {
[
IpAddr::V4(Ipv4Addr::LOCALHOST),
IpAddr::V6(Ipv6Addr::LOCALHOST),
new_local,
]
.into_iter()
.collect()
})
.expect("packet should be reparsed");
assert!(corrected.is_outgoing);
assert_eq!(corrected.local_addr.ip(), new_local);
assert_eq!(corrected.local_addr.port(), 1234);
assert_eq!(corrected.remote_addr.port(), 80);
}
#[test]
fn refresh_replaces_addresses_that_are_no_longer_assigned() {
let mut parser = create_parser_with_linktype(1);
let old = IpAddr::V6("2001:db8::1".parse().expect("valid old address"));
let new = IpAddr::V6("2001:db8::2".parse().expect("valid new address"));
parser.local_ips = [old].into_iter().collect();
assert!(parser.refresh_local_ips_with(|| [new].into_iter().collect()));
assert!(!parser.local_ips.contains(&old));
assert!(parser.local_ips.contains(&new));
}
#[test]
fn ambiguous_refresh_is_rate_limited_between_packets() {
use std::cell::Cell;
let mut parser = create_parser_with_linktype(1);
parser.local_ips.clear();
parser.local_ips.insert(IpAddr::V4(Ipv4Addr::LOCALHOST));
let packet = ethernet_ipv6_tcp();
let collector_calls = Cell::new(0u32);
let unchanged_collector = || {
collector_calls.set(collector_calls.get() + 1);
[IpAddr::V4(Ipv4Addr::LOCALHOST)].into_iter().collect()
};
parser
.parse_packet_with_local_ip_collector(&packet, unchanged_collector)
.expect("packet should parse");
parser
.parse_packet_with_local_ip_collector(&packet, unchanged_collector)
.expect("packet should parse");
assert_eq!(
collector_calls.get(),
1,
"second ambiguous packet within the refresh interval must not re-enumerate"
);
}
#[test]
fn fruitless_ambiguous_refreshes_back_off_exponentially() {
let mut parser = create_parser_with_linktype(1);
assert_eq!(parser.ambiguous_refresh_interval(), Duration::from_secs(1));
parser.unchanged_ambiguous_refreshes = 3;
assert_eq!(parser.ambiguous_refresh_interval(), Duration::from_secs(8));
parser.unchanged_ambiguous_refreshes = 100;
assert_eq!(
parser.ambiguous_refresh_interval(),
AMBIGUOUS_ENDPOINT_REFRESH_MAX_INTERVAL
);
let new = IpAddr::V6("2001:db8::99".parse().expect("valid address"));
assert!(parser.refresh_local_ips_with(|| [new].into_iter().collect()));
assert_eq!(
parser.unchanged_ambiguous_refreshes, 0,
"a refresh that observes a change must reset the backoff"
);
}
#[test]
fn periodic_refresh_waits_for_interval() {
let mut parser = create_parser_with_linktype(1);
let bogus = IpAddr::V6("2001:db8::dead".parse().expect("valid address"));
parser.local_ips = [bogus].into_iter().collect();
assert!(!parser.refresh_local_ips_if_due(Duration::from_secs(3600)));
assert!(
parser.local_ips.contains(&bogus),
"snapshot must be untouched before the interval elapses"
);
assert!(parser.refresh_local_ips_if_due(Duration::ZERO));
assert!(!parser.local_ips.contains(&bogus));
}
#[test]
fn test_empty_packet() {
let parser = create_parser_with_linktype(1);
let empty = vec![];
assert!(parser.parse_packet(&empty).is_none());
}
#[test]
fn test_ipv6_extension_header_overflow_does_not_panic() {
let parser = create_parser_with_linktype(1);
let mut packet = vec![
0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff, 0x86, 0xdd,
];
packet.extend_from_slice(&[
0x60, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x02,
]);
packet.extend_from_slice(&[0x3b , 0xff]);
let _ = parser.parse_packet(&packet);
}
#[test]
fn test_ipv4_with_options() {
let parser = create_parser_with_linktype(1);
let mut packet = vec![
0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff, 0x08, 0x00,
0x46, 0x00, 0x00, 0x2c, 0x00, 0x01, 0x00, 0x00, 0x40, 0x06, 0x00, 0x00, 192, 168, 1, 100, 93, 184, 216,
34, 0x01, 0x01, 0x00, 0x00,
];
packet.extend_from_slice(&[
0x04, 0xd2, 0x00, 0x50, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x50, 0x02,
0x20, 0x00, 0x00, 0x00, 0x00, 0x00,
]);
let parsed = parser.parse_packet(&packet);
assert!(parsed.is_some(), "Should handle IPv4 with options");
}
#[test]
fn test_packet_length_calculation_ipv4() {
let parser = create_parser_with_linktype(1);
let packet = ethernet_ipv4_tcp_syn();
let parsed = parser.parse_packet(&packet).unwrap();
assert_eq!(parsed.packet_len, 54);
}
#[test]
fn test_packet_length_calculation_ipv6() {
let parser = create_parser_with_linktype(1);
let packet = ethernet_ipv6_tcp();
let parsed = parser.parse_packet(&packet).unwrap();
assert_eq!(parsed.packet_len, 74);
}
#[test]
fn test_ethernet_padding_is_not_counted_as_tcp_payload() {
let parser = create_parser_with_linktype(1);
let mut packet = ethernet_ipv4_tcp_syn();
assert_eq!(packet.len(), 54);
packet.extend_from_slice(&[0x00; 6]);
let parsed = parser.parse_packet(&packet).unwrap();
assert_eq!(parsed.tcp_header.unwrap().payload_len, 0);
}
#[test]
fn test_trailing_bytes_are_not_read_as_tcp_payload() {
let parser = create_parser_with_linktype(1);
let mut packet = ethernet_ipv4_tcp_syn();
packet.extend_from_slice(b"SSH-2.0-OpenSSH_9.6\r\n");
let parsed = parser.parse_packet(&packet).unwrap();
assert_eq!(parsed.tcp_header.unwrap().payload_len, 0);
assert!(parsed.dpi_result.is_none());
}
#[test]
fn test_ipv6_padding_is_not_counted_as_tcp_payload() {
let parser = create_parser_with_linktype(1);
let mut packet = ethernet_ipv6_tcp();
packet.extend_from_slice(&[0x00; 6]);
let parsed = parser.parse_packet(&packet).unwrap();
assert_eq!(parsed.tcp_header.unwrap().payload_len, 0);
}
#[test]
fn test_real_payload_is_preserved() {
let parser = create_parser_with_linktype(1);
let mut packet = ethernet_ipv4_tcp_syn();
packet[16] = 0x00;
packet[17] = 0x2c;
packet.extend_from_slice(b"data");
let parsed = parser.parse_packet(&packet).unwrap();
assert_eq!(parsed.tcp_header.unwrap().payload_len, 4);
}
#[test]
fn test_truncated_capture_keeps_captured_payload() {
let parser = create_parser_with_linktype(1);
let mut packet = ethernet_ipv4_tcp_syn();
packet[16] = 0x05;
packet[17] = 0xdc;
packet.extend_from_slice(b"data");
let parsed = parser.parse_packet(&packet).unwrap();
assert_eq!(parsed.tcp_header.unwrap().payload_len, 4);
}
#[test]
fn test_sll_padding_is_not_counted_as_tcp_payload() {
let parser = create_parser_with_linktype(113); let mut packet = linux_sll_ipv4_tcp();
packet.extend_from_slice(&[0x00; 6]);
let parsed = parser.parse_packet(&packet).unwrap();
assert_eq!(parsed.tcp_header.unwrap().payload_len, 0);
}
#[test]
fn test_raw_ip_trailing_bytes_are_not_read_as_tcp_payload() {
let parser = create_parser_with_linktype(12); let mut packet = ethernet_ipv4_tcp_syn()[14..].to_vec();
packet.extend_from_slice(b"SSH-2.0-OpenSSH_9.6\r\n");
let parsed = parser.parse_packet(&packet).unwrap();
assert_eq!(parsed.tcp_header.unwrap().payload_len, 0);
assert!(parsed.dpi_result.is_none());
}
#[test]
fn test_raw_ipv6_padding_is_not_counted_as_tcp_payload() {
let parser = create_parser_with_linktype(12); let mut packet = ethernet_ipv6_tcp()[14..].to_vec();
packet.extend_from_slice(&[0x00; 6]);
let parsed = parser.parse_packet(&packet).unwrap();
assert_eq!(parsed.tcp_header.unwrap().payload_len, 0);
}
#[test]
fn test_zero_total_length_keeps_full_payload() {
let parser = create_parser_with_linktype(1);
let mut packet = ethernet_ipv4_tcp_syn();
packet[16] = 0x00;
packet[17] = 0x00;
packet.extend_from_slice(b"data");
let parsed = parser.parse_packet(&packet).unwrap();
assert_eq!(parsed.tcp_header.unwrap().payload_len, 4);
}
}