use pnet_base::MacAddr;
use pnet_packet::Packet as _;
use pnet_packet::ethernet::EtherTypes;
use pnet_packet::icmpv6::Icmpv6Types;
use pnet_packet::icmpv6::ndp::NeighborAdvertPacket;
use pnet_packet::ip::IpNextHeaderProtocols;
use std::net::Ipv6Addr;
use crate::protocols::craft::{Ethernet, Field, Icmpv6, Ipv6, Packet};
use crate::protocols::ethernet::Frame;
use crate::protocols::ip;
const SOLICIT_BODY_LEN: usize = 16;
const OPTION_LEN: usize = 8;
const NEIGHBOR_SOLICIT: u8 = 135;
const ROUTER_SOLICIT: u8 = 133;
const ROUTER_FLAG: u8 = 0b1000_0000;
const ALL_ROUTERS: Ipv6Addr = Ipv6Addr::new(0xff02, 0, 0, 0, 0, 0, 0, 2);
const NDP_OPTION_SOURCE_LL_ADDR: u8 = 1;
const IPV6_MULTICAST_MAC_PREFIX: [u8; 2] = [0x33, 0x33];
pub fn solicited_node_multicast(target: Ipv6Addr) -> Ipv6Addr {
let octets = target.octets();
Ipv6Addr::new(
0xff02,
0,
0,
0,
0,
1,
u16::from_be_bytes([0xff, octets[13]]),
u16::from_be_bytes([octets[14], octets[15]]),
)
}
pub fn multicast_mac(group: Ipv6Addr) -> MacAddr {
let octets = group.octets();
MacAddr::new(
IPV6_MULTICAST_MAC_PREFIX[0],
IPV6_MULTICAST_MAC_PREFIX[1],
octets[12],
octets[13],
octets[14],
octets[15],
)
}
pub fn build_neighbor_solicitation(
src_mac: MacAddr,
src_addr: Ipv6Addr,
target: Ipv6Addr,
) -> Vec<u8> {
let group = solicited_node_multicast(target);
let mut body = Vec::with_capacity(SOLICIT_BODY_LEN + OPTION_LEN);
body.extend_from_slice(&target.octets());
body.push(NDP_OPTION_SOURCE_LL_ADDR);
body.push(1);
body.extend_from_slice(&src_mac.octets());
let message = Icmpv6 {
icmp_type: NEIGHBOR_SOLICIT,
code: 0,
checksum: Field::Computed,
rest_of_header: [0; 4],
payload: body,
};
Packet::new()
.push(Ethernet::new(src_mac, multicast_mac(group)).with_ethertype(EtherTypes::Ipv6))
.push(Ipv6::new(src_addr, group).with_hop_limit(ip::HOP_LIMIT_NDP))
.push(message)
.build()
.expect("a solicitation fits every length field it is counted by")
}
pub fn build_router_solicitation(src_mac: MacAddr, src_addr: Ipv6Addr) -> Vec<u8> {
let mut body = Vec::with_capacity(OPTION_LEN);
body.push(NDP_OPTION_SOURCE_LL_ADDR);
body.push(1);
body.extend_from_slice(&src_mac.octets());
let message = Icmpv6 {
icmp_type: ROUTER_SOLICIT,
code: 0,
checksum: Field::Computed,
rest_of_header: [0; 4],
payload: body,
};
Packet::new()
.push(Ethernet::new(src_mac, multicast_mac(ALL_ROUTERS)).with_ethertype(EtherTypes::Ipv6))
.push(Ipv6::new(src_addr, ALL_ROUTERS).with_hop_limit(ip::HOP_LIMIT_NDP))
.push(message)
.build()
.expect("a router solicitation fits every length field it is counted by")
}
#[non_exhaustive]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Advertisement {
pub target: Ipv6Addr,
pub router: bool,
}
pub fn advertisement(frame: &Frame<'_>) -> Option<Advertisement> {
advertisement_in(ipv6_payload(frame)?)
}
pub(crate) fn advertisement_in(packet: &[u8]) -> Option<Advertisement> {
let packet = icmpv6(packet)?;
let advert = NeighborAdvertPacket::new(packet.payload())?;
if advert.get_icmpv6_type() != Icmpv6Types::NeighborAdvert {
return None;
}
Some(Advertisement {
target: advert.get_target_addr(),
router: advert.get_flags() & ROUTER_FLAG != 0
&& packet.get_hop_limit() == ip::HOP_LIMIT_NDP,
})
}
pub fn is_router_advertisement(frame: &Frame<'_>) -> bool {
ipv6_payload(frame).is_some_and(is_router_advertisement_in)
}
pub(crate) fn is_router_advertisement_in(packet: &[u8]) -> bool {
let Some(packet) = icmpv6(packet) else {
return false;
};
packet
.payload()
.first()
.is_some_and(|icmp_type| *icmp_type == Icmpv6Types::RouterAdvert.0)
&& packet.get_hop_limit() == ip::HOP_LIMIT_NDP
}
fn ipv6_payload<'a>(frame: &Frame<'a>) -> Option<&'a [u8]> {
(frame.ethertype() == EtherTypes::Ipv6).then(|| frame.payload())
}
fn icmpv6(packet: &[u8]) -> Option<pnet_packet::ipv6::Ipv6Packet<'_>> {
if packet.first()? >> 4 != 6 {
return None;
}
let packet = pnet_packet::ipv6::Ipv6Packet::new(packet)?;
(packet.get_next_header() == IpNextHeaderProtocols::Icmpv6).then_some(packet)
}
#[cfg(test)]
mod tests {
use super::*;
use crate::protocols::ethernet;
use crate::protocols::sizes::ETH_HDR_LEN;
use pnet_packet::icmpv6::Icmpv6Type;
use pnet_packet::icmpv6::ndp::NdpOptionTypes;
use pnet_packet::icmpv6::ndp::{
MutableNeighborAdvertPacket, NeighborSolicitPacket, RouterSolicitPacket,
};
use pnet_packet::ipv6::Ipv6Packet;
const SRC_MAC: MacAddr = MacAddr(0x02, 0, 0, 0, 0, 0x01);
fn src_addr() -> Ipv6Addr {
Ipv6Addr::new(0xfe80, 0, 0, 0, 0, 0, 0, 0x50)
}
#[test]
fn the_solicited_node_group_is_the_prefix_plus_the_low_24_bits() {
let target = Ipv6Addr::new(0x4037, 0, 0, 0, 0x01, 0x800, 0x200e, 0x8c6c);
assert_eq!(
solicited_node_multicast(target),
Ipv6Addr::new(0xff02, 0, 0, 0, 0, 1, 0xff0e, 0x8c6c)
);
}
#[test]
fn addresses_sharing_their_low_24_bits_share_a_group() {
let a = Ipv6Addr::new(0xfe80, 0, 0, 0, 0, 0, 0x11aa, 0xbbcc);
let b = Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0x99aa, 0xbbcc);
assert_eq!(solicited_node_multicast(a), solicited_node_multicast(b));
}
#[test]
fn a_multicast_group_maps_onto_its_ethernet_address() {
let group = Ipv6Addr::new(0xff02, 0, 0, 0, 0, 1, 0xff0e, 0x8c6c);
assert_eq!(
multicast_mac(group),
MacAddr::new(0x33, 0x33, 0xff, 0x0e, 0x8c, 0x6c)
);
}
#[test]
fn a_solicitation_carries_the_hop_limit_the_rfc_requires() {
let target = Ipv6Addr::new(0xfe80, 0, 0, 0, 0, 0, 0, 0xAA);
let frame = build_neighbor_solicitation(SRC_MAC, src_addr(), target);
let eth = super::super::ethernet::parse(&frame).unwrap();
let packet = Ipv6Packet::new(eth.payload()).unwrap();
assert_eq!(packet.get_hop_limit(), 255);
}
#[test]
fn a_solicitation_is_addressed_to_the_targets_group() {
let target = Ipv6Addr::new(0xfe80, 0, 0, 0, 0, 0, 0x11aa, 0xbbcc);
let frame = build_neighbor_solicitation(SRC_MAC, src_addr(), target);
let eth = super::super::ethernet::parse(&frame).unwrap();
assert_eq!(
eth.destination(),
MacAddr::new(0x33, 0x33, 0xff, 0xaa, 0xbb, 0xcc)
);
let packet = Ipv6Packet::new(eth.payload()).unwrap();
assert_eq!(packet.get_destination(), solicited_node_multicast(target));
assert_eq!(packet.get_source(), src_addr());
}
#[test]
fn a_solicitation_names_its_target_and_offers_a_return_address() {
let target = Ipv6Addr::new(0xfe80, 0, 0, 0, 0, 0, 0, 0xAA);
let frame = build_neighbor_solicitation(SRC_MAC, src_addr(), target);
let eth = super::super::ethernet::parse(&frame).unwrap();
let packet = Ipv6Packet::new(eth.payload()).unwrap();
let solicit = NeighborSolicitPacket::new(packet.payload()).unwrap();
assert_eq!(solicit.get_icmpv6_type(), Icmpv6Types::NeighborSolicit);
assert_eq!(solicit.get_target_addr(), target);
let options = solicit.get_options();
assert_eq!(options.len(), 1);
assert_eq!(options[0].option_type, NdpOptionTypes::SourceLLAddr);
assert_eq!(options[0].data, SRC_MAC.octets().to_vec());
}
#[test]
fn a_solicitation_is_checksummed() {
let target = Ipv6Addr::new(0xfe80, 0, 0, 0, 0, 0, 0, 0xAA);
let frame = build_neighbor_solicitation(SRC_MAC, src_addr(), target);
let eth = super::super::ethernet::parse(&frame).unwrap();
let packet = Ipv6Packet::new(eth.payload()).unwrap();
let solicit = NeighborSolicitPacket::new(packet.payload()).unwrap();
assert_ne!(solicit.get_checksum(), 0);
}
fn advertisement_frame(target: Ipv6Addr, message_type: Icmpv6Type) -> Vec<u8> {
advertisement_frame_with(target, message_type, 0, ip::HOP_LIMIT_NDP)
}
fn advertisement_frame_with(
target: Ipv6Addr,
message_type: Icmpv6Type,
flags: u8,
hop_limit: u8,
) -> Vec<u8> {
let mut message = vec![0u8; 24];
{
let mut advert = MutableNeighborAdvertPacket::new(&mut message).unwrap();
advert.set_icmpv6_type(message_type);
advert.set_target_addr(target);
advert.set_flags(flags);
}
let eth = ethernet::build_header(SRC_MAC, SRC_MAC, EtherTypes::Ipv6);
let ipv6 = ip::build_ipv6_header(
target,
src_addr(),
message.len() as u16,
IpNextHeaderProtocols::Icmpv6,
hop_limit,
);
[eth, ipv6, message].concat()
}
#[test]
fn an_advertisement_yields_the_address_it_announces() {
let target = Ipv6Addr::new(0xfe80, 0, 0, 0, 0, 0, 0, 0xAA);
let frame = advertisement_frame(target, Icmpv6Types::NeighborAdvert);
let eth = super::super::ethernet::parse(&frame).unwrap();
assert_eq!(
advertisement(ð),
Some(Advertisement {
target,
router: false
})
);
}
#[test]
fn other_icmpv6_traffic_is_not_an_advertisement() {
let target = Ipv6Addr::new(0xfe80, 0, 0, 0, 0, 0, 0, 0xAA);
for message_type in [Icmpv6Types::NeighborSolicit, Icmpv6Types::EchoReply] {
let frame = advertisement_frame(target, message_type);
let eth = super::super::ethernet::parse(&frame).unwrap();
assert_eq!(advertisement(ð), None);
}
let arp = [0u8; ETH_HDR_LEN + 8];
let eth = super::super::ethernet::parse(&arp).unwrap();
assert_eq!(advertisement(ð), None);
}
#[test]
fn an_advertisement_carries_whether_its_sender_routes() {
let target = Ipv6Addr::new(0xfe80, 0, 0, 0, 0, 0, 0, 0xAA);
for (flags, routes) in [(ROUTER_FLAG, true), (0b0100_0000, false), (0, false)] {
let frame = advertisement_frame_with(
target,
Icmpv6Types::NeighborAdvert,
flags,
ip::HOP_LIMIT_NDP,
);
let eth = super::super::ethernet::parse(&frame).unwrap();
assert_eq!(
advertisement(ð).expect("an advertisement").router,
routes,
"flags {flags:#010b}"
);
}
}
#[test]
fn a_forwarded_advertisement_proves_presence_but_never_routing() {
let target = Ipv6Addr::new(0xfe80, 0, 0, 0, 0, 0, 0, 0xAA);
let frame = advertisement_frame_with(target, Icmpv6Types::NeighborAdvert, ROUTER_FLAG, 254);
let eth = super::super::ethernet::parse(&frame).unwrap();
assert_eq!(
advertisement(ð),
Some(Advertisement {
target,
router: false
})
);
}
#[test]
fn a_router_advertisement_is_recognised_only_from_the_segment() {
let target = Ipv6Addr::new(0xfe80, 0, 0, 0, 0, 0, 0, 0x01);
let from_the_segment =
advertisement_frame_with(target, Icmpv6Types::RouterAdvert, 0, ip::HOP_LIMIT_NDP);
assert!(is_router_advertisement(
&super::super::ethernet::parse(&from_the_segment).unwrap()
));
let forwarded = advertisement_frame_with(target, Icmpv6Types::RouterAdvert, 0, 254);
assert!(!is_router_advertisement(
&super::super::ethernet::parse(&forwarded).unwrap()
));
let neighbour = advertisement_frame(target, Icmpv6Types::NeighborAdvert);
assert!(!is_router_advertisement(
&super::super::ethernet::parse(&neighbour).unwrap()
));
}
#[test]
fn a_router_solicitation_asks_every_router_and_nobody_else() {
let frame = build_router_solicitation(SRC_MAC, src_addr());
let eth = super::super::ethernet::parse(&frame).unwrap();
assert_eq!(
eth.destination(),
MacAddr::new(0x33, 0x33, 0x00, 0x00, 0x00, 0x02)
);
let packet = Ipv6Packet::new(eth.payload()).unwrap();
assert_eq!(packet.get_destination(), ALL_ROUTERS);
assert_eq!(packet.get_hop_limit(), 255);
let solicit = RouterSolicitPacket::new(packet.payload()).unwrap();
assert_eq!(solicit.get_icmpv6_type(), Icmpv6Types::RouterSolicit);
assert_ne!(solicit.get_checksum(), 0);
let options = solicit.get_options();
assert_eq!(options.len(), 1);
assert_eq!(options[0].option_type, NdpOptionTypes::SourceLLAddr);
assert_eq!(options[0].data, SRC_MAC.octets().to_vec());
}
}