use super::*;
use crate::test_gens::*;
use alloc::{vec, vec::Vec};
use proptest::prelude::*;
#[derive(Clone, Debug, Eq, PartialEq)]
struct ComponentTest {
link: Option<LinkHeader>,
vlan: Option<VlanHeader>,
ip: Option<IpHeaders>,
transport: Option<TransportHeader>,
payload: Vec<u8>,
}
static VLAN_ETHER_TYPES: &'static [EtherType] = &[
EtherType::VLAN_TAGGED_FRAME,
EtherType::PROVIDER_BRIDGING,
EtherType::VLAN_DOUBLE_TAGGED_FRAME,
];
impl ComponentTest {
fn serialize(&self) -> Vec<u8> {
let mut buffer = Vec::<u8>::with_capacity(
match &self.link {
Some(header) => header.header_len(),
None => 0,
} + match &self.vlan {
Some(header) => header.header_len(),
None => 0,
} + match &self.ip {
Some(headers) => headers.header_len(),
None => 0,
} + match &self.transport {
Some(header) => header.header_len(),
None => 0,
} + self.payload.len(),
);
//fill all the elements
match &self.link {
Some(header) => header.write(&mut buffer).unwrap(),
None => {}
}
use crate::VlanHeader::*;
match &self.vlan {
Some(Single(header)) => header.write(&mut buffer).unwrap(),
Some(Double(header)) => header.write(&mut buffer).unwrap(),
None => {}
}
match &self.ip {
Some(IpHeaders::Ipv4(header, exts)) => {
header.write_raw(&mut buffer).unwrap();
exts.write(&mut buffer, header.protocol).unwrap();
}
Some(IpHeaders::Ipv6(header, exts)) => {
header.write(&mut buffer).unwrap();
exts.write(&mut buffer, header.next_header).unwrap();
}
None => {}
}
match &self.transport {
Some(TransportHeader::Icmpv6(header)) => header.write(&mut buffer).unwrap(),
Some(TransportHeader::Icmpv4(header)) => header.write(&mut buffer).unwrap(),
Some(TransportHeader::Udp(header)) => header.write(&mut buffer).unwrap(),
Some(TransportHeader::Tcp(header)) => header.write(&mut buffer).unwrap(),
None => {}
}
use std::io::Write;
buffer.write(&self.payload[..]).unwrap();
buffer
}
/// Serialize the headers & payload specified in the headers and check that
/// the different decoding & slicing methods for entire packets work correctly.
///
/// The following functions will be checked if they work correctly:
/// * `SlicedPacket::from_ethernet`
/// * `SlicedPacket::from_ip`
/// * `PacketHeaders::from_ethernet_slice`
/// * `PacketHeaders::from_ip_slice`
fn run(&self) {
// clone the test so the length fields can be adapted
let mut test = self.clone();
// set the payload length
if let Some(ip) = test.ip.as_mut() {
match ip {
IpHeaders::Ipv4(ipv4, exts) => {
ipv4.set_payload_len(
exts.header_len()
+ self.transport.as_ref().map_or(0, |t| t.header_len())
+ self.payload.len(),
)
.unwrap();
}
IpHeaders::Ipv6(ipv6, exts) => {
ipv6.set_payload_length(
exts.header_len()
+ self.transport.as_ref().map_or(0, |t| t.header_len())
+ self.payload.len(),
)
.unwrap();
}
}
}
if let Some(TransportHeader::Udp(udp)) = test.transport.as_mut() {
udp.length = udp.header_len_u16() + self.payload.len() as u16;
}
//packet with ethernet2 & vlan headers
{
//serialize to buffer
let buffer = test.serialize();
// PacketHeaders::from_ethernet_slice
test.assert_headers(PacketHeaders::from_ethernet_slice(&buffer).unwrap());
// SlicedPacket::from_ethernet
test.assert_sliced_packet(SlicedPacket::from_ethernet(&buffer).unwrap());
// create unexpected end of slice errors for the different headers
for len in test.invalid_ser_lengths() {
if let Some(len) = len {
assert!(PacketHeaders::from_ethernet_slice(&buffer[..len]).is_err());
assert!(SlicedPacket::from_ethernet(&buffer[..len]).is_err());
}
}
}
// packet data starting right after the link layer (tests from_ether_type functions)
{
// remove the link layer
let ether_down = {
let mut ether_down = test.clone();
ether_down.link = None;
ether_down
};
// serialize to buffer
let buffer = ether_down.serialize();
// PacketHeaders::from_ether_type
ether_down.assert_headers(
PacketHeaders::from_ether_type(
test.link.clone().unwrap().ethernet2().unwrap().ether_type,
&buffer[..],
)
.unwrap(),
);
// SlicedPacket::from_ether_type
ether_down.assert_sliced_packet(
SlicedPacket::from_ether_type(
test.link.clone().unwrap().ethernet2().unwrap().ether_type,
&buffer[..],
)
.unwrap(),
);
// create unexpected end of slice errors for the different headers
for len in ether_down.invalid_ser_lengths() {
if let Some(len) = len {
assert!(PacketHeaders::from_ether_type(
test.link.clone().unwrap().ethernet2().unwrap().ether_type,
&buffer[..len]
)
.is_err());
assert!(SlicedPacket::from_ether_type(
test.link.clone().unwrap().ethernet2().unwrap().ether_type,
&buffer[..len]
)
.is_err());
}
}
}
// packet from the internet layer down (without ethernet2 & vlan headers)
if test.ip.is_some() {
// serialize from the ip layer downwards
let ip_down = {
let mut ip_down = test.clone();
ip_down.link = None;
ip_down.vlan = None;
ip_down
};
// serialize to buffer
let buffer = ip_down.serialize();
// PacketHeaders::from_ip_slice
ip_down.assert_headers(PacketHeaders::from_ip_slice(&buffer).unwrap());
// SlicedPacket::from_ip
ip_down.assert_sliced_packet(SlicedPacket::from_ip(&buffer).unwrap());
// create unexpected end of slice errors for the different headers
for len in ip_down.invalid_ser_lengths() {
if let Some(len) = len {
assert!(PacketHeaders::from_ip_slice(&buffer[..len]).is_err());
assert!(SlicedPacket::from_ip(&buffer[..len]).is_err());
}
}
}
}
/// Creates slice lengths at which an too short slice error
/// should be triggered.
fn invalid_ser_lengths(&self) -> [Option<usize>; 12] {
struct Builder {
result: [Option<usize>; 12],
next_index: usize,
offset: usize,
}
impl Builder {
fn add(&mut self, header_len: usize) {
self.offset += header_len;
self.result[self.next_index] = Some(self.offset - 1);
self.next_index += 1;
}
}
let mut builder = Builder {
result: [None; 12],
next_index: 0,
offset: 0,
};
if let Some(link) = self.link.as_ref() {
builder.add(link.header_len());
}
if let Some(vlan) = self.vlan.as_ref() {
use VlanHeader::*;
match vlan {
Single(single) => builder.add(single.header_len()),
Double(double) => {
builder.add(double.outer.header_len());
builder.add(double.inner.header_len());
}
}
}
if let Some(ip) = self.ip.as_ref() {
use IpHeaders::*;
match ip {
Ipv4(header, exts) => {
builder.add(header.header_len());
if let Some(auth) = exts.auth.as_ref() {
builder.add(auth.header_len());
}
}
Ipv6(header, exts) => {
builder.add(header.header_len());
if let Some(e) = exts.hop_by_hop_options.as_ref() {
builder.add(e.header_len());
}
if let Some(e) = exts.destination_options.as_ref() {
builder.add(e.header_len());
}
if let Some(routing) = exts.routing.as_ref() {
builder.add(routing.routing.header_len());
if let Some(e) = routing.final_destination_options.as_ref() {
builder.add(e.header_len());
}
}
if let Some(e) = exts.fragment.as_ref() {
builder.add(e.header_len());
}
if let Some(e) = exts.auth.as_ref() {
builder.add(e.header_len());
}
}
}
}
if let Some(transport) = self.transport.as_ref() {
builder.add(transport.header_len());
}
builder.result
}
fn assert_headers(&self, actual: PacketHeaders) {
assert_eq!(self.link, actual.link);
assert_eq!(self.vlan, actual.vlan);
assert_eq!(self.ip, self.ip);
assert_eq!(self.transport, actual.transport);
assert_eq!(self.payload[..], actual.payload.slice()[..]);
}
fn assert_sliced_packet(&self, result: SlicedPacket) {
//assert identity to touch the derives (code coverage hack)
assert_eq!(result, result);
//ethernet & vlan
assert_eq!(
self.link,
match result.link.as_ref() {
Some(l) => match l {
LinkSlice::Ethernet2(e) => Some(LinkHeader::Ethernet2(e.to_header())),
LinkSlice::LinuxSll(e) => Some(LinkHeader::LinuxSll(e.to_header())),
LinkSlice::EtherPayload(_) => None,
LinkSlice::LinuxSllPayload(_) => None,
},
None => None,
}
); //.unwrap_or(None).map(|ref x| x.to_header()));
assert_eq!(self.vlan, result.vlan.as_ref().map(|ref x| x.to_header()));
//ip
assert_eq!(self.ip, {
use crate::NetSlice::*;
match result.net.as_ref() {
Some(Ipv4(actual)) => Some(IpHeaders::Ipv4(
actual.header().to_header(),
Ipv4Extensions {
auth: actual.extensions().auth.map(|ref x| x.to_header()),
},
)),
Some(Ipv6(actual)) => Some(IpHeaders::Ipv6(
actual.header().to_header(),
Ipv6Extensions::from_slice(
actual.header().next_header(),
actual.extensions().slice(),
)
.unwrap()
.0,
)),
None => None,
}
});
// transport header
assert_eq!(
self.transport,
match result.transport.as_ref() {
Some(TransportSlice::Icmpv4(actual)) =>
Some(TransportHeader::Icmpv4(actual.header())),
Some(TransportSlice::Icmpv6(actual)) =>
Some(TransportHeader::Icmpv6(actual.header())),
Some(TransportSlice::Udp(actual)) => Some(TransportHeader::Udp(actual.to_header())),
Some(TransportSlice::Tcp(actual)) => Some(TransportHeader::Tcp(actual.to_header())),
None => None,
}
);
// additional check for the contents of Unknown
if self.transport.is_none() {
match result.transport.as_ref() {
None => assert!(result.transport.is_none()),
_ => unreachable!(),
}
}
//payload
match result.transport.as_ref() {
Some(TransportSlice::Icmpv4(icmpv4)) => {
assert_eq!(&self.payload[..], icmpv4.payload());
}
Some(TransportSlice::Icmpv6(icmpv6)) => {
assert_eq!(&self.payload[..], icmpv6.payload());
}
Some(TransportSlice::Udp(udp)) => {
assert_eq!(&self.payload[..], udp.payload());
}
Some(TransportSlice::Tcp(tcp)) => {
assert_eq!(&self.payload[..], tcp.payload());
}
// check ip next
None => {
if let Some(ip) = result.net.as_ref() {
assert_eq!(
&self.payload[..],
match ip {
NetSlice::Ipv4(s) => s.payload.payload,
NetSlice::Ipv6(s) => s.payload.payload,
}
);
} else {
if let Some(vlan) = result.vlan.as_ref() {
assert_eq!(&self.payload[..], vlan.payload().payload);
} else {
if let Some(LinkSlice::Ethernet2(eth)) = result.link.as_ref() {
assert_eq!(&self.payload[..], eth.payload().payload);
}
}
}
}
}
}
fn run_vlan(
&self,
outer_vlan: &SingleVlanHeader,
inner_vlan: &SingleVlanHeader,
ipv4: &Ipv4Header,
ipv4_ext: &Ipv4Extensions,
ipv6: &Ipv6Header,
ipv6_ext: &Ipv6Extensions,
udp: &UdpHeader,
tcp: &TcpHeader,
icmpv4: &Icmpv4Header,
icmpv6: &Icmpv6Header,
) {
let setup_single = |ether_type: EtherType| -> ComponentTest {
let mut result = self.clone();
result.vlan = Some(VlanHeader::Single({
let mut v = inner_vlan.clone();
v.ether_type = ether_type;
v
}));
result
};
let setup_double =
|outer_ether_type: EtherType, inner_ether_type: EtherType| -> ComponentTest {
let mut result = self.clone();
result.vlan = Some(VlanHeader::Double(DoubleVlanHeader {
outer: {
let mut v = outer_vlan.clone();
v.ether_type = outer_ether_type;
v
},
inner: {
let mut v = inner_vlan.clone();
v.ether_type = inner_ether_type;
v
},
}));
result
};
//single
setup_single(inner_vlan.ether_type).run();
setup_single(ether_type::IPV4).run_ipv4(ipv4, ipv4_ext, udp, tcp, icmpv4, icmpv6);
setup_single(ether_type::IPV6).run_ipv6(ipv6, ipv6_ext, udp, tcp, icmpv4, icmpv6);
//double
for ether_type in VLAN_ETHER_TYPES {
setup_double(*ether_type, inner_vlan.ether_type).run();
setup_double(*ether_type, ether_type::IPV4)
.run_ipv4(ipv4, ipv4_ext, udp, tcp, icmpv4, icmpv6);
setup_double(*ether_type, ether_type::IPV6)
.run_ipv6(ipv6, ipv6_ext, udp, tcp, icmpv4, icmpv6);
}
}
fn run_ipv4(
&self,
ip: &Ipv4Header,
ip_exts: &Ipv4Extensions,
udp: &UdpHeader,
tcp: &TcpHeader,
icmpv4: &Icmpv4Header,
icmpv6: &Icmpv6Header,
) {
// fragmenting
{
let mut test = self.clone();
test.ip = Some({
let mut frag = ip.clone();
if false == frag.is_fragmenting_payload() {
frag.more_fragments = true;
}
let mut header = IpHeaders::Ipv4(frag, ip_exts.clone());
header.set_next_headers(ip.protocol);
header
});
// run without transport header
test.run();
}
// non fragmenting
{
let mut test = self.clone();
test.ip = Some({
let mut non_frag = ip.clone();
non_frag.more_fragments = false;
non_frag.fragment_offset = 0.try_into().unwrap();
let mut header = IpHeaders::Ipv4(non_frag, ip_exts.clone());
header.set_next_headers(ip.protocol);
header
});
test.run_transport(udp, tcp, icmpv4, icmpv6);
}
}
fn run_ipv6(
&self,
ip: &Ipv6Header,
ip_exts: &Ipv6Extensions,
udp: &UdpHeader,
tcp: &TcpHeader,
icmpv4: &Icmpv4Header,
icmpv6: &Icmpv6Header,
) {
// fragmenting
{
let mut test = self.clone();
test.ip = Some({
let mut frag = ip_exts.clone();
if let Some(frag) = frag.fragment.as_mut() {
if false == frag.is_fragmenting_payload() {
frag.more_fragments = true;
}
} else {
frag.fragment = Some(Ipv6FragmentHeader::new(
ip_number::UDP,
IpFragOffset::ZERO,
true,
0,
));
}
let mut header = IpHeaders::Ipv6(ip.clone(), frag);
header.set_next_headers(ip.next_header);
header
});
test.run();
}
// non fragmenting
{
let mut test = self.clone();
test.ip = Some({
let mut non_frag = ip_exts.clone();
non_frag.fragment = None;
let mut header = IpHeaders::Ipv6(ip.clone(), non_frag);
header.set_next_headers(ip.next_header);
header
});
test.run_transport(udp, tcp, icmpv4, icmpv6);
}
}
fn run_transport(
&self,
udp: &UdpHeader,
tcp: &TcpHeader,
icmpv4: &Icmpv4Header,
icmpv6: &Icmpv6Header,
) {
// unknown transport layer
self.run();
// udp
{
let mut test = self.clone();
test.ip.as_mut().unwrap().set_next_headers(ip_number::UDP);
test.transport = Some(TransportHeader::Udp(udp.clone()));
test.run()
}
// tcp
{
let mut test = self.clone();
test.ip.as_mut().unwrap().set_next_headers(ip_number::TCP);
test.transport = Some(TransportHeader::Tcp(tcp.clone()));
test.run()
}
// icmpv4
if let Some(payload_size) = icmpv4.fixed_payload_size() {
let mut test = self.clone();
test.ip.as_mut().unwrap().set_next_headers(ip_number::ICMP);
test.transport = Some(TransportHeader::Icmpv4(icmpv4.clone()));
// resize the payload in case it does not have to be as big
test.payload.resize(payload_size, 0);
test.run()
} else {
let mut test = self.clone();
test.ip.as_mut().unwrap().set_next_headers(ip_number::ICMP);
test.transport = Some(TransportHeader::Icmpv4(icmpv4.clone()));
test.run()
}
// icmpv6
if let Some(payload_size) = icmpv6.fixed_payload_size() {
let mut test = self.clone();
test.ip
.as_mut()
.unwrap()
.set_next_headers(ip_number::IPV6_ICMP);
test.transport = Some(TransportHeader::Icmpv6(icmpv6.clone()));
// resize the payload in case it does not have to be as big
test.payload.resize(payload_size, 0);
test.run()
} else {
let mut test = self.clone();
test.ip
.as_mut()
.unwrap()
.set_next_headers(ip_number::IPV6_ICMP);
test.transport = Some(TransportHeader::Icmpv6(icmpv6.clone()));
test.run()
}
}
}
proptest! {
///Test that all known packet compositions are parsed correctly.
#[test]
#[cfg_attr(miri, ignore)] // vec allocation reduces miri runspeed too much
fn test_compositions(ref eth in ethernet_2_unknown(),
ref vlan_outer in vlan_single_unknown(),
ref vlan_inner in vlan_single_unknown(),
ref ipv4 in ipv4_unknown(),
ref ipv4_exts in ipv4_extensions_unknown(),
ref ipv6 in ipv6_unknown(),
ref ipv6_exts in ipv6_extensions_unknown(),
ref udp in udp_any(),
ref tcp in tcp_any(),
ref icmpv4 in icmpv4_header_any(),
ref icmpv6 in icmpv6_header_any(),
ref payload in proptest::collection::vec(any::<u8>(), 0..1024))
{
let setup_eth = | ether_type: EtherType | -> ComponentTest {
ComponentTest {
payload: payload.clone(),
link: Some({
let mut result = eth.clone();
result.ether_type = ether_type;
LinkHeader::Ethernet2(result)
}),
vlan: None,
ip: None,
transport: None
}
};
//ethernet 2: standalone, ipv4, ipv6
setup_eth(eth.ether_type).run();
setup_eth(ether_type::IPV4).run_ipv4(ipv4, ipv4_exts, udp, tcp, icmpv4, icmpv6);
setup_eth(ether_type::IPV6).run_ipv6(ipv6, ipv6_exts, udp, tcp, icmpv4, icmpv6);
//vlans
for ether_type in VLAN_ETHER_TYPES {
setup_eth(*ether_type).run_vlan(vlan_outer, vlan_inner, ipv4, ipv4_exts, ipv6, ipv6_exts, udp, tcp, icmpv4, icmpv6);
}
}
}
///Test that assert_sliced_packet is panicking when the ethernet header is missing
#[test]
#[should_panic]
fn test_packet_slicing_panics() {
let s = SlicedPacket {
link: None,
vlan: None,
net: None,
transport: None,
};
ComponentTest {
link: Some(LinkHeader::Ethernet2(Ethernet2Header {
source: [0; 6],
destination: [0; 6],
ether_type: 0.into(),
})),
vlan: None,
ip: None,
transport: None,
payload: vec![],
}
.assert_sliced_packet(s);
}