use std::net::IpAddr;
use pnet_base::MacAddr;
use pnet_packet::ethernet::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,
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 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::Unsupported(_) => None,
}
}
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 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::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;
}
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(),
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 parse_captured(link: LinkType, frame: &[u8]) -> Option<(IpSegment<'_>, Option<MacAddr>)> {
let segment = parse_captured_segment(link, frame)?;
Some((segment, source_mac(link, frame)))
}
#[derive(Debug, Clone, Copy)]
pub struct FrameSpec {
pub src_mac: MacAddr,
pub dst_mac: MacAddr,
pub src: IpAddr,
pub dst: IpAddr,
pub protocol: IpNextHeaderProtocol,
pub hop_limit: u8,
}
pub fn build_ethernet_frame(spec: &FrameSpec, segment: &[u8]) -> Result<Vec<u8>, PacketError> {
let FrameSpec {
src_mac,
dst_mac,
src,
dst,
protocol,
hop_limit,
} = *spec;
let payload_len = u16::try_from(segment.len())
.map_err(|_| PacketError::too_long("an IP payload length", 0, segment.len()))?;
let (ethertype, ip_header) = match (src, dst) {
(IpAddr::V4(s), IpAddr::V4(d)) => (
EtherTypes::Ipv4,
ip::build_ipv4_header(s, d, payload_len, protocol, hop_limit)?,
),
(IpAddr::V6(s), IpAddr::V6(d)) => (
EtherTypes::Ipv6,
ip::build_ipv6_header(s, d, payload_len, protocol, hop_limit),
),
_ => return Err(PacketError::FamilyMismatch { src, dst }),
};
let mut frame = Vec::with_capacity(ETH_HDR_LEN + ip_header.len() + segment.len());
frame.extend_from_slice(ðernet::build_header(src_mac, dst_mac, ethertype));
frame.extend_from_slice(&ip_header);
frame.extend_from_slice(segment);
Ok(frame)
}
pub fn build_fragmented_ethernet_frames(
spec: &FrameSpec,
segment: &[u8],
mtu: u16,
) -> Result<Vec<Vec<u8>>, PacketError> {
let FrameSpec {
src_mac,
dst_mac,
src,
dst,
protocol,
hop_limit,
} = *spec;
let (packets, ethertype) = 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)?, EtherTypes::Ipv4)
}
(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)?, EtherTypes::Ipv6)
}
_ => return Err(PacketError::FamilyMismatch { src, dst }),
};
let frames = packets
.into_iter()
.map(|packet| {
let mut frame = Vec::with_capacity(ETH_HDR_LEN + packet.len());
frame.extend_from_slice(ðernet::build_header(src_mac, dst_mac, ethertype));
frame.extend_from_slice(&packet);
frame
})
.collect();
Ok(frames)
}
#[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 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: 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::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,
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 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.0;
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.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(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(),
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());
}
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,
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);
}
}