use std::net::IpAddr;
use crate::model::mac::MacAddr;
use pnet_packet::ethernet::{EtherType, EtherTypes};
use pnet_packet::ip::{IpNextHeaderProtocol, IpNextHeaderProtocols};
use pnet_packet::ipv4::Ipv4Packet;
use pnet_packet::ipv6::Ipv6Packet;
use crate::model::capture::{IpObservation, Ipv4Observation, Ipv6Observation};
use crate::protocols::craft;
use crate::protocols::error::PacketError;
use crate::protocols::ethernet;
use crate::protocols::ip;
use crate::protocols::sizes::{ETH_HDR_LEN, IP_V4_HDR_LEN, IP_V6_HDR_LEN};
#[non_exhaustive]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum LinkType {
Ethernet,
NullLoop,
Raw,
LinuxSll,
LinuxSll2,
Unsupported(i32),
}
const NULL_LOOP_HDR_LEN: usize = 4;
pub(crate) const SLL_HDR_LEN: usize = 16;
pub(crate) const SLL2_HDR_LEN: usize = 20;
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;
const DLT_LINUX_SLL: i32 = 113;
const DLT_LINUX_SLL2: i32 = 276;
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,
DLT_LINUX_SLL => LinkType::LinuxSll,
DLT_LINUX_SLL2 => LinkType::LinuxSll2,
other => LinkType::Unsupported(other),
}
}
}
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 => strip_null_loop(frame),
LinkType::Raw => Some(frame),
LinkType::LinuxSll => Cooked::sll(frame)?.ip_packet(),
LinkType::LinuxSll2 => Cooked::sll2(frame)?.ip_packet(),
LinkType::Unsupported(_) => None,
}
}
struct Cooked<'a> {
protocol: u16,
hardware_type: u16,
address_len: usize,
address: &'a [u8; 8],
payload: &'a [u8],
}
const ARPHRD_ETHER: u16 = 1;
impl<'a> Cooked<'a> {
fn sll(frame: &'a [u8]) -> Option<Self> {
let (header, payload) = frame.split_first_chunk::<SLL_HDR_LEN>()?;
Some(Self {
hardware_type: u16::from_be_bytes([header[2], header[3]]),
address_len: usize::from(u16::from_be_bytes([header[4], header[5]])),
address: header[6..].first_chunk()?,
protocol: u16::from_be_bytes([header[14], header[15]]),
payload,
})
}
fn sll2(frame: &'a [u8]) -> Option<Self> {
let (header, payload) = frame.split_first_chunk::<SLL2_HDR_LEN>()?;
Some(Self {
protocol: u16::from_be_bytes([header[0], header[1]]),
hardware_type: u16::from_be_bytes([header[8], header[9]]),
address_len: usize::from(header[11]),
address: header[12..].first_chunk()?,
payload,
})
}
fn ip_packet(&self) -> Option<&'a [u8]> {
match EtherType(self.protocol) {
EtherTypes::Ipv4 | EtherTypes::Ipv6 => Some(self.payload),
_ => None,
}
}
fn hardware_address(&self) -> Option<MacAddr> {
if self.hardware_type != ARPHRD_ETHER || self.address_len != 6 {
return None;
}
let [a, b, c, d, e, f, _, _] = *self.address;
Some(MacAddr::new(a, b, c, d, e, f))
}
}
fn strip_null_loop(frame: &[u8]) -> Option<&[u8]> {
let word = u32::from_ne_bytes(*frame.first_chunk::<NULL_LOOP_HDR_LEN>()?);
if !IP_ADDRESS_FAMILIES.contains(&word) && !IP_ADDRESS_FAMILIES.contains(&word.swap_bytes()) {
return None;
}
frame.get(NULL_LOOP_HDR_LEN..)
}
const IP_ADDRESS_FAMILIES: [u32; 5] = [2, 30, 28, 10, 24];
fn strip_ethernet(frame: &[u8]) -> Option<&[u8]> {
let parsed = ethernet::parse(frame).ok()?;
match EtherType(parsed.ethertype()) {
EtherTypes::Ipv4 | EtherTypes::Ipv6 => Some(parsed.payload()),
_ => 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::LinuxSll => Cooked::sll(frame)?.hardware_address(),
LinkType::LinuxSll2 => Cooked::sll2(frame)?.hardware_address(),
LinkType::NullLoop | LinkType::Raw | LinkType::Unsupported(_) => None,
}
}
#[non_exhaustive]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct IpSegment<'a> {
pub source: IpAddr,
pub destination: IpAddr,
pub protocol: u8,
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;
}
if packet.get_fragment_offset() != 0 {
return None;
}
Some(IpSegment {
source: IpAddr::V4(packet.get_source()),
destination: IpAddr::V4(packet.get_destination()),
protocol: packet.get_next_level_protocol().0,
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: protocol.0,
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 parse_captured(link: LinkType, frame: &[u8]) -> Option<(IpSegment<'_>, Option<MacAddr>)> {
let segment = parse_captured_segment(link, frame)?;
Some((segment, source_mac(link, frame)))
}
#[non_exhaustive]
#[derive(Debug, Clone, Copy)]
pub struct FrameSpec {
pub src_mac: MacAddr,
pub dst_mac: MacAddr,
pub src: IpAddr,
pub dst: IpAddr,
pub protocol: u8,
pub hop_limit: u8,
}
#[derive(Debug, Clone, Copy)]
pub(crate) struct IpSpec {
pub(crate) src: IpAddr,
pub(crate) dst: IpAddr,
pub(crate) protocol: u8,
pub(crate) hop_limit: u8,
}
impl FrameSpec {
fn ip(&self) -> IpSpec {
IpSpec {
src: self.src,
dst: self.dst,
protocol: self.protocol,
hop_limit: self.hop_limit,
}
}
}
pub(crate) fn build_ip_packets(
spec: &IpSpec,
segment: &[u8],
mtu: Option<u16>,
) -> Result<Vec<Vec<u8>>, PacketError> {
let IpSpec {
src,
dst,
protocol,
hop_limit,
} = *spec;
if let Some(mtu) = mtu {
return match (src, dst) {
(IpAddr::V4(s), IpAddr::V4(d)) => {
let header = craft::Ipv4 {
protocol: craft::Field::Exact(protocol),
..craft::Ipv4::new(s, d).with_ttl(hop_limit)
};
ip::fragment_ipv4(&header, segment, mtu)
}
(IpAddr::V6(s), IpAddr::V6(d)) => {
let header = craft::Ipv6 {
next_header: craft::Field::Exact(protocol),
..craft::Ipv6::new(s, d).with_hop_limit(hop_limit)
};
ip::fragment_ipv6(&header, segment, mtu)
}
_ => Err(PacketError::FamilyMismatch { src, dst }),
};
}
let payload_len = u16::try_from(segment.len())
.map_err(|_| PacketError::too_long("an IP payload length", 0, segment.len()))?;
let header = match (src, dst) {
(IpAddr::V4(s), IpAddr::V4(d)) => {
ip::build_ipv4_header(s, d, payload_len, protocol, hop_limit)?
}
(IpAddr::V6(s), IpAddr::V6(d)) => {
ip::build_ipv6_header(s, d, payload_len, protocol, hop_limit)
}
_ => return Err(PacketError::FamilyMismatch { src, dst }),
};
let mut packet = Vec::with_capacity(header.len() + segment.len());
packet.extend_from_slice(&header);
packet.extend_from_slice(segment);
Ok(vec![packet])
}
pub(crate) fn build_null_loop_frames(
spec: &IpSpec,
segment: &[u8],
mtu: Option<u16>,
) -> Result<Vec<Vec<u8>>, PacketError> {
const AF_INET: u32 = 2;
const AF_INET6_MACOS: u32 = 30;
let family = match spec.dst {
IpAddr::V4(_) => AF_INET,
IpAddr::V6(_) => AF_INET6_MACOS,
};
let packets = build_ip_packets(spec, segment, mtu)?;
Ok(packets
.into_iter()
.map(|packet| [&family.to_ne_bytes()[..], &packet].concat())
.collect())
}
fn behind_ethernet(
packets: Vec<Vec<u8>>,
src_mac: MacAddr,
dst_mac: MacAddr,
dst: IpAddr,
) -> Vec<Vec<u8>> {
let ethertype = match dst {
IpAddr::V4(_) => EtherTypes::Ipv4,
IpAddr::V6(_) => EtherTypes::Ipv6,
};
let header = ethernet::build_header(src_mac, dst_mac, ethertype.0);
packets
.into_iter()
.map(|packet| {
let mut frame = Vec::with_capacity(ETH_HDR_LEN + packet.len());
frame.extend_from_slice(&header);
frame.extend_from_slice(&packet);
frame
})
.collect()
}
pub fn build_ethernet_frame(spec: &FrameSpec, segment: &[u8]) -> Result<Vec<u8>, PacketError> {
let packets = build_ip_packets(&spec.ip(), segment, None)?;
let frames = behind_ethernet(packets, spec.src_mac, spec.dst_mac, spec.dst);
Ok(frames
.into_iter()
.next()
.expect("an unfragmented packet is one"))
}
pub fn build_fragmented_ethernet_frames(
spec: &FrameSpec,
segment: &[u8],
mtu: u16,
) -> Result<Vec<Vec<u8>>, PacketError> {
let packets = build_ip_packets(&spec.ip(), segment, Some(mtu))?;
Ok(behind_ethernet(
packets,
spec.src_mac,
spec.dst_mac,
spec.dst,
))
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn a_tunnel_frame_is_held_to_the_family_it_names() {
let packet = [
0x45u8, 0, 0, 20, 0, 0, 0, 0, 64, 6, 0, 0, 203, 0, 113, 1, 203, 0, 113, 2,
];
for word in [2u32.to_ne_bytes(), 2u32.to_be_bytes(), 2u32.to_le_bytes()] {
let frame = [&word[..], &packet[..]].concat();
assert_eq!(
strip_to_ip(LinkType::NullLoop, &frame),
Some(&packet[..]),
"an AF_INET frame was refused"
);
}
for family in [30u32, 28, 10, 24] {
let frame = [&family.to_ne_bytes()[..], &packet[..]].concat();
assert_eq!(strip_to_ip(LinkType::NullLoop, &frame), Some(&packet[..]));
}
for family in [1u32, 17, 0xDEAD_BEEF] {
let frame = [&family.to_ne_bytes()[..], &packet[..]].concat();
assert_eq!(
strip_to_ip(LinkType::NullLoop, &frame),
None,
"address family {family} was read as an IP packet"
);
}
assert_eq!(strip_to_ip(LinkType::NullLoop, &[0, 0, 0]), None);
}
#[test]
fn a_loopback_frame_reads_back_as_the_packet_it_carries() {
let payload = [0xABu8; 128];
for (src, dst) in [
(
IpAddr::from(Ipv4Addr::LOCALHOST),
IpAddr::from(Ipv4Addr::LOCALHOST),
),
(
IpAddr::from(Ipv6Addr::LOCALHOST),
IpAddr::from(Ipv6Addr::LOCALHOST),
),
] {
let spec = IpSpec {
src,
dst,
protocol: TCP,
hop_limit: 64,
};
for mtu in [None, Some(96)] {
let frames = build_null_loop_frames(&spec, &payload, mtu).expect("the frames");
assert_eq!(frames.len() > 1, mtu.is_some(), "{dst} at {mtu:?}");
for frame in &frames {
let packet = strip_to_ip(LinkType::NullLoop, frame)
.unwrap_or_else(|| panic!("{dst} at {mtu:?}: the word was not read"));
assert_eq!(packet.len() + NULL_LOOP_HDR_LEN, frame.len());
assert_eq!(packet[0] >> 4, if dst.is_ipv4() { 4 } else { 6 });
}
let whole = strip_to_ip(LinkType::NullLoop, &frames[0]).expect("a packet");
let segment = parse_ip_segment(whole).expect("an IP packet");
assert_eq!((segment.source, segment.destination), (src, dst));
if mtu.is_none() {
assert_eq!(segment.payload, &payload[..]);
}
}
}
}
#[test]
fn one_pass_yields_the_segment_and_the_address_the_two_passes_did() {
let mut frame = vec![
0x02, 0, 0, 0, 0, 1, 0x02, 0, 0, 0, 0, 2, 0x08, 0x00, ];
frame.extend_from_slice(&[
0x45, 0, 0, 20, 0, 0, 0, 0, 64, 6, 0, 0, 203, 0, 113, 1, 203, 0, 113, 2,
]);
let (segment, mac) = parse_captured(LinkType::Ethernet, &frame).expect("a segment");
assert_eq!(
Some(segment),
parse_captured_segment(LinkType::Ethernet, &frame)
);
assert_eq!(mac, source_mac(LinkType::Ethernet, &frame));
assert_eq!(mac, Some(MacAddr::new(0x02, 0, 0, 0, 0, 2)));
}
use pnet_packet::ip::IpNextHeaderProtocols;
use std::net::{Ipv4Addr, Ipv6Addr};
const TCP: u8 = IpNextHeaderProtocols::Tcp.0;
#[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(113), LinkType::LinuxSll);
assert_eq!(LinkType::from_dlt(276), LinkType::LinuxSll2);
assert_eq!(LinkType::from_dlt(999), LinkType::Unsupported(999));
}
fn ipv4_packet(src: Ipv4Addr, payload: &[u8]) -> Vec<u8> {
ip::build_ipv4_header(
src,
Ipv4Addr::LOCALHOST,
payload.len() as u16,
TCP,
ip::HOP_LIMIT_ROUTED,
)
.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::build_ipv6_header(
src,
Ipv6Addr::LOCALHOST,
payload.len() as u16,
IpNextHeaderProtocols::Udp.0,
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.0);
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;
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 a_later_ipv4_fragment_is_not_a_segment() {
let fragment = |flag_and_offset: u16| {
let mut packet = vec![0u8; IP_V4_HDR_LEN + 8];
packet[0] = 0x45;
packet[2..4].copy_from_slice(&((IP_V4_HDR_LEN + 8) as u16).to_be_bytes());
packet[6..8].copy_from_slice(&flag_and_offset.to_be_bytes());
packet[9] = TCP;
packet
};
assert!(parse_ip_segment(&fragment(0b0010_0000_0000_0000 | 185)).is_none());
assert!(parse_ip_segment(&fragment(185)).is_none());
let first_bytes = fragment(0b0010_0000_0000_0000);
let first =
parse_ip_segment(&first_bytes).expect("the first fragment holds the Layer-4 header");
assert!(
first.observation.is_fragment(),
"the first fragment says it is one"
);
let whole_bytes = fragment(0);
let whole = parse_ip_segment(&whole_bytes).expect("a whole datagram");
assert!(!whole.observation.is_fragment());
}
#[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;
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;
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(203, 0, 113, 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(203, 0, 113, 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(203, 0, 113, 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(
&FrameSpec {
src_mac: MacAddr::new(1, 2, 3, 4, 5, 6),
dst_mac: MacAddr::new(6, 5, 4, 3, 2, 1),
src: IpAddr::V4(Ipv4Addr::new(192, 0, 2, 5)),
dst: IpAddr::V4(Ipv4Addr::new(192, 0, 2, 1)),
protocol: TCP,
hop_limit: ip::HOP_LIMIT_ROUTED,
},
&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 fragmenting_wraps_each_ip_fragment_in_its_own_ethernet_frame() {
use pnet_packet::Packet;
let src_mac = MacAddr::new(0x00, 0x11, 0x22, 0x33, 0x44, 0x55);
let dst_mac = MacAddr::new(0x66, 0x77, 0x88, 0x99, 0xAA, 0xBB);
let src = IpAddr::V4(Ipv4Addr::new(192, 0, 2, 1));
let dst = IpAddr::V4(Ipv4Addr::new(192, 0, 2, 2));
let segment: Vec<u8> = (0..40u8).collect();
let mtu = (IP_V4_HDR_LEN + 16) as u16;
let frames = build_fragmented_ethernet_frames(
&FrameSpec {
src_mac,
dst_mac,
src,
dst,
protocol: TCP,
hop_limit: ip::HOP_LIMIT_ROUTED,
},
&segment,
mtu,
)
.expect("an IPv4 segment fragments");
assert!(
frames.len() > 1,
"40 bytes should not fit one 16-byte fragment"
);
let mut reassembled = Vec::new();
for frame in &frames {
assert_eq!(
&frame[12..14],
&[0x08, 0x00],
"each frame is an IPv4 Ethernet frame"
);
let ip_packet = &frame[ETH_HDR_LEN..];
assert!(
ip_packet.len() <= usize::from(mtu),
"each fragment fits the MTU"
);
reassembled.extend_from_slice(Ipv4Packet::new(ip_packet).unwrap().payload());
}
assert_eq!(
reassembled, segment,
"the fragments reassemble to the original segment"
);
}
#[test]
fn fragmenting_wraps_each_ipv6_fragment_in_its_own_ethernet_frame() {
use pnet_packet::Packet;
use pnet_packet::ipv6::{FragmentPacket, Ipv6Packet};
let mac = MacAddr::new(0, 0, 0, 0, 0, 1);
let src = IpAddr::V6(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 1));
let dst = IpAddr::V6(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 2));
let segment: Vec<u8> = (0..40u8).collect();
let mtu = (IP_V6_HDR_LEN + 8 + 16) as u16;
let frames = build_fragmented_ethernet_frames(
&FrameSpec {
src_mac: mac,
dst_mac: mac,
src,
dst,
protocol: TCP,
hop_limit: ip::HOP_LIMIT_ROUTED,
},
&segment,
mtu,
)
.expect("an IPv6 segment fragments");
assert!(
frames.len() > 1,
"40 bytes should not fit one 16-byte fragment"
);
let mut reassembled = Vec::new();
for frame in &frames {
assert_eq!(
&frame[12..14],
&[0x86, 0xDD],
"each frame is an IPv6 Ethernet frame"
);
let ip_bytes = &frame[ETH_HDR_LEN..];
assert!(
ip_bytes.len() <= usize::from(mtu),
"each fragment fits the MTU"
);
let packet = Ipv6Packet::new(ip_bytes).expect("a v6 packet");
assert_eq!(
packet.get_next_header(),
IpNextHeaderProtocols::Ipv6Frag,
"the base header points at the fragment extension header"
);
let fragment = FragmentPacket::new(packet.payload()).expect("a fragment header");
assert_eq!(
fragment.get_next_header().0,
TCP,
"the fragment header carries the upper-layer protocol"
);
reassembled.extend_from_slice(&packet.payload()[8..]);
}
assert_eq!(
reassembled, segment,
"the fragments reassemble to the original segment"
);
}
#[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(
&FrameSpec {
src_mac: sender,
dst_mac: MacAddr::new(1, 1, 1, 1, 1, 1),
src: IpAddr::V4(Ipv4Addr::new(198, 51, 100, 9)),
dst: IpAddr::V4(Ipv4Addr::new(198, 51, 100, 1)),
protocol: TCP,
hop_limit: ip::HOP_LIMIT_ROUTED,
},
&[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(203, 0, 113, 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());
}
const DLT_SLL: i32 = 113;
const DLT_SLL2: i32 = 276;
const TO_US: u8 = 0;
const FROM_US: u8 = 4;
const ARPHRD_ETHER: u16 = 1;
const ARPHRD_PPP: u16 = 512;
const ARPHRD_IPGRE: u16 = 778;
const COOKED_V4: [u8; 20] = [
0x45, 0, 0, 20, 0, 0, 0, 0, 64, 6, 0, 0, 203, 0, 113, 1, 203, 0, 113, 2,
];
const COOKED_V6: [u8; 40] = [
0x60, 0, 0, 0, 0, 0, 6, 64, 0x20, 0x01, 0x0d, 0xb8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0x20, 0x01, 0x0d, 0xb8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, ];
fn cooked(
dlt: i32,
packet_type: u8,
hardware_type: u16,
address: &[u8],
protocol: u16,
payload: &[u8],
) -> Vec<u8> {
let mut padded = [0u8; 8];
padded[..address.len()].copy_from_slice(address);
let address_len = address.len() as u8;
let mut frame = Vec::new();
match dlt {
DLT_SLL => {
frame.extend_from_slice(&u16::from(packet_type).to_be_bytes());
frame.extend_from_slice(&hardware_type.to_be_bytes());
frame.extend_from_slice(&u16::from(address_len).to_be_bytes());
frame.extend_from_slice(&padded);
frame.extend_from_slice(&protocol.to_be_bytes());
assert_eq!(frame.len(), 16);
}
DLT_SLL2 => {
frame.extend_from_slice(&protocol.to_be_bytes());
frame.extend_from_slice(&[0, 0]);
frame.extend_from_slice(&7u32.to_be_bytes());
frame.extend_from_slice(&hardware_type.to_be_bytes());
frame.push(packet_type);
frame.push(address_len);
frame.extend_from_slice(&padded);
assert_eq!(frame.len(), 20);
}
other => panic!("{other} is not a cooked data-link type"),
}
frame.extend_from_slice(payload);
frame
}
#[test]
fn a_cooked_frame_yields_the_ip_packet_its_protocol_field_names() {
for dlt in [DLT_SLL, DLT_SLL2] {
let link = LinkType::from_dlt(dlt);
for (protocol, packet, source) in [
(0x0800, &COOKED_V4[..], IpAddr::from([203, 0, 113, 1])),
(0x86DD, &COOKED_V6[..], "2001:db8::1".parse().unwrap()),
] {
let frame = cooked(dlt, TO_US, ARPHRD_PPP, &[], protocol, packet);
assert_eq!(
strip_to_ip(link, &frame),
Some(packet),
"data-link type {dlt} did not yield the packet behind protocol {protocol:#06x}"
);
let segment = parse_captured_segment(link, &frame).expect("a segment");
assert_eq!(segment.source, source);
}
}
}
#[test]
fn a_probe_leaving_a_cooked_link_is_read_like_an_answer_arriving() {
for dlt in [DLT_SLL, DLT_SLL2] {
let link = LinkType::from_dlt(dlt);
let arriving = cooked(dlt, TO_US, ARPHRD_PPP, &[], 0x0800, &COOKED_V4);
let leaving = cooked(dlt, FROM_US, ARPHRD_PPP, &[], 0x0800, &COOKED_V4);
assert_eq!(strip_to_ip(link, &leaving), Some(&COOKED_V4[..]));
assert_eq!(
parse_captured(link, &leaving),
parse_captured(link, &arriving)
);
}
}
#[test]
fn a_cooked_frame_carrying_anything_but_ip_is_refused() {
for dlt in [DLT_SLL, DLT_SLL2] {
let link = LinkType::from_dlt(dlt);
let sender = [0x02, 0, 0, 0, 0, 1];
for protocol in [0x0806, 0x0004, 0x0000] {
let frame = cooked(dlt, TO_US, ARPHRD_ETHER, &sender, protocol, &COOKED_V4);
assert_eq!(
strip_to_ip(link, &frame),
None,
"data-link type {dlt} read protocol {protocol:#06x} as IP"
);
}
let whole = cooked(dlt, TO_US, ARPHRD_PPP, &[], 0x0800, &[]);
assert!(strip_to_ip(link, &whole).is_some());
for cut in 0..whole.len() {
assert_eq!(
strip_to_ip(link, &whole[..cut]),
None,
"data-link type {dlt} read a {cut}-byte header"
);
}
}
}
#[test]
fn a_cooked_frame_names_a_hardware_address_only_where_its_header_says_it_holds_one() {
let sender = [0x02, 0, 0, 0, 0, 0x2A];
for dlt in [DLT_SLL, DLT_SLL2] {
let link = LinkType::from_dlt(dlt);
let ethernet = cooked(dlt, TO_US, ARPHRD_ETHER, &sender, 0x0800, &COOKED_V4);
assert_eq!(
source_mac(link, ðernet),
Some(MacAddr::new(0x02, 0, 0, 0, 0, 0x2A)),
"data-link type {dlt} lost an Ethernet sender's address"
);
let (_, mac) = parse_captured(link, ðernet).expect("a segment");
assert_eq!(mac, source_mac(link, ðernet));
for (hardware_type, address) in [
(ARPHRD_PPP, &[][..]),
(ARPHRD_IPGRE, &[198, 51, 100, 1][..]),
(ARPHRD_ETHER, &[0x02, 0, 0, 0, 0, 0x2A, 0, 0][..]),
] {
let frame = cooked(dlt, TO_US, hardware_type, address, 0x0800, &COOKED_V4);
assert_eq!(
source_mac(link, &frame),
None,
"data-link type {dlt} read hardware type {hardware_type} as an Ethernet address"
);
}
assert_eq!(source_mac(link, ðernet[..11]), None);
}
}
#[test]
fn libpcap_reads_the_protocol_where_these_cooked_frames_put_it() {
for dlt in [DLT_SLL, DLT_SLL2] {
let capture = pcap::Capture::dead(pcap::Linktype(dlt)).expect("a dead capture");
let admits = |filter: &str, frame: &[u8]| {
capture
.compile(filter, true)
.unwrap_or_else(|e| panic!("compiling `{filter}` for {dlt}: {e}"))
.filter(frame)
};
let v4 = cooked(dlt, TO_US, ARPHRD_PPP, &[], 0x0800, &COOKED_V4);
let v6 = cooked(dlt, TO_US, ARPHRD_PPP, &[], 0x86DD, &COOKED_V6);
assert!(admits("ip", &v4) && !admits("ip6", &v4), "{dlt}: IPv4");
assert!(admits("ip6", &v6) && !admits("ip", &v6), "{dlt}: IPv6");
assert!(
admits("src host 203.0.113.1", &v4),
"{dlt}: libpcap found the IPv4 header somewhere other than behind the pseudo-header"
);
}
let captured = [0, 4, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x86, 0xDD];
assert_eq!(
cooked(DLT_SLL, FROM_US, ARPHRD_PPP, &[], 0x86DD, &[]),
captured
);
}
fn ipv6_chain(first: IpNextHeaderProtocol, chain: &[u8], segment: &[u8]) -> Vec<u8> {
let payload_len = (chain.len() + segment.len()) as u16;
ip::build_ipv6_header(
Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 1),
Ipv6Addr::LOCALHOST,
payload_len,
first.0,
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.0);
}
}