use crate::model::mac::MacAddr;
use crate::protocols::craft::{Arp, Ethernet, Packet};
use crate::protocols::error::{PacketError, Result};
use crate::protocols::ethernet::Frame;
use crate::protocols::sizes::{ARP_LEN, MIN_ETH_FRAME_NO_FCS};
use pnet_packet::arp::ArpPacket;
use pnet_packet::ethernet::EtherTypes;
use std::net::Ipv4Addr;
const PROTO_ADDR_LEN_V4: u8 = 4;
pub fn build_request(src_mac: MacAddr, src_addr: Ipv4Addr, dst_addr: Ipv4Addr) -> Vec<u8> {
frame(
src_mac,
MacAddr::BROADCAST,
Arp::request(src_mac, src_addr, dst_addr),
)
}
pub fn build_unicast_request(
src_mac: MacAddr,
dst_mac: MacAddr,
src_addr: Ipv4Addr,
dst_addr: Ipv4Addr,
) -> Vec<u8> {
let request = Arp::request(src_mac, src_addr, dst_addr).with_target_hw_addr(dst_mac);
frame(src_mac, dst_mac, request)
}
fn frame(src_mac: MacAddr, dst_mac: MacAddr, packet: Arp) -> Vec<u8> {
let mut bytes = Packet::new()
.push(Ethernet::new(src_mac, dst_mac))
.push(packet)
.build()
.expect("an ARP frame has no length field to overflow");
bytes.resize(MIN_ETH_FRAME_NO_FCS, 0u8);
bytes
}
pub fn sender_address(frame: &Frame<'_>) -> Result<Ipv4Addr> {
let arp = ArpPacket::new(frame.payload())
.ok_or_else(|| PacketError::truncated("an ARP packet", ARP_LEN, frame.payload().len()))?;
if arp.get_protocol_type() != EtherTypes::Ipv4 || arp.get_proto_addr_len() != PROTO_ADDR_LEN_V4
{
return Err(PacketError::unreadable(
"an ARP packet",
format_args!(
"it carries protocol {:#06x} in {}-byte addresses, not IPv4 in {PROTO_ADDR_LEN_V4}",
arp.get_protocol_type().0,
arp.get_proto_addr_len()
),
));
}
Ok(arp.get_sender_proto_addr())
}
#[cfg(test)]
mod tests {
use super::*;
use crate::model::mac::MacAddr;
use crate::protocols::mac::{IntoCoreMac, IntoPnetMac};
use crate::protocols::sizes::ETH_HDR_LEN;
use pnet_packet::arp::ArpHardwareTypes;
use pnet_packet::arp::{ArpOperations, MutableArpPacket};
use pnet_packet::ethernet::MutableEthernetPacket;
use std::net::IpAddr;
fn build_mock_arp_packet(sender_ip: Ipv4Addr, payload_size: usize) -> Vec<u8> {
let mut eth_buffer = vec![0u8; ETH_HDR_LEN];
{
let mut eth_pkt = MutableEthernetPacket::new(&mut eth_buffer).unwrap();
eth_pkt.set_destination(MacAddr::BROADCAST.into_pnet());
eth_pkt.set_source(MacAddr::new(0x01, 0x02, 0x03, 0x04, 0x05, 0x06).into_pnet());
eth_pkt.set_ethertype(EtherTypes::Arp);
}
let mut arp_buffer = vec![0u8; payload_size];
if payload_size >= ARP_LEN {
let mut arp_pkt = MutableArpPacket::new(&mut arp_buffer[..ARP_LEN]).unwrap();
arp_pkt.set_hardware_type(ArpHardwareTypes::Ethernet);
arp_pkt.set_protocol_type(EtherTypes::Ipv4);
arp_pkt.set_hw_addr_len(6);
arp_pkt.set_proto_addr_len(4);
arp_pkt.set_operation(ArpOperations::Reply);
arp_pkt
.set_sender_hw_addr(MacAddr::new(0x01, 0x02, 0x03, 0x04, 0x05, 0x06).into_pnet());
arp_pkt.set_sender_proto_addr(sender_ip);
arp_pkt.set_target_hw_addr(MacAddr::ZERO.into_pnet());
arp_pkt.set_target_proto_addr(Ipv4Addr::new(192, 0, 2, 1));
}
[eth_buffer, arp_buffer].concat()
}
#[test]
fn a_broadcast_request_asks_the_segment_and_names_nobody() {
let src_mac = MacAddr::new(0x01, 0x02, 0x03, 0x04, 0x05, 0x06);
let src_addr = Ipv4Addr::new(192, 0, 2, 10);
let dst_addr = Ipv4Addr::new(192, 0, 2, 1);
let buffer = build_request(src_mac, src_addr, dst_addr);
assert_eq!(buffer.len(), MIN_ETH_FRAME_NO_FCS);
let eth_packet =
super::super::ethernet::parse(&buffer).expect("Failed to parse Ethernet packet");
assert_eq!(eth_packet.destination(), MacAddr::BROADCAST);
assert_eq!(eth_packet.source(), src_mac);
assert_eq!(eth_packet.ethertype(), EtherTypes::Arp.0);
let arp_payload = eth_packet.payload();
assert!(arp_payload.len() >= ARP_LEN);
let arp_packet = ArpPacket::new(arp_payload).expect("Failed to parse ARP packet");
assert_eq!(arp_packet.get_operation(), ArpOperations::Request);
assert_eq!(arp_packet.get_hardware_type(), ArpHardwareTypes::Ethernet);
assert_eq!(arp_packet.get_protocol_type(), EtherTypes::Ipv4);
assert_eq!(arp_packet.get_hw_addr_len(), 6);
assert_eq!(arp_packet.get_proto_addr_len(), 4);
assert_eq!(arp_packet.get_sender_hw_addr().into_core(), src_mac);
assert_eq!(arp_packet.get_sender_proto_addr(), src_addr);
assert_eq!(
arp_packet.get_target_hw_addr().into_core(),
MacAddr::ZERO,
"undefined in a request, and zero is what every ordinary stack sends"
);
assert_eq!(arp_packet.get_target_proto_addr(), dst_addr);
}
#[test]
fn a_unicast_request_reaches_one_host_and_a_broadcast_one_reaches_all() {
let src_mac = MacAddr::new(0x01, 0x02, 0x03, 0x04, 0x05, 0x06);
let dst_mac = MacAddr::new(0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF);
let src_addr = Ipv4Addr::new(192, 0, 2, 10);
let dst_addr = Ipv4Addr::new(192, 0, 2, 1);
let unicast = build_unicast_request(src_mac, dst_mac, src_addr, dst_addr);
let eth = super::super::ethernet::parse(&unicast).expect("a frame");
assert_eq!(eth.destination(), dst_mac, "only that host's card wakes");
let arp = ArpPacket::new(eth.payload()).expect("an ARP packet");
assert_eq!(arp.get_operation(), ArpOperations::Request);
assert_eq!(
arp.get_target_hw_addr().into_core(),
dst_mac,
"the entry being validated is named, so a host that moved is visible"
);
assert_eq!(arp.get_target_proto_addr(), dst_addr);
}
#[test]
fn a_well_formed_frame_is_credited_to_its_sender() {
let expected = Ipv4Addr::new(192, 0, 2, 123);
let buffer = build_mock_arp_packet(expected, ARP_LEN);
let parsed = super::super::ethernet::parse(&buffer).expect("a frame");
assert_eq!(
crate::protocols::source_address(&parsed).expect("an ARP sender"),
IpAddr::V4(expected)
);
}
#[test]
fn a_truncated_frame_credits_nobody() {
let buffer = build_mock_arp_packet(Ipv4Addr::UNSPECIFIED, 10);
let parsed = super::super::ethernet::parse(&buffer).expect("a frame");
assert!(matches!(
crate::protocols::source_address(&parsed),
Err(PacketError::Truncated { got: 10, .. })
));
}
#[test]
fn an_arp_packet_about_another_protocol_credits_nobody() {
let mut buffer = build_mock_arp_packet(Ipv4Addr::new(198, 51, 100, 1), ARP_LEN);
{
let mut arp = MutableArpPacket::new(&mut buffer[ETH_HDR_LEN..]).expect("an ARP packet");
arp.set_protocol_type(EtherTypes::Ipv6);
arp.set_proto_addr_len(16);
}
let parsed = super::super::ethernet::parse(&buffer).expect("a frame");
assert!(matches!(
crate::protocols::source_address(&parsed),
Err(PacketError::Unreadable { .. })
));
let honest = build_mock_arp_packet(Ipv4Addr::new(198, 51, 100, 1), ARP_LEN);
let parsed = super::super::ethernet::parse(&honest).expect("a frame");
assert_eq!(
crate::protocols::source_address(&parsed).expect("an ARP sender"),
IpAddr::V4(Ipv4Addr::new(198, 51, 100, 1))
);
}
#[test]
fn a_frame_of_another_kind_is_reported_as_unread_rather_than_broken() {
let mut buffer = build_mock_arp_packet(Ipv4Addr::UNSPECIFIED, 20);
MutableEthernetPacket::new(&mut buffer)
.expect("a frame")
.set_ethertype(EtherTypes::Ipv4);
let parsed = super::super::ethernet::parse(&buffer).expect("a frame");
assert!(crate::protocols::source_address(&parsed).is_ok());
MutableEthernetPacket::new(&mut buffer)
.expect("a frame")
.set_ethertype(pnet_packet::ethernet::EtherType(0x88cc));
let parsed = super::super::ethernet::parse(&buffer).expect("a frame");
assert!(matches!(
crate::protocols::source_address(&parsed),
Err(PacketError::UnsupportedEtherType(0x88cc))
));
}
}