1use crate::network::dpi::DpiResult;
3use crate::network::link_layer;
4#[cfg(target_os = "macos")]
5use crate::network::link_layer::ethernet;
6#[cfg(target_os = "macos")]
7use crate::network::link_layer::pktap;
8use crate::network::local_addresses::collect_local_ips;
9use crate::network::oui::OuiLookup;
10use crate::network::protocol;
11use crate::network::protocol::TransportParams;
12use crate::network::types::*;
13use std::net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr};
14use std::time::{Duration, Instant};
15
16const AMBIGUOUS_ENDPOINT_REFRESH_INTERVAL: Duration = Duration::from_secs(1);
17const AMBIGUOUS_ENDPOINT_REFRESH_MAX_INTERVAL: Duration = Duration::from_secs(60);
18
19pub use crate::network::protocol::tcp::{TcpFlags, TcpHeaderInfo};
21
22#[derive(Debug)]
24pub struct ParsedPacket {
25 pub protocol: Protocol,
26 pub local_addr: SocketAddr,
27 pub remote_addr: SocketAddr,
28 pub tcp_header: Option<TcpHeaderInfo>, pub protocol_state: ProtocolState,
30 pub is_outgoing: bool,
31 pub packet_len: usize,
32 pub dpi_result: Option<DpiResult>, pub process_name: Option<String>, pub process_id: Option<u32>, }
36
37impl ParsedPacket {
38 #[inline]
42 pub fn connection_key(&self) -> ConnectionKey {
43 ConnectionKey::new(self.protocol, self.local_addr, self.remote_addr)
44 }
45}
46
47#[derive(Clone)]
65pub struct ParserConfig {
66 pub enable_dpi: bool,
67 pub dpi_packet_limit: usize,
70}
71
72impl Default for ParserConfig {
73 fn default() -> Self {
74 let config = Self {
75 enable_dpi: true,
76 dpi_packet_limit: 10, };
78
79 log::trace!(
81 "ParserConfig: DPI {} (limit: {} packets per connection)",
82 if config.enable_dpi {
83 "enabled"
84 } else {
85 "disabled"
86 },
87 config.dpi_packet_limit
88 );
89
90 if config.enable_dpi {
92 log::trace!(" - Packet 0: DPI = {}", config.should_perform_dpi(0));
93 log::trace!(
94 " - Packet {}: DPI = {}",
95 config.dpi_packet_limit - 1,
96 config.should_perform_dpi(config.dpi_packet_limit - 1)
97 );
98 log::trace!(
99 " - Packet {}: DPI = {}",
100 config.dpi_packet_limit,
101 config.should_perform_dpi(config.dpi_packet_limit)
102 );
103 }
104
105 config
106 }
107}
108
109impl ParserConfig {
110 pub fn should_perform_dpi(&self, packet_count: usize) -> bool {
113 let should_dpi = self.enable_dpi && packet_count < self.dpi_packet_limit;
114 if !should_dpi && self.enable_dpi {
115 log::trace!(
116 "DPI skipped: packet {} exceeds limit {}",
117 packet_count,
118 self.dpi_packet_limit
119 );
120 }
121 should_dpi
122 }
123}
124
125pub struct PacketParser {
127 local_ips: std::collections::HashSet<IpAddr>,
128 last_local_ip_refresh: Instant,
129 last_ambiguous_endpoint_refresh: Option<Instant>,
130 unchanged_ambiguous_refreshes: u32,
131 config: ParserConfig,
132 linktype: Option<i32>, oui_lookup: Option<OuiLookup>,
134}
135
136impl Default for PacketParser {
137 fn default() -> Self {
138 Self::new()
139 }
140}
141
142impl PacketParser {
143 pub fn new() -> Self {
146 Self {
147 local_ips: collect_local_ips(),
148 last_local_ip_refresh: Instant::now(),
149 last_ambiguous_endpoint_refresh: None,
150 unchanged_ambiguous_refreshes: 0,
151 config: ParserConfig::default(),
152 linktype: None,
153 oui_lookup: None,
154 }
155 }
156
157 pub fn with_config(config: ParserConfig) -> Self {
158 Self {
159 local_ips: collect_local_ips(),
160 last_local_ip_refresh: Instant::now(),
161 last_ambiguous_endpoint_refresh: None,
162 unchanged_ambiguous_refreshes: 0,
163 config,
164 linktype: None,
165 oui_lookup: None,
166 }
167 }
168
169 pub fn with_oui_lookup(mut self, oui_lookup: OuiLookup) -> Self {
171 self.oui_lookup = Some(oui_lookup);
172 self
173 }
174
175 pub fn with_linktype(mut self, linktype: i32) -> Self {
177 self.linktype = Some(linktype);
178
179 let link_type = link_layer::LinkLayerType::from_dlt(linktype);
181 if link_type.is_tunnel() {
182 log::debug!(
183 "Parser configured for tunnel interface: linktype {} ({:?})",
184 linktype,
185 link_type
186 );
187
188 log::trace!("TUN/TAP parsing available via link_layer::tun_tap module");
190 log::trace!(" - TUN interfaces (Layer 3): tun*, utun*");
191 log::trace!(" - TAP interfaces (Layer 2): tap*");
192 } else {
193 log::trace!(
194 "Parser configured with linktype {} ({:?})",
195 linktype,
196 link_type
197 );
198 }
199
200 self
201 }
202
203 pub fn refresh_local_ips(&mut self) -> bool {
210 self.refresh_local_ips_with(collect_local_ips)
211 }
212
213 pub fn refresh_local_ips_if_due(&mut self, interval: Duration) -> bool {
215 if self.last_local_ip_refresh.elapsed() < interval {
216 return false;
217 }
218 self.refresh_local_ips()
219 }
220
221 pub fn parse_packet_with_refresh(&mut self, data: &[u8]) -> Option<ParsedPacket> {
229 self.parse_packet_with_local_ip_collector(data, collect_local_ips)
230 }
231
232 pub fn parse_packet(&self, data: &[u8]) -> Option<ParsedPacket> {
234 if let Some(linktype) = self.linktype {
235 let link_type = link_layer::LinkLayerType::from_dlt(linktype);
237 log::trace!(
238 "Parsing packet with linktype {} ({:?})",
239 linktype,
240 link_type
241 );
242
243 match linktype {
244 #[cfg(target_os = "macos")]
246 149 | 258 if pktap::is_pktap_linktype(linktype) => {
247 log::debug!("Parsing as PKTAP (linktype {})", linktype);
248 return self.parse_pktap_packet(data);
249 }
250 113 => {
252 log::debug!("Parsing as Linux SLL (linktype 113)");
253 return link_layer::linux_sll::parse_sll(data, self, None, None);
254 }
255 276 => {
257 log::debug!("Parsing as Linux SLL2 (linktype 276)");
258 return link_layer::linux_sll::parse_sll2(data, self, None, None);
259 }
260 0
262 | 1
263 | 12
264 | 101
265 | link_layer::dlt::LINKTYPE_IPV4
266 | link_layer::dlt::LINKTYPE_IPV6 => {
267 log::debug!("Parsing TUN/TAP packet (linktype {})", linktype);
268 return link_layer::tun_tap::parse_by_dlt(data, linktype, self, None, None);
269 }
270 _ => {
271 log::debug!("Unknown linktype {}, trying Ethernet", linktype);
272 }
273 }
274 }
275
276 log::debug!("Using fallback Ethernet parsing");
278 link_layer::ethernet::parse(data, self, None, None)
279 }
280
281 fn parse_packet_with_local_ip_collector<F>(
282 &mut self,
283 data: &[u8],
284 collector: F,
285 ) -> Option<ParsedPacket>
286 where
287 F: FnOnce() -> std::collections::HashSet<IpAddr>,
288 {
289 let parsed = self.parse_packet(data)?;
290 let local_ip = parsed.local_addr.ip();
291 let remote_ip = parsed.remote_addr.ip();
292
293 if self.local_ips.contains(&local_ip)
294 || self.local_ips.contains(&remote_ip)
295 || !is_unicast_endpoint(local_ip)
296 || !is_unicast_endpoint(remote_ip)
297 {
298 return Some(parsed);
299 }
300
301 let now = Instant::now();
302 if self
303 .last_ambiguous_endpoint_refresh
304 .is_some_and(|last| now.duration_since(last) < self.ambiguous_refresh_interval())
305 {
306 return Some(parsed);
307 }
308 self.last_ambiguous_endpoint_refresh = Some(now);
309
310 if self.refresh_local_ips_with(collector) {
311 self.parse_packet(data)
312 } else {
313 self.unchanged_ambiguous_refreshes =
314 self.unchanged_ambiguous_refreshes.saturating_add(1);
315 Some(parsed)
316 }
317 }
318
319 fn ambiguous_refresh_interval(&self) -> Duration {
327 let factor = 1u32 << self.unchanged_ambiguous_refreshes.min(6);
328 AMBIGUOUS_ENDPOINT_REFRESH_INTERVAL
329 .saturating_mul(factor)
330 .min(AMBIGUOUS_ENDPOINT_REFRESH_MAX_INTERVAL)
331 }
332
333 fn refresh_local_ips_with<F>(&mut self, collector: F) -> bool
334 where
335 F: FnOnce() -> std::collections::HashSet<IpAddr>,
336 {
337 let refreshed = collector();
338 self.last_local_ip_refresh = Instant::now();
339 if refreshed == self.local_ips {
340 return false;
341 }
342
343 log::debug!(
344 "Local address set changed: {} -> {} address(es)",
345 self.local_ips.len(),
346 refreshed.len()
347 );
348 self.local_ips = refreshed;
349 self.unchanged_ambiguous_refreshes = 0;
350 true
351 }
352
353 #[cfg(target_os = "macos")]
354 fn parse_pktap_packet(&self, data: &[u8]) -> Option<ParsedPacket> {
355 let (pktap_header, payload) = pktap::parse_pktap_packet(data)?;
356 let (process_name, process_id) = pktap_header.get_process_info();
357
358 log::debug!(
359 "PKTAP packet: interface={}, process={:?}, pid={:?}, payload_len={}",
360 pktap_header.get_interface(),
361 process_name,
362 process_id,
363 payload.len()
364 );
365
366 match pktap_header.inner_dlt() {
368 1 => {
369 ethernet::parse(payload, self, process_name, process_id)
375 }
376 12 => {
377 if payload.is_empty() {
379 return None;
380 }
381 let version = payload[0] >> 4;
382 match version {
383 4 => self.parse_raw_ipv4_packet(payload, process_name, process_id),
384 6 => self.parse_raw_ipv6_packet(payload, process_name, process_id),
385 _ => None,
386 }
387 }
388 _ => {
389 log::debug!("Unsupported PKTAP inner DLT: {}", pktap_header.inner_dlt());
390 None
391 }
392 }
393 }
394
395 pub fn parse_ipv4_packet_inner(
398 &self,
399 data: &[u8],
400 offset: usize,
401 process_name: Option<String>,
402 process_id: Option<u32>,
403 ) -> Option<ParsedPacket> {
404 let ip_data = &data[offset..];
405 if ip_data.len() < 20 {
406 return None;
407 }
408
409 let version = ip_data[0] >> 4;
410 if version != 4 {
411 return None;
412 }
413
414 let ip_total_length = u16::from_be_bytes([ip_data[2], ip_data[3]]) as usize;
416 let actual_packet_len = offset + ip_total_length;
418
419 let fragment_offset = u16::from_be_bytes([ip_data[6], ip_data[7]]) & 0x1FFF;
423 if fragment_offset != 0 {
424 return None;
425 }
426
427 let protocol_num = ip_data[9];
428 let src_ip = IpAddr::V4(Ipv4Addr::new(
429 ip_data[12],
430 ip_data[13],
431 ip_data[14],
432 ip_data[15],
433 ));
434 let dst_ip = IpAddr::V4(Ipv4Addr::new(
435 ip_data[16],
436 ip_data[17],
437 ip_data[18],
438 ip_data[19],
439 ));
440
441 let ihl = ip_data[0] & 0x0F;
442 if ihl < 5 {
445 return None;
446 }
447 let ip_header_len = (ihl as usize) * 4;
448
449 if ip_data.len() < ip_header_len {
450 return None;
451 }
452
453 let transport_data = &ip_data[ip_header_len..];
454
455 let transport_data = match ip_total_length.checked_sub(ip_header_len) {
462 Some(payload_len) => &transport_data[..payload_len.min(transport_data.len())],
463 None => transport_data,
464 };
465
466 let params =
467 TransportParams::new(src_ip, dst_ip, actual_packet_len, process_name, process_id);
468
469 match protocol_num {
470 1 => protocol::icmp::parse(transport_data, params, &self.local_ips),
471 2 => protocol::igmp::parse(transport_data, params, &self.local_ips),
472 6 => protocol::tcp::parse(transport_data, params, &self.config, &self.local_ips),
473 17 => protocol::udp::parse(transport_data, params, &self.config, &self.local_ips),
474 _ => None,
475 }
476 }
477
478 pub fn parse_ipv6_packet_inner(
481 &self,
482 data: &[u8],
483 offset: usize,
484 process_name: Option<String>,
485 process_id: Option<u32>,
486 ) -> Option<ParsedPacket> {
487 let ip_data = &data[offset..];
488 if ip_data.len() < 40 {
489 return None;
490 }
491
492 let version = ip_data[0] >> 4;
493 if version != 6 {
494 return None;
495 }
496
497 let ipv6_payload_length = u16::from_be_bytes([ip_data[4], ip_data[5]]) as usize;
499 let actual_packet_len = offset + 40 + ipv6_payload_length;
501
502 let next_header = ip_data[6];
503
504 let src_ip = IpAddr::V6(Ipv6Addr::new(
506 u16::from_be_bytes([ip_data[8], ip_data[9]]),
507 u16::from_be_bytes([ip_data[10], ip_data[11]]),
508 u16::from_be_bytes([ip_data[12], ip_data[13]]),
509 u16::from_be_bytes([ip_data[14], ip_data[15]]),
510 u16::from_be_bytes([ip_data[16], ip_data[17]]),
511 u16::from_be_bytes([ip_data[18], ip_data[19]]),
512 u16::from_be_bytes([ip_data[20], ip_data[21]]),
513 u16::from_be_bytes([ip_data[22], ip_data[23]]),
514 ));
515
516 let dst_ip = IpAddr::V6(Ipv6Addr::new(
517 u16::from_be_bytes([ip_data[24], ip_data[25]]),
518 u16::from_be_bytes([ip_data[26], ip_data[27]]),
519 u16::from_be_bytes([ip_data[28], ip_data[29]]),
520 u16::from_be_bytes([ip_data[30], ip_data[31]]),
521 u16::from_be_bytes([ip_data[32], ip_data[33]]),
522 u16::from_be_bytes([ip_data[34], ip_data[35]]),
523 u16::from_be_bytes([ip_data[36], ip_data[37]]),
524 u16::from_be_bytes([ip_data[38], ip_data[39]]),
525 ));
526
527 let transport_data = &ip_data[40..];
528
529 let transport_data = if ipv6_payload_length == 0 {
535 transport_data
536 } else {
537 &transport_data[..ipv6_payload_length.min(transport_data.len())]
538 };
539
540 let (final_next_header, transport_offset) =
543 self.parse_ipv6_extension_headers(next_header, transport_data)?;
544 let final_transport_data = &transport_data[transport_offset.min(transport_data.len())..];
548
549 let params =
550 TransportParams::new(src_ip, dst_ip, actual_packet_len, process_name, process_id);
551
552 match final_next_header {
553 58 => protocol::icmp::parse_v6(final_transport_data, params, &self.local_ips),
554 6 => protocol::tcp::parse(final_transport_data, params, &self.config, &self.local_ips),
555 17 => protocol::udp::parse(final_transport_data, params, &self.config, &self.local_ips),
556 _ => None,
557 }
558 }
559
560 pub fn parse_arp_packet_inner(
563 &self,
564 data: &[u8],
565 offset: usize,
566 process_name: Option<String>,
567 process_id: Option<u32>,
568 ) -> Option<ParsedPacket> {
569 self.parse_arp_packet_with_offset(data, offset, process_name, process_id)
570 }
571
572 pub fn parse_arp_packet_with_offset(
573 &self,
574 data: &[u8],
575 header_len: usize,
576 process_name: Option<String>,
577 process_id: Option<u32>,
578 ) -> Option<ParsedPacket> {
579 let arp_data = &data[header_len..];
580 if arp_data.len() < 28 {
581 return None;
582 }
583
584 let hardware_type = u16::from_be_bytes([arp_data[0], arp_data[1]]);
585 let protocol_type = u16::from_be_bytes([arp_data[2], arp_data[3]]);
586 let opcode = u16::from_be_bytes([arp_data[6], arp_data[7]]);
587
588 if hardware_type != 1 || protocol_type != 0x0800 {
589 return None;
590 }
591
592 let sender_mac = format!(
594 "{:02x}:{:02x}:{:02x}:{:02x}:{:02x}:{:02x}",
595 arp_data[8], arp_data[9], arp_data[10], arp_data[11], arp_data[12], arp_data[13]
596 );
597 let target_mac = format!(
598 "{:02x}:{:02x}:{:02x}:{:02x}:{:02x}:{:02x}",
599 arp_data[18], arp_data[19], arp_data[20], arp_data[21], arp_data[22], arp_data[23]
600 );
601
602 let sender_ip = IpAddr::from([arp_data[14], arp_data[15], arp_data[16], arp_data[17]]);
603 let target_ip = IpAddr::from([arp_data[24], arp_data[25], arp_data[26], arp_data[27]]);
604
605 let operation = match opcode {
606 1 => ArpOperation::Request,
607 2 => ArpOperation::Reply,
608 _ => return None,
609 };
610
611 let sender_vendor = self
612 .oui_lookup
613 .as_ref()
614 .and_then(|oui| oui.lookup(&sender_mac).map(String::from));
615 let target_vendor = self
616 .oui_lookup
617 .as_ref()
618 .and_then(|oui| oui.lookup(&target_mac).map(String::from));
619
620 let arp_info = ArpInfo {
621 operation,
622 sender_mac,
623 sender_ip,
624 target_mac,
625 target_ip,
626 sender_vendor,
627 target_vendor,
628 };
629
630 let is_outgoing = self.local_ips.contains(&sender_ip);
631 let (local_addr, remote_addr) = if is_outgoing {
632 (SocketAddr::new(sender_ip, 0), SocketAddr::new(target_ip, 0))
633 } else {
634 (SocketAddr::new(target_ip, 0), SocketAddr::new(sender_ip, 0))
635 };
636
637 Some(ParsedPacket {
638 protocol: Protocol::Arp,
639 local_addr,
640 remote_addr,
641 tcp_header: None,
642 protocol_state: ProtocolState::Arp(arp_info),
643 is_outgoing,
644 packet_len: data.len(),
645 dpi_result: None,
646 process_name,
647 process_id,
648 })
649 }
650
651 pub fn parse_raw_ipv4_packet(
654 &self,
655 data: &[u8],
656 process_name: Option<String>,
657 process_id: Option<u32>,
658 ) -> Option<ParsedPacket> {
659 if data.len() < 20 {
660 return None;
661 }
662
663 let version = data[0] >> 4;
664 if version != 4 {
665 return None;
666 }
667
668 let actual_packet_len = u16::from_be_bytes([data[2], data[3]]) as usize;
671
672 let fragment_offset = u16::from_be_bytes([data[6], data[7]]) & 0x1FFF;
676 if fragment_offset != 0 {
677 return None;
678 }
679
680 let protocol_num = data[9];
681 let src_ip = IpAddr::V4(Ipv4Addr::new(data[12], data[13], data[14], data[15]));
682 let dst_ip = IpAddr::V4(Ipv4Addr::new(data[16], data[17], data[18], data[19]));
683
684 let ihl = data[0] & 0x0F;
685 if ihl < 5 {
688 return None;
689 }
690 let ip_header_len = (ihl as usize) * 4;
691
692 if data.len() < ip_header_len {
693 return None;
694 }
695
696 let transport_data = &data[ip_header_len..];
697
698 let transport_data = match actual_packet_len.checked_sub(ip_header_len) {
704 Some(payload_len) => &transport_data[..payload_len.min(transport_data.len())],
705 None => transport_data,
706 };
707
708 let params =
709 TransportParams::new(src_ip, dst_ip, actual_packet_len, process_name, process_id);
710
711 match protocol_num {
712 1 => protocol::icmp::parse(transport_data, params, &self.local_ips),
713 2 => protocol::igmp::parse(transport_data, params, &self.local_ips),
714 6 => protocol::tcp::parse(transport_data, params, &self.config, &self.local_ips),
715 17 => protocol::udp::parse(transport_data, params, &self.config, &self.local_ips),
716 _ => None,
717 }
718 }
719
720 pub fn parse_raw_ipv6_packet(
723 &self,
724 data: &[u8],
725 process_name: Option<String>,
726 process_id: Option<u32>,
727 ) -> Option<ParsedPacket> {
728 if data.len() < 40 {
729 return None;
730 }
731
732 let version = data[0] >> 4;
733 if version != 6 {
734 return None;
735 }
736
737 let ipv6_payload_length = u16::from_be_bytes([data[4], data[5]]) as usize;
740 let actual_packet_len = 40 + ipv6_payload_length;
741
742 let next_header = data[6];
743
744 let src_ip = IpAddr::V6(Ipv6Addr::new(
746 u16::from_be_bytes([data[8], data[9]]),
747 u16::from_be_bytes([data[10], data[11]]),
748 u16::from_be_bytes([data[12], data[13]]),
749 u16::from_be_bytes([data[14], data[15]]),
750 u16::from_be_bytes([data[16], data[17]]),
751 u16::from_be_bytes([data[18], data[19]]),
752 u16::from_be_bytes([data[20], data[21]]),
753 u16::from_be_bytes([data[22], data[23]]),
754 ));
755
756 let dst_ip = IpAddr::V6(Ipv6Addr::new(
757 u16::from_be_bytes([data[24], data[25]]),
758 u16::from_be_bytes([data[26], data[27]]),
759 u16::from_be_bytes([data[28], data[29]]),
760 u16::from_be_bytes([data[30], data[31]]),
761 u16::from_be_bytes([data[32], data[33]]),
762 u16::from_be_bytes([data[34], data[35]]),
763 u16::from_be_bytes([data[36], data[37]]),
764 u16::from_be_bytes([data[38], data[39]]),
765 ));
766
767 let transport_data = &data[40..];
768
769 let transport_data = if ipv6_payload_length == 0 {
774 transport_data
775 } else {
776 &transport_data[..ipv6_payload_length.min(transport_data.len())]
777 };
778
779 let (final_next_header, transport_offset) =
782 self.parse_ipv6_extension_headers(next_header, transport_data)?;
783 let final_transport_data = &transport_data[transport_offset.min(transport_data.len())..];
787
788 let params =
789 TransportParams::new(src_ip, dst_ip, actual_packet_len, process_name, process_id);
790
791 match final_next_header {
792 58 => protocol::icmp::parse_v6(final_transport_data, params, &self.local_ips),
793 6 => protocol::tcp::parse(final_transport_data, params, &self.config, &self.local_ips),
794 17 => protocol::udp::parse(final_transport_data, params, &self.config, &self.local_ips),
795 _ => None,
796 }
797 }
798
799 fn parse_ipv6_extension_headers(
804 &self,
805 mut next_header: u8,
806 data: &[u8],
807 ) -> Option<(u8, usize)> {
808 let mut offset = 0;
809
810 const HOP_BY_HOP: u8 = 0;
811 const ROUTING: u8 = 43;
812 const FRAGMENT: u8 = 44;
813 const ENCAPSULATING_SECURITY: u8 = 50;
814 const AUTHENTICATION: u8 = 51;
815 const DESTINATION_OPTIONS: u8 = 60;
816
817 loop {
818 match next_header {
819 HOP_BY_HOP | ROUTING | DESTINATION_OPTIONS => {
820 if data.len() < offset + 2 {
821 return Some((next_header, offset));
822 }
823 next_header = data[offset];
824 let header_len = ((data[offset + 1] as usize) + 1) * 8;
825 offset += header_len;
826 }
827 FRAGMENT => {
828 if data.len() < offset + 8 {
829 return Some((next_header, offset));
830 }
831 let fragment_offset =
834 u16::from_be_bytes([data[offset + 2], data[offset + 3]]) >> 3;
835 if fragment_offset != 0 {
836 return None;
837 }
838 next_header = data[offset];
839 offset += 8;
840 }
841 AUTHENTICATION => {
842 if data.len() < offset + 2 {
843 return Some((next_header, offset));
844 }
845 next_header = data[offset];
846 let header_len = ((data[offset + 1] as usize) + 2) * 4;
847 offset += header_len;
848 }
849 ENCAPSULATING_SECURITY => {
850 return Some((next_header, offset));
851 }
852 _ => {
853 return Some((next_header, offset));
854 }
855 }
856
857 if offset >= data.len() {
858 return Some((next_header, offset));
859 }
860 }
861 }
862}
863
864fn is_unicast_endpoint(ip: IpAddr) -> bool {
865 match ip {
866 IpAddr::V4(ip) => !ip.is_unspecified() && !ip.is_multicast() && ip != Ipv4Addr::BROADCAST,
867 IpAddr::V6(ip) => !ip.is_unspecified() && !ip.is_multicast(),
868 }
869}
870
871#[cfg(test)]
872mod tests {
873 use super::*;
874 use std::net::IpAddr;
875
876 fn create_parser_with_linktype(linktype: i32) -> PacketParser {
879 let mut parser = PacketParser::with_config(ParserConfig::default()).with_linktype(linktype);
880 parser
882 .local_ips
883 .insert(IpAddr::V4(Ipv4Addr::new(192, 168, 1, 100)));
884 parser
885 }
886
887 fn ethernet_ipv4_tcp_syn() -> Vec<u8> {
889 vec![
890 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff, 0x08, 0x00,
892 0x45, 0x00, 0x00, 0x28, 0x00, 0x01, 0x00, 0x00, 0x40, 0x06, 0x00, 0x00, 192, 168, 1,
894 100, 93, 184, 216, 34, 0x04, 0xd2, 0x00, 0x50, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x50, 0x02,
896 0x20, 0x00, 0x00, 0x00, 0x00, 0x00,
897 ]
898 }
899
900 fn ethernet_ipv4_udp_dns() -> Vec<u8> {
901 vec![
902 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff, 0x08, 0x00,
904 0x45, 0x00, 0x00, 0x20, 0x00, 0x01, 0x00, 0x00, 0x40, 0x11, 0x00, 0x00, 192, 168, 1,
906 100, 8, 8, 8, 8, 0x04, 0xd2, 0x00, 0x35, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04,
908 ]
909 }
910
911 fn ethernet_ipv6_tcp() -> Vec<u8> {
912 vec![
913 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff, 0x86, 0xdd,
915 0x60, 0x00, 0x00, 0x00, 0x00, 0x14, 0x06, 0x40, 0x20, 0x01, 0x0d, 0xb8, 0x00, 0x00,
917 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x20, 0x01, 0x0d, 0xb8,
918 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
919 0x04, 0xd2, 0x00, 0x50, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x50, 0x02,
921 0x20, 0x00, 0x00, 0x00, 0x00, 0x00,
922 ]
923 }
924
925 fn linux_sll_ipv4_tcp() -> Vec<u8> {
926 vec![
927 0x00, 0x00, 0x00, 0x01, 0x00, 0x06, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff, 0x00, 0x00,
929 0x08, 0x00, 0x45, 0x00, 0x00, 0x28, 0x00, 0x01, 0x00, 0x00, 0x40, 0x06, 0x00, 0x00, 192, 168, 1,
931 100, 93, 184, 216, 34, 0x04, 0xd2, 0x00, 0x50, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x50, 0x02,
933 0x20, 0x00, 0x00, 0x00, 0x00, 0x00,
934 ]
935 }
936
937 fn linux_sll2_ipv4_udp() -> Vec<u8> {
938 vec![
939 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x06, 0xaa, 0xbb,
941 0xcc, 0xdd, 0xee, 0xff, 0x00, 0x00, 0x45, 0x00, 0x00, 0x20, 0x00, 0x01, 0x00, 0x00, 0x40, 0x11, 0x00, 0x00, 192, 168, 1,
943 100, 8, 8, 8, 8, 0x04, 0xd2, 0x00, 0x35, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04,
945 ]
946 }
947
948 #[test]
951 fn test_ethernet_ipv4_tcp_parsing() {
952 let parser = create_parser_with_linktype(1); let packet = ethernet_ipv4_tcp_syn();
954
955 let parsed = parser.parse_packet(&packet);
956 assert!(
957 parsed.is_some(),
958 "Should parse valid Ethernet IPv4 TCP packet"
959 );
960
961 let p = parsed.unwrap();
962 assert_eq!(p.protocol, Protocol::Tcp);
963 assert_eq!(p.local_addr.port(), 1234, "Local port should be 1234");
966 assert_eq!(p.remote_addr.port(), 80, "Remote port should be 80");
967 assert!(p.tcp_header.is_some());
968 assert!(p.tcp_header.unwrap().flags.syn, "SYN flag should be set");
969 }
970
971 #[test]
972 fn test_ethernet_ipv4_udp_parsing() {
973 let parser = create_parser_with_linktype(1);
974 let packet = ethernet_ipv4_udp_dns();
975
976 let parsed = parser.parse_packet(&packet);
977 assert!(parsed.is_some());
978
979 let p = parsed.unwrap();
980 assert_eq!(p.protocol, Protocol::Udp);
981 assert_eq!(p.local_addr.port(), 1234);
983 assert_eq!(p.remote_addr.port(), 53, "Should detect DNS port");
984 }
985
986 #[test]
987 fn test_ethernet_ipv6_tcp_parsing() {
988 let parser = create_parser_with_linktype(1);
989 let packet = ethernet_ipv6_tcp();
990
991 let parsed = parser.parse_packet(&packet);
992 assert!(parsed.is_some(), "Should parse IPv6 packets");
993
994 let p = parsed.unwrap();
995 assert_eq!(p.protocol, Protocol::Tcp);
996 assert!(matches!(p.local_addr.ip(), IpAddr::V6(_)), "Should be IPv6");
997 }
998
999 #[test]
1000 fn test_truncated_ethernet_packet() {
1001 let parser = create_parser_with_linktype(1);
1002 let truncated = vec![0x00, 0x11, 0x22]; let parsed = parser.parse_packet(&truncated);
1005 assert!(parsed.is_none(), "Should reject truncated packets");
1006 }
1007
1008 #[test]
1009 fn test_unknown_ethertype() {
1010 let parser = create_parser_with_linktype(1);
1011 let packet = vec![
1012 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff, 0xff,
1013 0xff, ];
1015
1016 let parsed = parser.parse_packet(&packet);
1017 assert!(parsed.is_none(), "Should reject unknown EtherType");
1018 }
1019
1020 #[test]
1023 fn test_linux_sll_ipv4_tcp_parsing() {
1024 let parser = create_parser_with_linktype(113); let packet = linux_sll_ipv4_tcp();
1026
1027 let parsed = parser.parse_packet(&packet);
1028 assert!(parsed.is_some(), "Should parse Linux SLL packets");
1029
1030 let p = parsed.unwrap();
1031 assert_eq!(p.protocol, Protocol::Tcp);
1032 assert_eq!(p.local_addr.port(), 1234);
1033 assert_eq!(p.remote_addr.port(), 80);
1034 }
1035
1036 #[test]
1037 fn test_linux_sll_truncated() {
1038 let parser = create_parser_with_linktype(113);
1039 let truncated = vec![0x00, 0x00, 0x00]; let parsed = parser.parse_packet(&truncated);
1042 assert!(parsed.is_none(), "Should reject truncated SLL packets");
1043 }
1044
1045 #[test]
1048 fn test_linux_sll2_ipv4_udp_parsing() {
1049 let parser = create_parser_with_linktype(276); let packet = linux_sll2_ipv4_udp();
1051
1052 let parsed = parser.parse_packet(&packet);
1053 assert!(parsed.is_some(), "Should parse Linux SLL2 packets");
1054
1055 let p = parsed.unwrap();
1056 assert_eq!(p.protocol, Protocol::Udp);
1057 assert_eq!(p.local_addr.port(), 1234);
1058 assert_eq!(p.remote_addr.port(), 53);
1059 }
1060
1061 #[test]
1062 fn test_linux_sll2_truncated() {
1063 let parser = create_parser_with_linktype(276);
1064 let truncated = vec![0x08, 0x00]; let parsed = parser.parse_packet(&truncated);
1067 assert!(parsed.is_none(), "Should reject truncated SLL2 packets");
1068 }
1069
1070 #[test]
1073 fn test_tcp_flags_parsing() {
1074 use crate::network::protocol::tcp::parse_tcp_flags;
1075
1076 let flags = parse_tcp_flags(0x02); assert!(flags.syn);
1078 assert!(!flags.ack);
1079 assert!(!flags.fin);
1080
1081 let flags = parse_tcp_flags(0x12); assert!(flags.syn);
1083 assert!(flags.ack);
1084
1085 let flags = parse_tcp_flags(0x11); assert!(flags.fin);
1087 assert!(flags.ack);
1088 }
1089
1090 #[test]
1093 fn test_parser_default_config() {
1094 let config = ParserConfig::default();
1095 assert!(config.enable_dpi, "DPI should be enabled by default");
1096 assert_eq!(config.dpi_packet_limit, 10);
1097 }
1098
1099 #[test]
1100 fn test_parser_with_linktype() {
1101 let parser = PacketParser::with_config(ParserConfig::default()).with_linktype(1);
1102 assert_eq!(parser.linktype, Some(1));
1103 }
1104
1105 #[test]
1108 fn test_local_ip_detection() {
1109 let parser = PacketParser::new();
1110 assert!(!parser.local_ips.is_empty(), "Should detect local IPs");
1112 }
1113
1114 #[test]
1115 fn ambiguous_ipv6_packet_refreshes_local_addresses_and_reorients_endpoints() {
1116 let mut parser = create_parser_with_linktype(1);
1117 parser.local_ips.clear();
1118 parser.local_ips.insert(IpAddr::V4(Ipv4Addr::LOCALHOST));
1119 parser.local_ips.insert(IpAddr::V6(Ipv6Addr::LOCALHOST));
1120 let packet = ethernet_ipv6_tcp();
1121
1122 let stale = parser.parse_packet(&packet).expect("packet should parse");
1123 assert!(!stale.is_outgoing);
1124 assert_eq!(stale.local_addr.port(), 80);
1125
1126 let new_local = IpAddr::V6("2001:db8::1".parse().expect("valid fixture address"));
1127 let corrected = parser
1128 .parse_packet_with_local_ip_collector(&packet, || {
1129 [
1130 IpAddr::V4(Ipv4Addr::LOCALHOST),
1131 IpAddr::V6(Ipv6Addr::LOCALHOST),
1132 new_local,
1133 ]
1134 .into_iter()
1135 .collect()
1136 })
1137 .expect("packet should be reparsed");
1138
1139 assert!(corrected.is_outgoing);
1140 assert_eq!(corrected.local_addr.ip(), new_local);
1141 assert_eq!(corrected.local_addr.port(), 1234);
1142 assert_eq!(corrected.remote_addr.port(), 80);
1143 }
1144
1145 #[test]
1146 fn refresh_replaces_addresses_that_are_no_longer_assigned() {
1147 let mut parser = create_parser_with_linktype(1);
1148 let old = IpAddr::V6("2001:db8::1".parse().expect("valid old address"));
1149 let new = IpAddr::V6("2001:db8::2".parse().expect("valid new address"));
1150 parser.local_ips = [old].into_iter().collect();
1151
1152 assert!(parser.refresh_local_ips_with(|| [new].into_iter().collect()));
1153 assert!(!parser.local_ips.contains(&old));
1154 assert!(parser.local_ips.contains(&new));
1155 }
1156
1157 #[test]
1158 fn ambiguous_refresh_is_rate_limited_between_packets() {
1159 use std::cell::Cell;
1160
1161 let mut parser = create_parser_with_linktype(1);
1162 parser.local_ips.clear();
1163 parser.local_ips.insert(IpAddr::V4(Ipv4Addr::LOCALHOST));
1164 let packet = ethernet_ipv6_tcp();
1165 let collector_calls = Cell::new(0u32);
1166 let unchanged_collector = || {
1167 collector_calls.set(collector_calls.get() + 1);
1168 [IpAddr::V4(Ipv4Addr::LOCALHOST)].into_iter().collect()
1169 };
1170
1171 parser
1172 .parse_packet_with_local_ip_collector(&packet, unchanged_collector)
1173 .expect("packet should parse");
1174 parser
1175 .parse_packet_with_local_ip_collector(&packet, unchanged_collector)
1176 .expect("packet should parse");
1177
1178 assert_eq!(
1179 collector_calls.get(),
1180 1,
1181 "second ambiguous packet within the refresh interval must not re-enumerate"
1182 );
1183 }
1184
1185 #[test]
1186 fn fruitless_ambiguous_refreshes_back_off_exponentially() {
1187 let mut parser = create_parser_with_linktype(1);
1188 assert_eq!(parser.ambiguous_refresh_interval(), Duration::from_secs(1));
1189
1190 parser.unchanged_ambiguous_refreshes = 3;
1191 assert_eq!(parser.ambiguous_refresh_interval(), Duration::from_secs(8));
1192
1193 parser.unchanged_ambiguous_refreshes = 100;
1194 assert_eq!(
1195 parser.ambiguous_refresh_interval(),
1196 AMBIGUOUS_ENDPOINT_REFRESH_MAX_INTERVAL
1197 );
1198
1199 let new = IpAddr::V6("2001:db8::99".parse().expect("valid address"));
1200 assert!(parser.refresh_local_ips_with(|| [new].into_iter().collect()));
1201 assert_eq!(
1202 parser.unchanged_ambiguous_refreshes, 0,
1203 "a refresh that observes a change must reset the backoff"
1204 );
1205 }
1206
1207 #[test]
1208 fn periodic_refresh_waits_for_interval() {
1209 let mut parser = create_parser_with_linktype(1);
1210 let bogus = IpAddr::V6("2001:db8::dead".parse().expect("valid address"));
1211 parser.local_ips = [bogus].into_iter().collect();
1212
1213 assert!(!parser.refresh_local_ips_if_due(Duration::from_secs(3600)));
1214 assert!(
1215 parser.local_ips.contains(&bogus),
1216 "snapshot must be untouched before the interval elapses"
1217 );
1218
1219 assert!(parser.refresh_local_ips_if_due(Duration::ZERO));
1220 assert!(!parser.local_ips.contains(&bogus));
1221 }
1222
1223 #[test]
1226 fn test_empty_packet() {
1227 let parser = create_parser_with_linktype(1);
1228 let empty = vec![];
1229 assert!(parser.parse_packet(&empty).is_none());
1230 }
1231
1232 #[test]
1233 fn test_ipv6_extension_header_overflow_does_not_panic() {
1234 let parser = create_parser_with_linktype(1);
1240 let mut packet = vec![
1241 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff, 0x86, 0xdd,
1243 ];
1244 packet.extend_from_slice(&[
1245 0x60, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1252 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1254 0x00, 0x02,
1255 ]);
1256 packet.extend_from_slice(&[0x3b , 0xff]);
1259
1260 let _ = parser.parse_packet(&packet);
1262 }
1263
1264 #[test]
1265 fn test_ipv4_with_options() {
1266 let parser = create_parser_with_linktype(1);
1267 let mut packet = vec![
1268 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff, 0x08, 0x00,
1270 0x46, 0x00, 0x00, 0x2c, 0x00, 0x01, 0x00, 0x00, 0x40, 0x06, 0x00, 0x00, 192, 168, 1, 100, 93, 184, 216,
1273 34, 0x01, 0x01, 0x00, 0x00,
1275 ];
1276 packet.extend_from_slice(&[
1278 0x04, 0xd2, 0x00, 0x50, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x50, 0x02,
1279 0x20, 0x00, 0x00, 0x00, 0x00, 0x00,
1280 ]);
1281
1282 let parsed = parser.parse_packet(&packet);
1283 assert!(parsed.is_some(), "Should handle IPv4 with options");
1284 }
1285
1286 #[test]
1287 fn test_packet_length_calculation_ipv4() {
1288 let parser = create_parser_with_linktype(1);
1289 let packet = ethernet_ipv4_tcp_syn();
1290
1291 let parsed = parser.parse_packet(&packet).unwrap();
1292 assert_eq!(parsed.packet_len, 54);
1294 }
1295
1296 #[test]
1297 fn test_packet_length_calculation_ipv6() {
1298 let parser = create_parser_with_linktype(1);
1299 let packet = ethernet_ipv6_tcp();
1300
1301 let parsed = parser.parse_packet(&packet).unwrap();
1302 assert_eq!(parsed.packet_len, 74);
1304 }
1305
1306 #[test]
1307 fn test_ethernet_padding_is_not_counted_as_tcp_payload() {
1308 let parser = create_parser_with_linktype(1);
1309 let mut packet = ethernet_ipv4_tcp_syn();
1313 assert_eq!(packet.len(), 54);
1314 packet.extend_from_slice(&[0x00; 6]);
1315
1316 let parsed = parser.parse_packet(&packet).unwrap();
1317 assert_eq!(parsed.tcp_header.unwrap().payload_len, 0);
1318 }
1319
1320 #[test]
1321 fn test_trailing_bytes_are_not_read_as_tcp_payload() {
1322 let parser = create_parser_with_linktype(1);
1323 let mut packet = ethernet_ipv4_tcp_syn();
1327 packet.extend_from_slice(b"SSH-2.0-OpenSSH_9.6\r\n");
1328
1329 let parsed = parser.parse_packet(&packet).unwrap();
1330 assert_eq!(parsed.tcp_header.unwrap().payload_len, 0);
1331 assert!(parsed.dpi_result.is_none());
1332 }
1333
1334 #[test]
1335 fn test_ipv6_padding_is_not_counted_as_tcp_payload() {
1336 let parser = create_parser_with_linktype(1);
1337 let mut packet = ethernet_ipv6_tcp();
1340 packet.extend_from_slice(&[0x00; 6]);
1341
1342 let parsed = parser.parse_packet(&packet).unwrap();
1343 assert_eq!(parsed.tcp_header.unwrap().payload_len, 0);
1344 }
1345
1346 #[test]
1347 fn test_real_payload_is_preserved() {
1348 let parser = create_parser_with_linktype(1);
1349 let mut packet = ethernet_ipv4_tcp_syn();
1351 packet[16] = 0x00;
1352 packet[17] = 0x2c;
1353 packet.extend_from_slice(b"data");
1354
1355 let parsed = parser.parse_packet(&packet).unwrap();
1356 assert_eq!(parsed.tcp_header.unwrap().payload_len, 4);
1357 }
1358
1359 #[test]
1360 fn test_truncated_capture_keeps_captured_payload() {
1361 let parser = create_parser_with_linktype(1);
1362 let mut packet = ethernet_ipv4_tcp_syn();
1365 packet[16] = 0x05;
1366 packet[17] = 0xdc;
1367 packet.extend_from_slice(b"data");
1368
1369 let parsed = parser.parse_packet(&packet).unwrap();
1370 assert_eq!(parsed.tcp_header.unwrap().payload_len, 4);
1371 }
1372
1373 #[test]
1374 fn test_sll_padding_is_not_counted_as_tcp_payload() {
1375 let parser = create_parser_with_linktype(113); let mut packet = linux_sll_ipv4_tcp();
1379 packet.extend_from_slice(&[0x00; 6]);
1380
1381 let parsed = parser.parse_packet(&packet).unwrap();
1382 assert_eq!(parsed.tcp_header.unwrap().payload_len, 0);
1383 }
1384
1385 #[test]
1386 fn test_raw_ip_trailing_bytes_are_not_read_as_tcp_payload() {
1387 let parser = create_parser_with_linktype(12); let mut packet = ethernet_ipv4_tcp_syn()[14..].to_vec();
1391 packet.extend_from_slice(b"SSH-2.0-OpenSSH_9.6\r\n");
1392
1393 let parsed = parser.parse_packet(&packet).unwrap();
1394 assert_eq!(parsed.tcp_header.unwrap().payload_len, 0);
1395 assert!(parsed.dpi_result.is_none());
1396 }
1397
1398 #[test]
1399 fn test_raw_ipv6_padding_is_not_counted_as_tcp_payload() {
1400 let parser = create_parser_with_linktype(12); let mut packet = ethernet_ipv6_tcp()[14..].to_vec();
1402 packet.extend_from_slice(&[0x00; 6]);
1403
1404 let parsed = parser.parse_packet(&packet).unwrap();
1405 assert_eq!(parsed.tcp_header.unwrap().payload_len, 0);
1406 }
1407
1408 #[test]
1409 fn test_zero_total_length_keeps_full_payload() {
1410 let parser = create_parser_with_linktype(1);
1411 let mut packet = ethernet_ipv4_tcp_syn();
1414 packet[16] = 0x00;
1415 packet[17] = 0x00;
1416 packet.extend_from_slice(b"data");
1417
1418 let parsed = parser.parse_packet(&packet).unwrap();
1419 assert_eq!(parsed.tcp_header.unwrap().payload_len, 4);
1420 }
1421}