use pnet::packet::icmp::destination_unreachable::{DestinationUnreachablePacket, IcmpCodes};
use pnet::packet::icmp::{IcmpCode, IcmpPacket, IcmpTypes};
use pnet::packet::icmpv6::{Icmpv6Code, Icmpv6Packet, Icmpv6Types};
use pnet::packet::ip::IpNextHeaderProtocols;
use crate::transport::capture::CapturedSegment;
use crate::transport::frame::{self, IpSegment};
pub(super) const ICMPV6_PORT_UNREACHABLE: Icmpv6Code = Icmpv6Code(4);
pub(super) const ICMPV6_ADMIN_PROHIBITED: Icmpv6Code = Icmpv6Code(1);
pub(super) const ICMPV6_INGRESS_EGRESS_POLICY: Icmpv6Code = Icmpv6Code(5);
pub(super) const ICMPV6_REJECT_ROUTE: Icmpv6Code = Icmpv6Code(6);
pub(super) const ICMPV6_NO_ROUTE: Icmpv6Code = Icmpv6Code(0);
pub(super) const ICMPV6_ADDR_UNREACHABLE: Icmpv6Code = Icmpv6Code(3);
pub(super) const ICMPV6_UNUSED_LEN: usize = 4;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Unreachable {
Port,
Prohibited,
Host,
}
#[derive(Debug, Clone, Copy)]
pub struct IcmpError<'a> {
pub reason: Unreachable,
pub quoted: IpSegment<'a>,
}
pub fn parse(reply: &CapturedSegment) -> Option<IcmpError<'_>> {
match reply.protocol {
IpNextHeaderProtocols::Icmp => parse_v4(&reply.bytes),
IpNextHeaderProtocols::Icmpv6 => parse_v6(&reply.bytes),
_ => None,
}
}
#[derive(Debug, Clone, Copy)]
pub struct Expired<'a> {
pub quoted: IpSegment<'a>,
}
pub fn parse_expired(reply: &CapturedSegment) -> Option<Expired<'_>> {
let quoted_at = match reply.protocol {
IpNextHeaderProtocols::Icmp => {
let message = IcmpPacket::new(&reply.bytes)?;
if message.get_icmp_type() != IcmpTypes::TimeExceeded {
return None;
}
TIME_EXCEEDED_HEADER_LEN
}
IpNextHeaderProtocols::Icmpv6 => {
let message = Icmpv6Packet::new(&reply.bytes)?;
if message.get_icmpv6_type() != Icmpv6Types::TimeExceeded {
return None;
}
Icmpv6Packet::minimum_packet_size() + ICMPV6_UNUSED_LEN
}
_ => return None,
};
Some(Expired {
quoted: frame::parse_ip_segment(reply.bytes.get(quoted_at..)?)?,
})
}
const TIME_EXCEEDED_HEADER_LEN: usize = 8;
fn parse_v4(bytes: &[u8]) -> Option<IcmpError<'_>> {
let unreachable = DestinationUnreachablePacket::new(bytes)?;
if unreachable.get_icmp_type() != IcmpTypes::DestinationUnreachable {
return None;
}
let quoted_at = DestinationUnreachablePacket::minimum_packet_size();
Some(IcmpError {
reason: reason_v4(unreachable.get_icmp_code())?,
quoted: frame::parse_ip_segment(bytes.get(quoted_at..)?)?,
})
}
fn parse_v6(bytes: &[u8]) -> Option<IcmpError<'_>> {
let unreachable = Icmpv6Packet::new(bytes)?;
if unreachable.get_icmpv6_type() != Icmpv6Types::DestinationUnreachable {
return None;
}
let quoted_at = Icmpv6Packet::minimum_packet_size() + ICMPV6_UNUSED_LEN;
Some(IcmpError {
reason: reason_v6(unreachable.get_icmpv6_code())?,
quoted: frame::parse_ip_segment(bytes.get(quoted_at..)?)?,
})
}
fn reason_v4(code: IcmpCode) -> Option<Unreachable> {
match code {
IcmpCodes::DestinationPortUnreachable => Some(Unreachable::Port),
IcmpCodes::DestinationProtocolUnreachable
| IcmpCodes::NetworkAdministrativelyProhibited
| IcmpCodes::HostAdministrativelyProhibited
| IcmpCodes::CommunicationAdministrativelyProhibited => Some(Unreachable::Prohibited),
IcmpCodes::DestinationHostUnreachable => Some(Unreachable::Host),
_ => None,
}
}
fn reason_v6(code: Icmpv6Code) -> Option<Unreachable> {
match code {
ICMPV6_PORT_UNREACHABLE => Some(Unreachable::Port),
ICMPV6_ADMIN_PROHIBITED | ICMPV6_INGRESS_EGRESS_POLICY | ICMPV6_REJECT_ROUTE => {
Some(Unreachable::Prohibited)
}
ICMPV6_NO_ROUTE | ICMPV6_ADDR_UNREACHABLE => Some(Unreachable::Host),
_ => None,
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
use pnet::packet::icmp::destination_unreachable::MutableDestinationUnreachablePacket;
use pnet::packet::icmpv6::MutableIcmpv6Packet;
use crate::protocols::{ip, udp};
const LOCAL_V4: IpAddr = IpAddr::V4(Ipv4Addr::new(192, 168, 1, 50));
const TARGET_V4: IpAddr = IpAddr::V4(Ipv4Addr::new(192, 168, 1, 200));
const LOCAL_V6: IpAddr = IpAddr::V6(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 50));
const TARGET_V6: IpAddr = IpAddr::V6(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 200));
fn quoted_packet(from: IpAddr, to: IpAddr) -> Vec<u8> {
let datagram = udp::create_packet(&from, &to, 50_000, 53, vec![]).unwrap();
let len = datagram.len() as u16;
let header = match (from, to) {
(IpAddr::V4(s), IpAddr::V4(d)) => {
ip::create_ipv4_header(s, d, len, IpNextHeaderProtocols::Udp, ip::HOP_LIMIT_ROUTED)
.unwrap()
}
(IpAddr::V6(s), IpAddr::V6(d)) => {
ip::create_ipv6_header(s, d, len, IpNextHeaderProtocols::Udp, ip::HOP_LIMIT_ROUTED)
}
_ => panic!("IP version mismatch in test fixture"),
};
header.into_iter().chain(datagram).collect()
}
fn expired_v4(router: IpAddr, target: IpAddr) -> CapturedSegment {
let quoted = quoted_packet(LOCAL_V4, target);
let mut bytes = vec![0u8; TIME_EXCEEDED_HEADER_LEN + quoted.len()];
bytes[0] = IcmpTypes::TimeExceeded.0;
bytes[TIME_EXCEEDED_HEADER_LEN..].copy_from_slice("ed);
CapturedSegment::synthetic(router, IpNextHeaderProtocols::Icmp, bytes)
}
fn expired_v6(router: IpAddr, target: IpAddr) -> CapturedSegment {
let quoted = quoted_packet(LOCAL_V6, target);
let mut payload = vec![0u8; ICMPV6_UNUSED_LEN];
payload.extend_from_slice("ed);
let mut bytes = vec![0u8; Icmpv6Packet::minimum_packet_size() + payload.len()];
let mut packet = MutableIcmpv6Packet::new(&mut bytes).unwrap();
packet.set_icmpv6_type(Icmpv6Types::TimeExceeded);
packet.set_payload(&payload);
CapturedSegment::synthetic(router, IpNextHeaderProtocols::Icmpv6, bytes)
}
#[test]
fn an_expiry_names_the_router_that_discarded_it_and_the_probe_it_discarded() {
for (reply, target) in [
(expired_v4(TARGET_V4, TARGET_V4), TARGET_V4),
(expired_v6(TARGET_V6, TARGET_V6), TARGET_V6),
] {
let expired = parse_expired(&reply).expect("a Time Exceeded parses");
assert_eq!(
expired.quoted.destination, target,
"the probe's destination"
);
assert_eq!(
expired.quoted.source,
if target.is_ipv4() { LOCAL_V4 } else { LOCAL_V6 },
"the probe left from this host"
);
}
}
#[test]
fn an_unreachable_is_not_an_expiry_and_an_expiry_is_not_an_unreachable() {
let unreachable = error_v4(IcmpCodes::DestinationPortUnreachable);
assert!(parse(&unreachable).is_some());
assert!(parse_expired(&unreachable).is_none());
let expired = expired_v4(TARGET_V4, TARGET_V4);
assert!(parse_expired(&expired).is_some());
assert!(parse(&expired).is_none());
}
fn error_v4(code: IcmpCode) -> CapturedSegment {
let quoted = quoted_packet(LOCAL_V4, TARGET_V4);
let mut bytes =
vec![0u8; DestinationUnreachablePacket::minimum_packet_size() + quoted.len()];
let mut packet = MutableDestinationUnreachablePacket::new(&mut bytes).unwrap();
packet.set_icmp_type(IcmpTypes::DestinationUnreachable);
packet.set_icmp_code(code);
packet.set_payload("ed);
CapturedSegment::synthetic(TARGET_V4, IpNextHeaderProtocols::Icmp, bytes)
}
fn error_v6(code: Icmpv6Code) -> CapturedSegment {
let quoted = quoted_packet(LOCAL_V6, TARGET_V6);
let mut payload = vec![0u8; ICMPV6_UNUSED_LEN];
payload.extend_from_slice("ed);
let mut bytes = vec![0u8; Icmpv6Packet::minimum_packet_size() + payload.len()];
let mut packet = MutableIcmpv6Packet::new(&mut bytes).unwrap();
packet.set_icmpv6_type(Icmpv6Types::DestinationUnreachable);
packet.set_icmpv6_code(code);
packet.set_payload(&payload);
CapturedSegment::synthetic(TARGET_V6, IpNextHeaderProtocols::Icmpv6, bytes)
}
fn reason_of(reply: &CapturedSegment) -> Unreachable {
parse(reply).expect("the message parses").reason
}
#[test]
fn the_quoted_packet_names_the_probe_rather_than_the_sender() {
let reply = error_v4(IcmpCodes::DestinationPortUnreachable);
let error = parse(&reply).expect("parses");
assert_eq!(error.quoted.destination, TARGET_V4);
assert_eq!(error.quoted.protocol, IpNextHeaderProtocols::Udp);
}
#[test]
fn the_same_code_number_means_different_things_per_family() {
let (as_v4, as_v6) = (error_v4(IcmpCode(3)), error_v6(Icmpv6Code(3)));
assert_eq!(reason_of(&as_v4), Unreachable::Port);
assert_eq!(reason_of(&as_v6), Unreachable::Host);
assert_eq!(
reason_of(&error_v6(ICMPV6_PORT_UNREACHABLE)),
Unreachable::Port
);
}
#[test]
fn administrative_refusals_are_recognized_in_both_families() {
assert_eq!(
reason_of(&error_v4(
IcmpCodes::CommunicationAdministrativelyProhibited
)),
Unreachable::Prohibited
);
for code in [
ICMPV6_ADMIN_PROHIBITED,
ICMPV6_INGRESS_EGRESS_POLICY,
ICMPV6_REJECT_ROUTE,
] {
assert_eq!(reason_of(&error_v6(code)), Unreachable::Prohibited);
}
}
#[test]
fn an_uninformative_code_is_not_parsed_into_a_verdict() {
assert!(parse(&error_v4(IcmpCode(4))).is_none());
assert!(parse(&error_v6(Icmpv6Code(2))).is_none());
}
#[test]
fn another_icmp_message_is_not_an_error() {
let mut reply = error_v4(IcmpCodes::DestinationPortUnreachable);
MutableDestinationUnreachablePacket::new(&mut reply.bytes)
.unwrap()
.set_icmp_type(IcmpTypes::EchoReply);
assert!(parse(&reply).is_none());
}
#[test]
fn a_truncated_quotation_resolves_nothing() {
let mut error = error_v4(IcmpCodes::DestinationPortUnreachable);
error
.bytes
.truncate(DestinationUnreachablePacket::minimum_packet_size() + 4);
assert!(parse(&error).is_none());
}
}