use std::net::IpAddr;
use anyhow::Context;
use pnet::packet::ethernet::{EtherType, EtherTypes};
use pnet::packet::ip::IpNextHeaderProtocol;
use pnet::packet::ipv4::Ipv4Packet;
use pnet::packet::ipv6::Ipv6Packet;
use pnet::util::MacAddr;
use crate::protocols::ethernet;
use crate::protocols::ip;
use crate::protocols::utils::{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;
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,
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct IpSegment<'a> {
pub source: IpAddr,
pub destination: IpAddr,
pub protocol: IpNextHeaderProtocol,
pub payload: &'a [u8],
}
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..)?,
})
}
6 => {
let packet = Ipv6Packet::new(ip_bytes)?;
Some(IpSegment {
source: IpAddr::V6(packet.get_source()),
destination: IpAddr::V6(packet.get_destination()),
protocol: packet.get_next_header(),
payload: ip_bytes.get(IP_V6_HDR_LEN..)?,
})
}
_ => 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)?,
),
_ => 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::make_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,
)
.unwrap();
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 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 unsupported_link_yields_nothing() {
let frame = [0u8; 32];
assert!(parse_captured_segment(LinkType::Unsupported(42), &frame).is_none());
}
}