use std::net::{Ipv4Addr, Ipv6Addr};
use crate::protocols::craft;
use crate::protocols::error::{PacketError, Result};
use crate::protocols::ethernet::Frame;
use crate::protocols::sizes::{IP_V4_HDR_LEN, IP_V6_HDR_LEN, UDP_HDR_LEN};
use pnet_packet::Packet;
use pnet_packet::ethernet::EtherTypes;
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, MutableFragmentPacket};
const WORD_LEN: usize = 4;
const FRAGMENT_UNIT: usize = 8;
const FRAGMENT_HEADER_LEN: usize = 8;
pub const SMALLEST_FRAGMENT_MTU: u16 = (IP_V4_HDR_LEN + FRAGMENT_UNIT) as u16;
pub const SMALLEST_FRAGMENT_MTU_V6: u16 =
(IP_V6_HDR_LEN + FRAGMENT_HEADER_LEN + FRAGMENT_UNIT) as u16;
pub fn build_ipv4_header(
src_addr: Ipv4Addr,
dst_addr: Ipv4Addr,
payload_length: u16,
next_protocol: IpNextHeaderProtocol,
ttl: u8,
) -> Result<Vec<u8>> {
craft::Ipv4 {
protocol: craft::Field::Exact(next_protocol),
..craft::Ipv4::new(src_addr, dst_addr).with_ttl(ttl)
}
.header_bytes(payload_length)
}
pub fn fragment_ipv4(header: &craft::Ipv4, payload: &[u8], mtu: u16) -> Result<Vec<Vec<u8>>> {
if !header.options.is_empty() {
return Err(PacketError::HeaderHasOptions {
options: header.options.len(),
});
}
let header_len = IP_V4_HDR_LEN;
let mtu = mtu as usize;
if header_len + payload.len() > u16::MAX as usize {
return Err(PacketError::too_long(
"the IPv4 total length",
header_len,
payload.len(),
));
}
if header_len + payload.len() <= mtu {
let mut packet = header.header_bytes(payload.len() as u16)?;
packet.extend_from_slice(payload);
return Ok(vec![packet]);
}
let max_chunk = (mtu.saturating_sub(header_len) / FRAGMENT_UNIT) * FRAGMENT_UNIT;
if max_chunk == 0 {
return Err(PacketError::MtuTooSmall {
mtu,
minimum: SMALLEST_FRAGMENT_MTU as usize,
});
}
let identification = header.identification.exact().unwrap_or_else(rand::random);
let mut fragments = Vec::new();
let mut offset = 0;
while offset < payload.len() {
let chunk = &payload[offset..(offset + max_chunk).min(payload.len())];
let more_fragments = offset + chunk.len() < payload.len();
let piece = craft::Ipv4 {
identification: craft::Field::Exact(identification),
flags: if more_fragments {
craft::ipv4_flags::MORE_FRAGMENTS
} else {
0
},
fragment_offset: (offset / FRAGMENT_UNIT) as u16,
total_length: craft::Field::Computed,
checksum: craft::Field::Computed,
..header.clone()
};
let mut packet = piece.header_bytes(chunk.len() as u16)?;
packet.extend_from_slice(chunk);
fragments.push(packet);
offset += chunk.len();
}
Ok(fragments)
}
pub fn fragment_ipv6(header: &craft::Ipv6, payload: &[u8], mtu: u16) -> Result<Vec<Vec<u8>>> {
let mtu = mtu as usize;
if payload.len() > u16::MAX as usize {
return Err(PacketError::too_long(
"the IPv6 fragmentable payload",
IP_V6_HDR_LEN + FRAGMENT_HEADER_LEN,
payload.len(),
));
}
if IP_V6_HDR_LEN + payload.len() <= mtu {
let mut packet = header.header_bytes(payload.len() as u16);
packet.extend_from_slice(payload);
return Ok(vec![packet]);
}
let overhead = IP_V6_HDR_LEN + FRAGMENT_HEADER_LEN;
let max_chunk = (mtu.saturating_sub(overhead) / FRAGMENT_UNIT) * FRAGMENT_UNIT;
if max_chunk == 0 {
return Err(PacketError::MtuTooSmall {
mtu,
minimum: SMALLEST_FRAGMENT_MTU_V6 as usize,
});
}
let upper = header
.next_header
.exact()
.unwrap_or(IpNextHeaderProtocols::Tcp);
let identification: u32 = rand::random();
let base = craft::Ipv6 {
next_header: craft::Field::Exact(IpNextHeaderProtocols::Ipv6Frag),
payload_length: craft::Field::Computed,
..header.clone()
};
let mut fragments = Vec::new();
let mut offset = 0;
while offset < payload.len() {
let chunk = &payload[offset..(offset + max_chunk).min(payload.len())];
let more_fragments = offset + chunk.len() < payload.len();
let mut packet = base.header_bytes((FRAGMENT_HEADER_LEN + chunk.len()) as u16);
let mut extension = [0u8; FRAGMENT_HEADER_LEN];
{
let mut fragment = MutableFragmentPacket::new(&mut extension)
.expect("an eight-byte buffer holds a fragment header");
fragment.set_next_header(upper);
fragment.set_reserved(0);
let units = (offset / FRAGMENT_UNIT) as u16;
fragment.set_fragment_offset_with_flags((units << 3) | u16::from(more_fragments));
fragment.set_id(identification);
}
packet.extend_from_slice(&extension);
packet.extend_from_slice(chunk);
fragments.push(packet);
offset += chunk.len();
}
Ok(fragments)
}
pub const HOP_LIMIT_ON_LINK: u8 = 1;
pub const HOP_LIMIT_NDP: u8 = 255;
pub const HOP_LIMIT_ROUTED: u8 = 64;
pub fn build_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: &Frame<'_>) -> Result<Ipv6Addr> {
Ok(ipv6_packet(frame)?.get_source())
}
pub fn ipv6_destination(frame: &Frame<'_>) -> Result<Ipv6Addr> {
Ok(ipv6_packet(frame)?.get_destination())
}
fn ipv6_packet<'a>(frame: &Frame<'a>) -> Result<Ipv6Packet<'a>> {
Ipv6Packet::new(frame.payload()).ok_or_else(|| {
PacketError::truncated("an IPv6 packet", IP_V6_HDR_LEN, frame.payload().len())
})
}
pub(crate) fn ipv6_carrying<'a>(
frame: &Frame<'a>,
protocol: IpNextHeaderProtocol,
) -> Option<Ipv6Packet<'a>> {
if frame.ethertype() != EtherTypes::Ipv6 {
return None;
}
let packet = Ipv6Packet::new(frame.payload())?;
(packet.get_next_header() == protocol).then_some(packet)
}
pub fn icmpv6_type(frame: &Frame<'_>) -> Option<Icmpv6Type> {
let packet = ipv6_carrying(frame, IpNextHeaderProtocols::Icmpv6)?;
Some(Icmpv6Packet::new(packet.payload())?.get_icmpv6_type())
}
pub fn icmpv6_echo_token(frame: &Frame<'_>) -> Option<(u16, u16)> {
let packet = ipv6_carrying(frame, IpNextHeaderProtocols::Icmpv6)?;
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: &Frame<'a>, port: u16) -> Option<&'a [u8]> {
let packet = frame.payload();
let (header_len, next) = match frame.ethertype() {
EtherTypes::Ipv6 => (IP_V6_HDR_LEN, Ipv6Packet::new(packet)?.get_next_header()),
EtherTypes::Ipv4 => {
let ipv4 = Ipv4Packet::new(packet)?;
if !carries_a_whole_datagram(&ipv4) {
return None;
}
(
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..)
}
fn carries_a_whole_datagram(packet: &Ipv4Packet<'_>) -> bool {
packet.get_header_length() >= (IP_V4_HDR_LEN / WORD_LEN) as u8
&& packet.get_fragment_offset() == 0
}
pub fn ipv4_source(frame: &Frame<'_>) -> 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;
use proptest::prelude::*;
const V4: Ipv4Addr = Ipv4Addr::new(192, 0, 2, 1);
const V6: Ipv6Addr = Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 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 = build_ipv4_header(
V4,
V4,
largest as u16,
IpNextHeaderProtocols::Tcp,
HOP_LIMIT_ROUTED,
)
.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 = build_ipv4_header(
V4,
V4,
oversize as u16,
IpNextHeaderProtocols::Tcp,
HOP_LIMIT_ROUTED,
);
assert!(
matches!(refused, Err(PacketError::TooLong { .. })),
"a payload of {oversize} produced {refused:?}"
);
}
}
fn read(bytes: &[u8]) -> Frame<'_> {
crate::protocols::ethernet::parse(bytes).expect("a frame")
}
fn frame_of(ethertype: u16, payload: &[u8]) -> Vec<u8> {
let mut bytes = vec![0u8; 12];
bytes.extend_from_slice(ðertype.to_be_bytes());
bytes.extend_from_slice(payload);
bytes
}
fn ipv4_packet(ihl: u8, fragment_offset: u16, protocol: u8, body: &[u8]) -> Vec<u8> {
let mut ip = vec![0u8; IP_V4_HDR_LEN];
ip[0] = (4 << 4) | ihl;
ip[2..4].copy_from_slice(&((IP_V4_HDR_LEN + body.len()) as u16).to_be_bytes());
ip[6..8].copy_from_slice(&fragment_offset.to_be_bytes());
ip[9] = protocol;
ip.extend_from_slice(body);
ip
}
fn udp_datagram(source_port: u16, payload: &[u8]) -> Vec<u8> {
let mut udp = vec![0u8; UDP_HDR_LEN];
udp[0..2].copy_from_slice(&source_port.to_be_bytes());
udp[4..6].copy_from_slice(&((UDP_HDR_LEN + payload.len()) as u16).to_be_bytes());
udp.extend_from_slice(payload);
udp
}
#[test]
fn a_whole_datagram_from_the_right_port_yields_its_payload() {
let bytes = frame_of(
EtherTypes::Ipv4.0,
&ipv4_packet(5, 0, 17, &udp_datagram(5353, b"the payload")),
);
let frame = read(&bytes);
assert_eq!(udp_payload(&frame, 5353), Some(&b"the payload"[..]));
assert_eq!(udp_payload(&frame, 53), None, "another port's datagram");
}
#[test]
fn a_fragment_carries_no_datagram_and_is_declined() {
let body = udp_datagram(5353, b"the payload");
let first = frame_of(EtherTypes::Ipv4.0, &ipv4_packet(5, 0, 17, &body));
assert!(
udp_payload(&read(&first), 5353).is_some(),
"the first fragment does carry a header"
);
for offset in [1, 2, 0x1FFF] {
let later = frame_of(EtherTypes::Ipv4.0, &ipv4_packet(5, offset, 17, &body));
assert_eq!(
udp_payload(&read(&later), 5353),
None,
"a fragment at offset {} was read as a datagram",
offset * 8
);
}
}
#[test]
fn a_header_length_below_the_minimum_is_declined() {
let mut packet = ipv4_packet(0, 0, 17, b"not a datagram at all");
packet[0] = 0x00;
packet[1] = 0x35;
assert_eq!(
u16::from_be_bytes([packet[0], packet[1]]),
53,
"the probe does not reach the header-length check it is about"
);
let bytes = frame_of(EtherTypes::Ipv4.0, &packet);
assert_eq!(udp_payload(&read(&bytes), 53), None);
let honest = frame_of(
EtherTypes::Ipv4.0,
&ipv4_packet(5, 0, 17, &udp_datagram(53, b"a datagram")),
);
assert_eq!(udp_payload(&read(&honest), 53), Some(&b"a datagram"[..]));
}
#[test]
fn a_frame_of_another_ethertype_carries_no_icmpv6() {
let mut packet = vec![0u8; IP_V6_HDR_LEN];
packet[4..6].copy_from_slice(&8u16.to_be_bytes()); packet[6] = IpNextHeaderProtocols::Icmpv6.0;
packet.extend_from_slice(&[128, 0, 0, 0, 0, 0, 0, 0]);
let honest = frame_of(EtherTypes::Ipv6.0, &packet);
assert_eq!(
icmpv6_type(&read(&honest)).map(|kind| kind.0),
Some(128),
"an IPv6 frame is still read"
);
for ethertype in [EtherTypes::Arp.0, EtherTypes::Ipv4.0, 0x88CC] {
let bytes = frame_of(ethertype, &packet);
assert_eq!(
icmpv6_type(&read(&bytes)),
None,
"ethertype {ethertype:#06x} was read as IPv6"
);
assert_eq!(icmpv6_echo_token(&read(&bytes)), None);
}
}
#[test]
fn an_address_is_read_from_the_header_that_carries_it() {
let v4 = frame_of(EtherTypes::Ipv4.0, &{
let mut packet = ipv4_packet(5, 0, 17, &[]);
packet[12..16].copy_from_slice(&V4.octets());
packet
});
assert_eq!(ipv4_source(&read(&v4)).expect("a source"), V4);
let source = Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 1);
let destination = Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 9);
let v6 = frame_of(EtherTypes::Ipv6.0, &{
let mut packet = vec![0u8; IP_V6_HDR_LEN];
packet[8..24].copy_from_slice(&source.octets());
packet[24..40].copy_from_slice(&destination.octets());
packet
});
assert_eq!(ipv6_source(&read(&v6)).expect("a source"), source);
assert_eq!(
ipv6_destination(&read(&v6)).expect("a destination"),
destination
);
for cut in 0..IP_V4_HDR_LEN {
let short = frame_of(EtherTypes::Ipv4.0, &vec![0u8; cut]);
assert!(
matches!(
ipv4_source(&read(&short)),
Err(PacketError::Truncated { .. })
),
"a {cut}-byte header credited somebody"
);
}
}
fn parse(fragment: &[u8]) -> (u16, bool, bool, Vec<u8>) {
let packet = Ipv4Packet::new(fragment).expect("a fragment parses");
let flags = packet.get_flags();
(
packet.get_fragment_offset(),
flags & craft::ipv4_flags::MORE_FRAGMENTS != 0,
flags & craft::ipv4_flags::DONT_FRAGMENT != 0,
packet.payload().to_vec(),
)
}
#[test]
fn offsets_and_flags_march_across_three_fragments() {
let mtu = 48;
let payload: Vec<u8> = (0..60u8).collect();
let fragments = fragment_ipv4(&craft::Ipv4::new(V4, V4), &payload, mtu).expect("fragments");
assert_eq!(fragments.len(), 3);
let parsed: Vec<_> = fragments.iter().map(|f| parse(f)).collect();
assert_eq!(
[parsed[0].0, parsed[1].0, parsed[2].0],
[0, 3, 6],
"offsets count eight-byte units: 0, 24/8, 48/8"
);
assert_eq!(
[parsed[0].1, parsed[1].1, parsed[2].1],
[true, true, false],
"more-fragments follows every piece but the last"
);
for fragment in &parsed {
assert!(!fragment.2, "don't-fragment is cleared on every fragment");
}
}
#[test]
fn every_non_last_piece_is_whole_units_and_within_the_mtu() {
let mtu = 45;
let payload = vec![0xA5u8; 100];
let fragments = fragment_ipv4(&craft::Ipv4::new(V4, V4), &payload, mtu).expect("fragments");
assert_eq!(fragments.len(), 5);
for (i, fragment) in fragments.iter().enumerate() {
assert!(
fragment.len() <= mtu as usize,
"fragment {i} is {} bytes, over the {mtu}-byte MTU",
fragment.len()
);
let (_, more_fragments, _, body) = parse(fragment);
if more_fragments {
assert_eq!(
body.len() % FRAGMENT_UNIT,
0,
"a non-last fragment is whole units"
);
}
}
}
#[test]
fn a_datagram_that_fits_is_returned_whole() {
let payload = vec![0xABu8; 100];
let fragments =
fragment_ipv4(&craft::Ipv4::new(V4, V4), &payload, 1500).expect("one packet");
assert_eq!(fragments.len(), 1);
let (offset, more_fragments, dont_fragment, body) = parse(&fragments[0]);
assert_eq!(offset, 0);
assert!(!more_fragments, "nothing follows a whole datagram");
assert!(dont_fragment, "the caller's don't-fragment is untouched");
assert_eq!(body, payload, "and the payload arrives intact");
}
#[test]
fn every_fragment_shares_one_identification() {
let payload = vec![0u8; 200];
let fragments = fragment_ipv4(&craft::Ipv4::new(V4, V4), &payload, 60).expect("fragments");
assert!(fragments.len() >= 2, "the payload must actually split");
let ids: Vec<u16> = fragments
.iter()
.map(|f| Ipv4Packet::new(f).expect("parses").get_identification())
.collect();
assert!(
ids.iter().all(|id| *id == ids[0]),
"one identification for the datagram, got {ids:?}"
);
}
#[test]
fn an_mtu_with_no_room_to_progress_is_refused() {
let payload = vec![0u8; 40];
let refused = fragment_ipv4(&craft::Ipv4::new(V4, V4), &payload, 27);
assert!(
matches!(refused, Err(PacketError::MtuTooSmall { .. })),
"got {refused:?}"
);
fragment_ipv4(&craft::Ipv4::new(V4, V4), &payload, 28)
.expect("28 bytes is one unit of room");
}
#[test]
fn a_datagram_too_large_for_the_length_field_is_refused() {
let largest = u16::MAX as usize - IP_V4_HDR_LEN;
fragment_ipv4(&craft::Ipv4::new(V4, V4), &vec![0u8; largest], 1500)
.expect("the largest describable datagram still fragments");
let refused = fragment_ipv4(&craft::Ipv4::new(V4, V4), &vec![0u8; largest + 1], 1500);
assert!(
matches!(refused, Err(PacketError::TooLong { .. })),
"got {refused:?}"
);
}
#[test]
fn a_header_with_options_is_refused() {
let with_options = craft::Ipv4 {
options: vec![0x01, 0x01, 0x01, 0x00],
..craft::Ipv4::new(V4, V4)
};
let refused = fragment_ipv4(&with_options, &vec![0u8; 4000], 1500);
assert!(
matches!(refused, Err(PacketError::HeaderHasOptions { .. })),
"got {refused:?}"
);
}
proptest! {
#[test]
fn fragments_reassemble_into_the_original_datagram(
payload in prop::collection::vec(any::<u8>(), 0..4096usize),
mtu in 28u16..=1500,
) {
let fragments = fragment_ipv4(&craft::Ipv4::new(V4, V4), &payload, mtu)
.expect("a workable MTU fragments");
let split = fragments.len() > 1;
let mut reassembled = Vec::new();
for (i, fragment) in fragments.iter().enumerate() {
prop_assert!(fragment.len() <= mtu as usize);
let packet = Ipv4Packet::new(fragment).expect("a fragment parses");
let last = i + 1 == fragments.len();
let flags = packet.get_flags();
prop_assert_eq!(
flags & craft::ipv4_flags::MORE_FRAGMENTS != 0,
!last,
"more-fragments is set on every piece but the last"
);
if split {
prop_assert_eq!(flags & craft::ipv4_flags::DONT_FRAGMENT, 0);
}
let body = packet.payload();
if !last {
prop_assert_eq!(body.len() % FRAGMENT_UNIT, 0, "a non-last fragment is whole units");
}
prop_assert_eq!(
packet.get_fragment_offset() as usize * FRAGMENT_UNIT,
reassembled.len()
);
reassembled.extend_from_slice(body);
}
prop_assert_eq!(reassembled, payload);
}
}
fn parse_v6(fragment: &[u8]) -> (u16, bool, IpNextHeaderProtocol, Vec<u8>) {
use pnet_packet::ipv6::FragmentPacket;
let packet = Ipv6Packet::new(fragment).expect("a v6 fragment parses");
assert_eq!(
packet.get_next_header(),
IpNextHeaderProtocols::Ipv6Frag,
"a fragment's base header points at the fragment extension"
);
let extension = FragmentPacket::new(packet.payload()).expect("a fragment header");
let offset_with_flags = extension.get_fragment_offset_with_flags();
(
offset_with_flags >> 3,
offset_with_flags & 1 != 0,
extension.get_next_header(),
packet.payload()[FRAGMENT_HEADER_LEN..].to_vec(),
)
}
#[test]
fn offsets_and_flags_march_across_three_fragments_v6() {
let mtu = (IP_V6_HDR_LEN + FRAGMENT_HEADER_LEN + 24) as u16;
let payload: Vec<u8> = (0..60u8).collect();
let header = craft::Ipv6 {
next_header: craft::Field::Exact(IpNextHeaderProtocols::Udp),
..craft::Ipv6::new(V6, V6)
};
let fragments = fragment_ipv6(&header, &payload, mtu).expect("fragments");
assert_eq!(fragments.len(), 3);
let parsed: Vec<_> = fragments.iter().map(|f| parse_v6(f)).collect();
assert_eq!(
[parsed[0].0, parsed[1].0, parsed[2].0],
[0, 3, 6],
"offsets count eight-byte units: 0, 24/8, 48/8"
);
assert_eq!(
[parsed[0].1, parsed[1].1, parsed[2].1],
[true, true, false],
"more-fragments follows every piece but the last"
);
for fragment in &parsed {
assert_eq!(
fragment.2,
IpNextHeaderProtocols::Udp,
"each fragment header carries the protocol the base header gave up"
);
}
}
#[test]
fn a_datagram_that_fits_is_returned_whole_v6() {
let payload = vec![0xABu8; 100];
let header = craft::Ipv6 {
next_header: craft::Field::Exact(IpNextHeaderProtocols::Tcp),
..craft::Ipv6::new(V6, V6)
};
let fragments = fragment_ipv6(&header, &payload, 1500).expect("one packet");
assert_eq!(fragments.len(), 1);
let packet = Ipv6Packet::new(&fragments[0]).expect("parses");
assert_eq!(
packet.get_next_header(),
IpNextHeaderProtocols::Tcp,
"an unfragmented datagram carries no fragment header"
);
assert_eq!(packet.payload(), payload, "and the payload arrives intact");
}
#[test]
fn every_fragment_shares_one_identification_v6() {
use pnet_packet::ipv6::FragmentPacket;
let payload = vec![0u8; 200];
let fragments = fragment_ipv6(&craft::Ipv6::new(V6, V6), &payload, 96).expect("fragments");
assert!(fragments.len() >= 2, "the payload must actually split");
let ids: Vec<u32> = fragments
.iter()
.map(|f| {
let packet = Ipv6Packet::new(f).expect("parses");
FragmentPacket::new(packet.payload())
.expect("a fragment header")
.get_id()
})
.collect();
assert!(
ids.iter().all(|id| *id == ids[0]),
"one identification for the datagram, got {ids:?}"
);
}
#[test]
fn an_mtu_with_no_room_to_progress_is_refused_v6() {
let payload = vec![0u8; 40];
let floor = SMALLEST_FRAGMENT_MTU_V6;
let refused = fragment_ipv6(&craft::Ipv6::new(V6, V6), &payload, floor - 1);
assert!(
matches!(refused, Err(PacketError::MtuTooSmall { .. })),
"got {refused:?}"
);
fragment_ipv6(&craft::Ipv6::new(V6, V6), &payload, floor)
.expect("the floor is one unit of room");
}
#[test]
fn a_payload_too_large_for_the_offset_field_is_refused_v6() {
let largest = u16::MAX as usize;
fragment_ipv6(&craft::Ipv6::new(V6, V6), &vec![0u8; largest], 1500)
.expect("the largest addressable payload still fragments");
let refused = fragment_ipv6(&craft::Ipv6::new(V6, V6), &vec![0u8; largest + 1], 1500);
assert!(
matches!(refused, Err(PacketError::TooLong { .. })),
"got {refused:?}"
);
}
proptest! {
#[test]
fn fragments_reassemble_into_the_original_datagram_v6(
payload in prop::collection::vec(any::<u8>(), 0..4096usize),
mtu in (SMALLEST_FRAGMENT_MTU_V6)..=1500,
) {
let fragments = fragment_ipv6(&craft::Ipv6::new(V6, V6), &payload, mtu)
.expect("a workable MTU fragments");
let split = fragments.len() > 1;
let mut reassembled = Vec::new();
for (i, fragment) in fragments.iter().enumerate() {
prop_assert!(fragment.len() <= mtu as usize);
let last = i + 1 == fragments.len();
if !split {
let packet = Ipv6Packet::new(fragment).expect("parses");
reassembled.extend_from_slice(packet.payload());
continue;
}
let (offset, more_fragments, _, body) = parse_v6(fragment);
prop_assert_eq!(more_fragments, !last, "more-fragments is set on every piece but the last");
if !last {
prop_assert_eq!(body.len() % FRAGMENT_UNIT, 0, "a non-last fragment is whole units");
}
prop_assert_eq!(
offset as usize * FRAGMENT_UNIT,
reassembled.len(),
"the offset counts the bytes before this piece"
);
reassembled.extend_from_slice(&body);
}
prop_assert_eq!(reassembled, payload);
}
}
#[test]
fn every_fragment_fits_its_mtu_and_the_pieces_reassemble() {
let v4_header = craft::Ipv4::new(
"192.0.2.1".parse().expect("literal"),
"192.0.2.2".parse().expect("literal"),
);
let v6_header = craft::Ipv6::new(
"2001:db8::1".parse().expect("literal"),
"2001:db8::2".parse().expect("literal"),
);
let mtus = [
0u16, 1, 7, 8, 20, 21, 27, 28, 39, 40, 47, 48, 55, 56, 64, 1280, 1500,
];
let sizes = [0usize, 1, 7, 8, 9, 63, 64, 1000, 1500, 9000];
for mtu in mtus {
for size in sizes {
let payload: Vec<u8> = (0..size).map(|byte| (byte % 251) as u8).collect();
if let Ok(fragments) = fragment_ipv4(&v4_header, &payload, mtu) {
let mut rebuilt = Vec::new();
for fragment in &fragments {
if fragments.len() > 1 {
assert!(
fragment.len() <= mtu as usize,
"an IPv4 fragment of {} bytes does not fit an MTU of {mtu}",
fragment.len()
);
}
rebuilt.extend_from_slice(&fragment[IP_V4_HDR_LEN..]);
}
assert_eq!(
rebuilt, payload,
"IPv4 mtu={mtu} size={size} did not reassemble"
);
}
if let Ok(fragments) = fragment_ipv6(&v6_header, &payload, mtu) {
let carries_header =
fragments.len() > 1 || fragments[0].len() > IP_V6_HDR_LEN + size;
let skip = match carries_header {
true => IP_V6_HDR_LEN + FRAGMENT_HEADER_LEN,
false => IP_V6_HDR_LEN,
};
let mut rebuilt = Vec::new();
for fragment in &fragments {
if fragments.len() > 1 {
assert!(
fragment.len() <= mtu as usize,
"an IPv6 fragment of {} bytes does not fit an MTU of {mtu}",
fragment.len()
);
}
rebuilt.extend_from_slice(&fragment[skip..]);
}
assert_eq!(
rebuilt, payload,
"IPv6 mtu={mtu} size={size} did not reassemble"
);
}
}
}
}
}