use std::net::{Ipv4Addr, Ipv6Addr};
use crate::protocols::craft;
use crate::protocols::error::{PacketError, Result};
use crate::protocols::sizes::{IP_V4_HDR_LEN, IP_V6_HDR_LEN, UDP_HDR_LEN};
use pnet::packet::Packet;
use pnet::packet::ethernet::{EtherTypes, EthernetPacket};
use pnet::packet::icmpv6::echo_reply::EchoReplyPacket;
use pnet::packet::icmpv6::{Icmpv6Packet, Icmpv6Type, Icmpv6Types};
use pnet::packet::ip::{IpNextHeaderProtocol, IpNextHeaderProtocols};
use pnet::packet::ipv4::Ipv4Packet;
use pnet::packet::ipv6::Ipv6Packet;
const WORD_LEN: usize = 4;
pub fn create_ipv4_header(
src_addr: Ipv4Addr,
dst_addr: Ipv4Addr,
payload_length: u16,
next_protocol: IpNextHeaderProtocol,
) -> Result<Vec<u8>> {
craft::Ipv4 {
protocol: craft::Field::Exact(next_protocol),
..craft::Ipv4::new(src_addr, dst_addr)
}
.header_bytes(payload_length)
}
pub const HOP_LIMIT_ON_LINK: u8 = 1;
pub const HOP_LIMIT_NDP: u8 = 255;
pub const HOP_LIMIT_ROUTED: u8 = 64;
pub fn create_ipv6_header(
src_addr: Ipv6Addr,
dst_addr: Ipv6Addr,
payload_length: u16,
next_protocol: IpNextHeaderProtocol,
hop_limit: u8,
) -> Vec<u8> {
craft::Ipv6 {
next_header: craft::Field::Exact(next_protocol),
..craft::Ipv6::new(src_addr, dst_addr).with_hop_limit(hop_limit)
}
.header_bytes(payload_length)
}
pub fn ipv6_source(frame: &EthernetPacket) -> Result<Ipv6Addr> {
Ok(ipv6_packet(frame)?.get_source())
}
pub fn ipv6_destination(frame: &EthernetPacket) -> Result<Ipv6Addr> {
Ok(ipv6_packet(frame)?.get_destination())
}
fn ipv6_packet<'a>(frame: &'a EthernetPacket<'a>) -> Result<Ipv6Packet<'a>> {
Ipv6Packet::new(frame.payload()).ok_or_else(|| {
PacketError::truncated("an IPv6 packet", IP_V6_HDR_LEN, frame.payload().len())
})
}
pub fn icmpv6_type(frame: &EthernetPacket) -> Option<Icmpv6Type> {
let packet = Ipv6Packet::new(frame.payload())?;
if packet.get_next_header() != IpNextHeaderProtocols::Icmpv6 {
return None;
}
Some(Icmpv6Packet::new(packet.payload())?.get_icmpv6_type())
}
pub fn icmpv6_echo_token(frame: &EthernetPacket) -> Option<(u16, u16)> {
let packet = Ipv6Packet::new(frame.payload())?;
if packet.get_next_header() != IpNextHeaderProtocols::Icmpv6 {
return None;
}
let reply = EchoReplyPacket::new(packet.payload())?;
if reply.get_icmpv6_type() != Icmpv6Types::EchoReply {
return None;
}
Some((reply.get_identifier(), reply.get_sequence_number()))
}
pub fn udp_payload<'a>(frame: &'a EthernetPacket<'a>, port: u16) -> Option<&'a [u8]> {
let packet = frame.payload();
let (header_len, next) = match frame.get_ethertype() {
EtherTypes::Ipv6 => (IP_V6_HDR_LEN, Ipv6Packet::new(packet)?.get_next_header()),
EtherTypes::Ipv4 => {
let ipv4 = Ipv4Packet::new(packet)?;
(
ipv4.get_header_length() as usize * WORD_LEN,
ipv4.get_next_level_protocol(),
)
}
_ => return None,
};
if next != IpNextHeaderProtocols::Udp {
return None;
}
let datagram = packet.get(header_len..)?;
let source = u16::from_be_bytes([*datagram.first()?, *datagram.get(1)?]);
if source != port {
return None;
}
datagram.get(UDP_HDR_LEN..)
}
pub fn ipv4_source(frame: &EthernetPacket) -> Result<Ipv4Addr> {
let ipv4_packet = Ipv4Packet::new(frame.payload()).ok_or_else(|| {
PacketError::truncated("an IPv4 packet", IP_V4_HDR_LEN, frame.payload().len())
})?;
Ok(ipv4_packet.get_source())
}
#[cfg(test)]
mod tests {
use super::*;
use pnet::packet::ip::IpNextHeaderProtocols;
const V4: Ipv4Addr = Ipv4Addr::new(192, 0, 2, 1);
#[test]
fn a_payload_too_large_for_the_length_field_is_refused_rather_than_wrapped() {
let largest = u16::MAX as usize - IP_V4_HDR_LEN;
let header = create_ipv4_header(V4, V4, largest as u16, IpNextHeaderProtocols::Tcp)
.expect("the largest describable payload");
assert_eq!(
Ipv4Packet::new(&header).expect("parses").get_total_length(),
u16::MAX
);
for oversize in [largest + 1, u16::MAX as usize] {
let refused = create_ipv4_header(V4, V4, oversize as u16, IpNextHeaderProtocols::Tcp);
assert!(
matches!(refused, Err(PacketError::TooLong { .. })),
"a payload of {oversize} produced {refused:?}"
);
}
}
}