use pnet::datalink::MacAddr;
use pnet::packet::Packet as _;
use pnet::packet::ethernet::{EtherTypes, EthernetPacket};
use pnet::packet::ip::IpNextHeaderProtocols;
use pnet::packet::ipv4::Ipv4Packet;
use pnet::packet::udp::UdpPacket;
use std::net::Ipv4Addr;
use crate::protocols::craft::{Ethernet, Ipv4, Packet, Udp};
use crate::protocols::ip;
pub const CLIENT_PORT: u16 = 68;
pub const SERVER_PORT: u16 = 67;
const BOOTREQUEST: u8 = 1;
const BOOTREPLY: u8 = 2;
const HTYPE_ETHERNET: u8 = 1;
const HLEN_ETHERNET: u8 = 6;
const BOOTP_FIXED_LEN: usize = 236;
const MAGIC_COOKIE: [u8; 4] = [99, 130, 83, 99];
const MIN_MESSAGE_LEN: usize = 300;
const OPT_PAD: u8 = 0;
const OPT_MESSAGE_TYPE: u8 = 53;
const OPT_SERVER_ID: u8 = 54;
const OPT_PARAMETER_REQUEST: u8 = 55;
const OPT_END: u8 = 255;
const DHCPOFFER: u8 = 2;
const DHCPACK: u8 = 5;
const DHCPNAK: u8 = 6;
const DHCPINFORM: u8 = 8;
const REQUESTED_PARAMETERS: [u8; 4] = [
1, 3, 6, 15, ];
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct ServerReply {
pub server: Option<Ipv4Addr>,
}
pub fn create_inform(src_mac: &MacAddr, src_addr: &Ipv4Addr) -> Vec<u8> {
let mut message = Vec::with_capacity(MIN_MESSAGE_LEN);
let mac = src_mac.octets();
message.push(BOOTREQUEST);
message.push(HTYPE_ETHERNET);
message.push(HLEN_ETHERNET);
message.push(0); message.extend_from_slice(&transaction_id(src_mac).to_be_bytes());
message.extend_from_slice(&0u16.to_be_bytes()); message.extend_from_slice(&0u16.to_be_bytes()); message.extend_from_slice(&src_addr.octets()); message.extend_from_slice(&[0; 4]); message.extend_from_slice(&[0; 4]); message.extend_from_slice(&[0; 4]); message.extend_from_slice(&mac);
message.extend_from_slice(&[0; 10]); message.extend_from_slice(&[0; 64]); message.extend_from_slice(&[0; 128]); debug_assert_eq!(message.len(), BOOTP_FIXED_LEN);
message.extend_from_slice(&MAGIC_COOKIE);
message.extend_from_slice(&[OPT_MESSAGE_TYPE, 1, DHCPINFORM]);
message.push(OPT_PARAMETER_REQUEST);
message.push(REQUESTED_PARAMETERS.len() as u8);
message.extend_from_slice(&REQUESTED_PARAMETERS);
message.push(OPT_END);
message.resize(message.len().max(MIN_MESSAGE_LEN), OPT_PAD);
Packet::new()
.push(Ethernet::new(*src_mac, MacAddr::broadcast()).with_ethertype(EtherTypes::Ipv4))
.push(Ipv4::new(*src_addr, Ipv4Addr::BROADCAST).with_ttl(ip::HOP_LIMIT_ON_LINK))
.push(Udp::new(CLIENT_PORT, SERVER_PORT).with_payload(message))
.build()
.expect("an inform fits every length field it is counted by")
}
pub fn server_reply(frame: &EthernetPacket) -> Option<ServerReply> {
if frame.get_ethertype() != EtherTypes::Ipv4 {
return None;
}
let packet = Ipv4Packet::new(frame.payload())?;
if packet.get_next_level_protocol() != IpNextHeaderProtocols::Udp {
return None;
}
let datagram = UdpPacket::new(packet.payload())?;
if datagram.get_source() != SERVER_PORT {
return None;
}
let message = datagram.payload();
if message.first() != Some(&BOOTREPLY) {
return None;
}
if message.get(BOOTP_FIXED_LEN..BOOTP_FIXED_LEN + MAGIC_COOKIE.len()) != Some(&MAGIC_COOKIE) {
return None;
}
let mut kind = None;
let mut server = None;
for (code, value) in options(&message[BOOTP_FIXED_LEN + MAGIC_COOKIE.len()..]) {
match code {
OPT_MESSAGE_TYPE => kind = value.first().copied(),
OPT_SERVER_ID => server = ipv4(value),
_ => {}
}
}
matches!(kind, Some(DHCPOFFER | DHCPACK | DHCPNAK)).then_some(ServerReply { server })
}
fn options(bytes: &[u8]) -> impl Iterator<Item = (u8, &[u8])> {
let mut rest = bytes;
std::iter::from_fn(move || {
loop {
let (&code, tail) = rest.split_first()?;
match code {
OPT_END => return None,
OPT_PAD => rest = tail,
_ => {
let (&len, tail) = tail.split_first()?;
let value = tail.get(..len as usize)?;
rest = &tail[len as usize..];
return Some((code, value));
}
}
}
})
}
fn ipv4(value: &[u8]) -> Option<Ipv4Addr> {
let octets: [u8; 4] = value.try_into().ok()?;
Some(Ipv4Addr::from(octets))
}
fn transaction_id(mac: &MacAddr) -> u32 {
let [_, _, a, b, c, d] = mac.octets();
u32::from_be_bytes([a, b, c, d])
}
#[cfg(test)]
mod tests {
use super::*;
use crate::protocols::ethernet;
const SRC_MAC: MacAddr = MacAddr(0x02, 0x00, 0x11, 0x22, 0x33, 0x44);
const SERVER_MAC: MacAddr = MacAddr(0x02, 0x00, 0x00, 0x00, 0x00, 0x01);
fn src_addr() -> Ipv4Addr {
Ipv4Addr::new(192, 168, 1, 50)
}
fn server_addr() -> Ipv4Addr {
Ipv4Addr::new(192, 168, 1, 1)
}
fn reply_frame(message_type: u8, server_id: Option<Ipv4Addr>) -> Vec<u8> {
let mut message = vec![0u8; BOOTP_FIXED_LEN];
message[0] = BOOTREPLY;
message.extend_from_slice(&MAGIC_COOKIE);
message.extend_from_slice(&[OPT_MESSAGE_TYPE, 1, message_type]);
if let Some(id) = server_id {
message.push(OPT_SERVER_ID);
message.push(4);
message.extend_from_slice(&id.octets());
}
message.push(OPT_END);
udp_frame(SERVER_PORT, CLIENT_PORT, message)
}
fn udp_frame(source_port: u16, destination_port: u16, message: Vec<u8>) -> Vec<u8> {
let datagram = Packet::new()
.push(Ipv4::new(server_addr(), src_addr()))
.push(Udp::new(source_port, destination_port).with_payload(message))
.build()
.expect("a test datagram");
[
ethernet::create_header(SERVER_MAC, SRC_MAC, EtherTypes::Ipv4),
datagram,
]
.concat()
}
#[test]
fn an_inform_is_broadcast_and_asks_for_nothing_it_would_have_to_be_given() {
let bytes = create_inform(&SRC_MAC, &src_addr());
let frame = EthernetPacket::new(&bytes).expect("an ethernet frame");
assert_eq!(frame.get_destination(), MacAddr::broadcast());
assert_eq!(frame.get_ethertype(), EtherTypes::Ipv4);
let packet = Ipv4Packet::new(frame.payload()).expect("an ipv4 packet");
assert_eq!(packet.get_destination(), Ipv4Addr::BROADCAST);
assert_eq!(packet.get_source(), src_addr());
let datagram = UdpPacket::new(packet.payload()).expect("a datagram");
assert_eq!(datagram.get_source(), CLIENT_PORT);
assert_eq!(datagram.get_destination(), SERVER_PORT);
assert_ne!(datagram.get_checksum(), 0);
let message = datagram.payload();
assert_eq!(message[0], BOOTREQUEST);
assert_eq!(
&message[12..16],
&src_addr().octets(),
"ciaddr is what makes this an inform, and where the answer goes"
);
assert_eq!(
&message[BOOTP_FIXED_LEN..BOOTP_FIXED_LEN + 4],
&MAGIC_COOKIE
);
assert!(message.len() >= MIN_MESSAGE_LEN);
let options: Vec<_> = options(&message[BOOTP_FIXED_LEN + 4..]).collect();
assert_eq!(options[0], (OPT_MESSAGE_TYPE, [DHCPINFORM].as_slice()));
assert_eq!(
options[1],
(OPT_PARAMETER_REQUEST, REQUESTED_PARAMETERS.as_slice())
);
}
#[test]
fn a_server_message_yields_the_address_the_server_named() {
for kind in [DHCPOFFER, DHCPACK, DHCPNAK] {
let bytes = reply_frame(kind, Some(server_addr()));
let frame = EthernetPacket::new(&bytes).unwrap();
assert_eq!(
server_reply(&frame),
Some(ServerReply {
server: Some(server_addr())
}),
"message type {kind}"
);
}
}
#[test]
fn a_clients_own_traffic_is_never_a_servers_answer() {
let mut message = vec![0u8; BOOTP_FIXED_LEN];
message[0] = BOOTREQUEST;
message.extend_from_slice(&MAGIC_COOKIE);
message.extend_from_slice(&[OPT_MESSAGE_TYPE, 1, 1]); message.push(OPT_END);
let bytes = udp_frame(CLIENT_PORT, SERVER_PORT, message);
assert_eq!(server_reply(&EthernetPacket::new(&bytes).unwrap()), None);
let mut bootp = vec![0u8; BOOTP_FIXED_LEN];
bootp[0] = BOOTREPLY;
let bytes = udp_frame(SERVER_PORT, CLIENT_PORT, bootp);
assert_eq!(server_reply(&EthernetPacket::new(&bytes).unwrap()), None);
let bytes = udp_frame(53, CLIENT_PORT, vec![0u8; 300]);
assert_eq!(server_reply(&EthernetPacket::new(&bytes).unwrap()), None);
}
#[test]
fn a_reply_without_a_server_identifier_names_nobody() {
let bytes = reply_frame(DHCPACK, None);
let frame = EthernetPacket::new(&bytes).unwrap();
assert_eq!(server_reply(&frame), Some(ServerReply { server: None }));
}
#[test]
fn the_option_walk_survives_padding_and_truncation() {
let padded = [OPT_PAD, OPT_PAD, OPT_MESSAGE_TYPE, 1, DHCPACK, OPT_END];
let read: Vec<_> = options(&padded).collect();
assert_eq!(read, vec![(OPT_MESSAGE_TYPE, [DHCPACK].as_slice())]);
let truncated = [OPT_SERVER_ID, 4, 192, 168];
assert_eq!(options(&truncated).count(), 0);
let unterminated = [OPT_MESSAGE_TYPE, 1, DHCPACK];
assert_eq!(options(&unterminated).count(), 1);
}
}