use std::net::IpAddr;
use anyhow::Context;
use pnet::packet::ethernet::{EtherType, EtherTypes};
use pnet::packet::ip::{IpNextHeaderProtocol, IpNextHeaderProtocols};
use pnet::packet::ipv4::Ipv4Packet;
use pnet::packet::ipv6::Ipv6Packet;
use pnet::util::MacAddr;
use crate::model::capture::{IpObservation, Ipv4Observation, Ipv6Observation};
use crate::protocols::ethernet;
use crate::protocols::ip;
use crate::protocols::sizes::{ETH_HDR_LEN, IP_V4_HDR_LEN, IP_V6_HDR_LEN};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum LinkType {
Ethernet,
NullLoop,
Raw,
Unsupported(i32),
}
const NULL_LOOP_HDR_LEN: usize = 4;
const DLT_NULL: i32 = 0;
const DLT_EN10MB: i32 = 1;
const DLT_LOOP: i32 = 108;
const DLT_RAW_BSD: i32 = 12;
const DLT_RAW_LINKTYPE: i32 = 101;
impl LinkType {
pub fn from_dlt(dlt: i32) -> Self {
match dlt {
DLT_EN10MB => LinkType::Ethernet,
DLT_NULL | DLT_LOOP => LinkType::NullLoop,
DLT_RAW_BSD | DLT_RAW_LINKTYPE => LinkType::Raw,
other => LinkType::Unsupported(other),
}
}
}
const ETHERTYPE_VLAN: u16 = 0x8100;
const VLAN_TAG_LEN: usize = 4;
const IPV4_DONT_FRAGMENT: u8 = 0b010;
const IPV4_MORE_FRAGMENTS: u8 = 0b001;
pub fn strip_to_ip(link: LinkType, frame: &[u8]) -> Option<&[u8]> {
match link {
LinkType::Ethernet => strip_ethernet(frame),
LinkType::NullLoop => frame.get(NULL_LOOP_HDR_LEN..),
LinkType::Raw => Some(frame),
LinkType::Unsupported(_) => None,
}
}
fn strip_ethernet(frame: &[u8]) -> Option<&[u8]> {
let ethertype = u16::from_be_bytes([*frame.get(12)?, *frame.get(13)?]);
let (ethertype, payload_offset) = if ethertype == ETHERTYPE_VLAN {
let inner =
u16::from_be_bytes([*frame.get(ETH_HDR_LEN + 2)?, *frame.get(ETH_HDR_LEN + 3)?]);
(inner, ETH_HDR_LEN + VLAN_TAG_LEN)
} else {
(ethertype, ETH_HDR_LEN)
};
match EtherType(ethertype) {
EtherTypes::Ipv4 | EtherTypes::Ipv6 => frame.get(payload_offset..),
_ => None,
}
}
pub fn source_mac(link: LinkType, frame: &[u8]) -> Option<MacAddr> {
match link {
LinkType::Ethernet => Some(MacAddr::new(
*frame.get(6)?,
*frame.get(7)?,
*frame.get(8)?,
*frame.get(9)?,
*frame.get(10)?,
*frame.get(11)?,
)),
LinkType::NullLoop | LinkType::Raw | LinkType::Unsupported(_) => None,
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct IpSegment<'a> {
pub source: IpAddr,
pub destination: IpAddr,
pub protocol: IpNextHeaderProtocol,
pub payload: &'a [u8],
pub observation: IpObservation,
}
pub fn parse_ip_segment(ip_bytes: &[u8]) -> Option<IpSegment<'_>> {
match ip_bytes.first()? >> 4 {
4 => {
let packet = Ipv4Packet::new(ip_bytes)?;
let header_len = packet.get_header_length() as usize * 4;
if header_len < IP_V4_HDR_LEN {
return None;
}
Some(IpSegment {
source: IpAddr::V4(packet.get_source()),
destination: IpAddr::V4(packet.get_destination()),
protocol: packet.get_next_level_protocol(),
payload: ip_bytes.get(header_len..)?,
observation: IpObservation::V4(Ipv4Observation {
ttl: packet.get_ttl(),
identification: packet.get_identification(),
dont_fragment: packet.get_flags() & IPV4_DONT_FRAGMENT != 0,
more_fragments: packet.get_flags() & IPV4_MORE_FRAGMENTS != 0,
dscp: packet.get_dscp(),
ecn: packet.get_ecn(),
}),
})
}
6 => {
let packet = Ipv6Packet::new(ip_bytes)?;
let (protocol, offset) =
walk_ipv6_headers(ip_bytes, packet.get_next_header(), IP_V6_HDR_LEN)?;
Some(IpSegment {
source: IpAddr::V6(packet.get_source()),
destination: IpAddr::V6(packet.get_destination()),
protocol,
payload: ip_bytes.get(offset..)?,
observation: IpObservation::V6(Ipv6Observation {
hop_limit: packet.get_hop_limit(),
traffic_class: packet.get_traffic_class(),
flow_label: packet.get_flow_label(),
}),
})
}
_ => None,
}
}
const MAX_EXTENSION_HEADERS: usize = 8;
fn walk_ipv6_headers(
bytes: &[u8],
protocol: IpNextHeaderProtocol,
offset: usize,
) -> Option<(IpNextHeaderProtocol, usize)> {
use IpNextHeaderProtocols as Protocols;
let mut protocol = protocol;
let mut offset = offset;
for _ in 0..MAX_EXTENSION_HEADERS {
let length = match protocol {
Protocols::Ipv6NoNxt => return None,
Protocols::Hopopt | Protocols::Ipv6Route | Protocols::Ipv6Opts => {
(usize::from(*bytes.get(offset + 1)?) + 1) * 8
}
Protocols::Ah => (usize::from(*bytes.get(offset + 1)?) + 2) * 4,
Protocols::Ipv6Frag => {
let fragment_offset =
u16::from_be_bytes([*bytes.get(offset + 2)?, *bytes.get(offset + 3)?]) >> 3;
if fragment_offset != 0 {
return None;
}
8
}
transport => return Some((transport, offset)),
};
protocol = IpNextHeaderProtocol::new(*bytes.get(offset)?);
offset = offset.checked_add(length)?;
if offset > bytes.len() {
return None;
}
}
None
}
pub fn parse_captured_segment(link: LinkType, frame: &[u8]) -> Option<IpSegment<'_>> {
parse_ip_segment(strip_to_ip(link, frame)?)
}
pub fn build_ethernet_frame(
src_mac: MacAddr,
dst_mac: MacAddr,
src: IpAddr,
dst: IpAddr,
protocol: IpNextHeaderProtocol,
segment: &[u8],
) -> anyhow::Result<Vec<u8>> {
let payload_len = u16::try_from(segment.len()).context("layer-4 segment too large for IP")?;
let (ethertype, ip_header) = match (src, dst) {
(IpAddr::V4(s), IpAddr::V4(d)) => (
EtherTypes::Ipv4,
ip::create_ipv4_header(s, d, payload_len, protocol)?,
),
(IpAddr::V6(s), IpAddr::V6(d)) => (
EtherTypes::Ipv6,
ip::create_ipv6_header(s, d, payload_len, protocol, ip::HOP_LIMIT_ROUTED),
),
_ => anyhow::bail!("IP version mismatch between {src} and {dst}"),
};
let mut frame = Vec::with_capacity(ETH_HDR_LEN + ip_header.len() + segment.len());
frame.extend_from_slice(ðernet::create_header(src_mac, dst_mac, ethertype));
frame.extend_from_slice(&ip_header);
frame.extend_from_slice(segment);
Ok(frame)
}
#[cfg(test)]
mod tests {
use super::*;
use pnet::packet::ip::IpNextHeaderProtocols;
use std::net::{Ipv4Addr, Ipv6Addr};
const TCP: IpNextHeaderProtocol = IpNextHeaderProtocols::Tcp;
#[test]
fn dlt_mapping_covers_known_link_types() {
assert_eq!(LinkType::from_dlt(1), LinkType::Ethernet);
assert_eq!(LinkType::from_dlt(0), LinkType::NullLoop);
assert_eq!(LinkType::from_dlt(108), LinkType::NullLoop);
assert_eq!(LinkType::from_dlt(12), LinkType::Raw);
assert_eq!(LinkType::from_dlt(101), LinkType::Raw);
assert_eq!(LinkType::from_dlt(999), LinkType::Unsupported(999));
}
fn ipv4_packet(src: Ipv4Addr, payload: &[u8]) -> Vec<u8> {
ip::create_ipv4_header(src, Ipv4Addr::LOCALHOST, payload.len() as u16, TCP)
.unwrap()
.into_iter()
.chain(payload.iter().copied())
.collect()
}
#[test]
fn parses_endpoints_protocol_and_segment_from_ipv4() {
let payload = [0xDE, 0xAD, 0xBE, 0xEF];
let src = Ipv4Addr::new(203, 0, 113, 7);
let packet = ipv4_packet(src, &payload);
let parsed = parse_ip_segment(&packet).unwrap();
assert_eq!(parsed.source, IpAddr::V4(src));
assert_eq!(parsed.destination, IpAddr::V4(Ipv4Addr::LOCALHOST));
assert_eq!(parsed.protocol, TCP);
assert_eq!(parsed.payload, &payload);
}
#[test]
fn parses_endpoints_protocol_and_segment_from_ipv6() {
let payload = [1, 2, 3, 4];
let src = Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 1);
let header = ip::create_ipv6_header(
src,
Ipv6Addr::LOCALHOST,
payload.len() as u16,
IpNextHeaderProtocols::Udp,
ip::HOP_LIMIT_ROUTED,
);
let packet: Vec<u8> = header.into_iter().chain(payload).collect();
let parsed = parse_ip_segment(&packet).unwrap();
assert_eq!(parsed.source, IpAddr::V6(src));
assert_eq!(parsed.destination, IpAddr::V6(Ipv6Addr::LOCALHOST));
assert_eq!(parsed.protocol, IpNextHeaderProtocols::Udp);
assert_eq!(parsed.payload, &payload);
}
#[test]
fn an_ipv4_header_yields_the_fields_its_stack_chose() {
let mut packet = vec![0u8; IP_V4_HDR_LEN];
packet[0] = 0x45; packet[1] = 0x8B; packet[2..4].copy_from_slice(&(IP_V4_HDR_LEN as u16).to_be_bytes());
packet[4..6].copy_from_slice(&0xBEEFu16.to_be_bytes()); packet[6] = 0x40; packet[8] = 57; packet[9] = TCP.0;
let IpObservation::V4(observed) = parse_ip_segment(&packet).unwrap().observation else {
panic!("an IPv4 packet observes an IPv4 header");
};
assert_eq!(observed.ttl, 57);
assert_eq!(observed.identification, 0xBEEF);
assert!(observed.dont_fragment);
assert!(!observed.more_fragments);
assert_eq!(observed.dscp, 34);
assert_eq!(observed.ecn, 3);
}
#[test]
fn the_two_fragment_bits_are_not_each_other() {
let observe = |flag_byte: u8| {
let mut packet = vec![0u8; IP_V4_HDR_LEN];
packet[0] = 0x45;
packet[6] = flag_byte;
packet[9] = TCP.0;
match parse_ip_segment(&packet).unwrap().observation {
IpObservation::V4(observed) => observed,
IpObservation::V6(_) => panic!("an IPv4 packet observes an IPv4 header"),
}
};
let dont_fragment = observe(0b0100_0000);
assert!(dont_fragment.dont_fragment && !dont_fragment.more_fragments);
let more_fragments = observe(0b0010_0000);
assert!(more_fragments.more_fragments && !more_fragments.dont_fragment);
assert!(
IpObservation::V4(more_fragments).is_fragment(),
"a datagram with more to come is a fragment, and its headers describe only this piece"
);
}
#[test]
fn an_ipv6_header_yields_the_fields_across_its_first_word() {
let mut packet = vec![0u8; IP_V6_HDR_LEN];
packet[0..4].copy_from_slice(&0x68B1_2345u32.to_be_bytes());
packet[6] = TCP.0;
packet[7] = 57;
let IpObservation::V6(observed) = parse_ip_segment(&packet).unwrap().observation else {
panic!("an IPv6 packet observes an IPv6 header");
};
assert_eq!(observed.hop_limit, 57);
assert_eq!(observed.traffic_class, 0x8B);
assert_eq!(observed.flow_label, 0x12345);
}
#[test]
fn implausible_ipv4_header_length_is_rejected() {
let mut packet = ipv4_packet(Ipv4Addr::new(10, 0, 0, 1), &[1, 2, 3, 4]);
packet[0] = 0x43;
assert!(parse_ip_segment(&packet).is_none());
}
#[test]
fn null_loop_link_strips_four_byte_family_word() {
let payload = [9, 9, 9, 9];
let packet = ipv4_packet(Ipv4Addr::new(10, 0, 0, 1), &payload);
let mut framed = vec![2, 0, 0, 0];
framed.extend_from_slice(&packet);
let parsed = parse_captured_segment(LinkType::NullLoop, &framed).unwrap();
assert_eq!(parsed.source, IpAddr::V4(Ipv4Addr::new(10, 0, 0, 1)));
assert_eq!(parsed.payload, &payload);
}
#[test]
fn ethernet_link_selects_ipv4_by_ethertype() {
let payload = [7, 7];
let ip_packet = ipv4_packet(Ipv4Addr::new(192, 0, 2, 5), &payload);
let frame = build_ethernet_frame(
MacAddr::new(1, 2, 3, 4, 5, 6),
MacAddr::new(6, 5, 4, 3, 2, 1),
IpAddr::V4(Ipv4Addr::new(192, 0, 2, 5)),
IpAddr::V4(Ipv4Addr::new(192, 0, 2, 1)),
TCP,
&payload,
)
.unwrap();
let _ = ip_packet;
let parsed = parse_captured_segment(LinkType::Ethernet, &frame).unwrap();
assert_eq!(parsed.source, IpAddr::V4(Ipv4Addr::new(192, 0, 2, 5)));
assert_eq!(parsed.destination, IpAddr::V4(Ipv4Addr::new(192, 0, 2, 1)));
assert_eq!(parsed.payload, &payload);
}
#[test]
fn ethernet_link_ignores_non_ip_ethertype() {
let mut frame = vec![0u8; ETH_HDR_LEN + 8];
frame[12] = 0x08;
frame[13] = 0x06;
assert!(parse_captured_segment(LinkType::Ethernet, &frame).is_none());
}
#[test]
fn ethernet_link_skips_vlan_tag() {
let payload = [4, 2];
let inner = ipv4_packet(Ipv4Addr::new(198, 51, 100, 9), &payload);
let mut frame = vec![0u8; ETH_HDR_LEN];
frame[12] = 0x81; frame[13] = 0x00;
frame.extend_from_slice(&[0x00, 0x64]); frame.extend_from_slice(&[0x08, 0x00]); frame.extend_from_slice(&inner);
let parsed = parse_captured_segment(LinkType::Ethernet, &frame).unwrap();
assert_eq!(parsed.source, IpAddr::V4(Ipv4Addr::new(198, 51, 100, 9)));
assert_eq!(parsed.payload, &payload);
}
#[test]
fn the_source_hardware_address_does_not_move_for_a_vlan_tag() {
let sender = MacAddr::new(0xDE, 0xAD, 0xBE, 0xEF, 0x00, 0x01);
let inner = ipv4_packet(Ipv4Addr::new(198, 51, 100, 9), &[4, 2]);
let plain = build_ethernet_frame(
sender,
MacAddr::new(1, 1, 1, 1, 1, 1),
IpAddr::V4(Ipv4Addr::new(198, 51, 100, 9)),
IpAddr::V4(Ipv4Addr::new(198, 51, 100, 1)),
TCP,
&[4, 2],
)
.unwrap();
assert_eq!(source_mac(LinkType::Ethernet, &plain), Some(sender));
let mut tagged = vec![0u8; ETH_HDR_LEN];
tagged[6..12].copy_from_slice(&[0xDE, 0xAD, 0xBE, 0xEF, 0x00, 0x01]);
tagged[12] = 0x81; tagged[13] = 0x00;
tagged.extend_from_slice(&[0x00, 0x64]); tagged.extend_from_slice(&[0x08, 0x00]); tagged.extend_from_slice(&inner);
assert_eq!(source_mac(LinkType::Ethernet, &tagged), Some(sender));
}
#[test]
fn a_link_without_hardware_addresses_reports_none() {
let packet = ipv4_packet(Ipv4Addr::new(10, 0, 0, 1), &[1, 2, 3, 4]);
let mut framed = vec![2, 0, 0, 0];
framed.extend_from_slice(&packet);
assert!(source_mac(LinkType::NullLoop, &framed).is_none());
assert!(source_mac(LinkType::Raw, &packet).is_none());
assert!(source_mac(LinkType::Unsupported(42), &packet).is_none());
assert!(source_mac(LinkType::Ethernet, &[0u8; 8]).is_none());
}
#[test]
fn unsupported_link_yields_nothing() {
let frame = [0u8; 32];
assert!(parse_captured_segment(LinkType::Unsupported(42), &frame).is_none());
}
fn ipv6_chain(first: IpNextHeaderProtocol, chain: &[u8], segment: &[u8]) -> Vec<u8> {
let payload_len = (chain.len() + segment.len()) as u16;
ip::create_ipv6_header(
Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 1),
Ipv6Addr::LOCALHOST,
payload_len,
first,
ip::HOP_LIMIT_ROUTED,
)
.into_iter()
.chain(chain.iter().copied())
.chain(segment.iter().copied())
.collect()
}
fn extension(next: IpNextHeaderProtocol, units_past_first: u8) -> Vec<u8> {
let mut header = vec![0u8; (usize::from(units_past_first) + 1) * 8];
header[0] = next.0;
header[1] = units_past_first;
header
}
#[test]
fn a_chain_of_extension_headers_yields_the_transport_behind_it() {
let segment = [0xAB, 0xCD, 0xEF, 0x01];
let chain = [
extension(IpNextHeaderProtocols::Ipv6Route, 0),
extension(IpNextHeaderProtocols::Tcp, 2),
]
.concat();
let packet = ipv6_chain(IpNextHeaderProtocols::Ipv6Opts, &chain, &segment);
let parsed = parse_ip_segment(&packet).unwrap();
assert_eq!(parsed.protocol, TCP);
assert_eq!(parsed.payload, &segment);
}
#[test]
fn the_first_fragment_yields_its_transport_header() {
let segment = [1, 2, 3, 4];
let mut fragment = vec![0u8; 8];
fragment[0] = IpNextHeaderProtocols::Tcp.0;
fragment[3] = 1;
let packet = ipv6_chain(IpNextHeaderProtocols::Ipv6Frag, &fragment, &segment);
let parsed = parse_ip_segment(&packet).unwrap();
assert_eq!(parsed.protocol, TCP);
assert_eq!(parsed.payload, &segment);
}
#[test]
fn a_later_fragment_yields_nothing() {
let mut fragment = vec![0u8; 8];
fragment[0] = IpNextHeaderProtocols::Tcp.0;
fragment[2..4].copy_from_slice(&(185u16 << 3).to_be_bytes());
let packet = ipv6_chain(IpNextHeaderProtocols::Ipv6Frag, &fragment, &[1, 2, 3, 4]);
assert!(parse_ip_segment(&packet).is_none());
}
#[test]
fn implausible_extension_chains_are_refused() {
let overrunning = ipv6_chain(
IpNextHeaderProtocols::Ipv6Opts,
&[IpNextHeaderProtocols::Tcp.0, 200, 0, 0, 0, 0, 0, 0],
&[],
);
assert!(parse_ip_segment(&overrunning).is_none());
let endless: Vec<u8> = (0..MAX_EXTENSION_HEADERS + 2)
.flat_map(|_| extension(IpNextHeaderProtocols::Ipv6Opts, 0))
.collect();
let too_long = ipv6_chain(IpNextHeaderProtocols::Ipv6Opts, &endless, &[1, 2, 3, 4]);
assert!(parse_ip_segment(&too_long).is_none());
let nothing_follows = ipv6_chain(IpNextHeaderProtocols::Ipv6NoNxt, &[], &[]);
assert!(parse_ip_segment(¬hing_follows).is_none());
}
#[test]
fn an_encrypted_payload_is_reported_as_esp() {
let packet = ipv6_chain(IpNextHeaderProtocols::Esp, &[], &[9, 9, 9, 9]);
let parsed = parse_ip_segment(&packet).unwrap();
assert_eq!(parsed.protocol, IpNextHeaderProtocols::Esp);
}
}