use pnet::datalink::MacAddr;
use pnet::packet::Packet as _;
use pnet::packet::ethernet::{EtherTypes, EthernetPacket};
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::ip;
const SOLICIT_BODY_LEN: usize = 16;
const OPTION_LEN: usize = 8;
const NEIGHBOR_SOLICIT: u8 = 135;
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 create_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 advertised_target(frame: &EthernetPacket) -> Option<Ipv6Addr> {
if frame.get_ethertype() != EtherTypes::Ipv6 {
return None;
}
let packet = pnet::packet::ipv6::Ipv6Packet::new(frame.payload())?;
if packet.get_next_header() != IpNextHeaderProtocols::Icmpv6 {
return None;
}
let advert = NeighborAdvertPacket::new(packet.payload())?;
if advert.get_icmpv6_type() != Icmpv6Types::NeighborAdvert {
return None;
}
Some(advert.get_target_addr())
}
#[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};
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 = create_neighbor_solicitation(&SRC_MAC, &src_addr(), target);
let eth = EthernetPacket::new(&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 = create_neighbor_solicitation(&SRC_MAC, &src_addr(), target);
let eth = EthernetPacket::new(&frame).unwrap();
assert_eq!(
eth.get_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 = create_neighbor_solicitation(&SRC_MAC, &src_addr(), target);
let eth = EthernetPacket::new(&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 = create_neighbor_solicitation(&SRC_MAC, &src_addr(), target);
let eth = EthernetPacket::new(&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> {
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);
}
let eth = ethernet::create_header(SRC_MAC, SRC_MAC, EtherTypes::Ipv6);
let ipv6 = ip::create_ipv6_header(
target,
src_addr(),
message.len() as u16,
IpNextHeaderProtocols::Icmpv6,
ip::HOP_LIMIT_NDP,
);
[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 = EthernetPacket::new(&frame).unwrap();
assert_eq!(advertised_target(ð), Some(target));
}
#[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 = EthernetPacket::new(&frame).unwrap();
assert_eq!(advertised_target(ð), None);
}
let arp = [0u8; ETH_HDR_LEN + 8];
let eth = EthernetPacket::new(&arp).unwrap();
assert_eq!(advertised_target(ð), None);
}
}