use pnet_base::MacAddr;
use pnet_packet::ethernet::EtherTypes;
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::ethernet::Frame;
use crate::protocols::ip;
use crate::protocols::sizes::{IP_V4_HDR_LEN, UDP_HDR_LEN};
use crate::protocols::text::field as text;
const WORD_LEN: usize = 4;
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 CHADDR_OFFSET: usize = 28;
const MAGIC_COOKIE: [u8; 4] = [99, 130, 83, 99];
const MIN_MESSAGE_LEN: usize = 300;
const OPT_PAD: u8 = 0;
const OPT_ROUTER: u8 = 3;
const OPT_DOMAIN_NAME_SERVER: u8 = 6;
const OPT_HOSTNAME: u8 = 12;
const OPT_DOMAIN_NAME: u8 = 15;
const OPT_REQUESTED_ADDRESS: u8 = 50;
const OPT_MESSAGE_TYPE: u8 = 53;
const OPT_SERVER_ID: u8 = 54;
const OPT_PARAMETER_REQUEST: u8 = 55;
const OPT_VENDOR_CLASS: u8 = 60;
const OPT_END: u8 = 255;
const DHCPDISCOVER: u8 = 1;
const DHCPREQUEST: u8 = 3;
const DHCPDECLINE: u8 = 4;
const DHCPRELEASE: u8 = 7;
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, ];
#[non_exhaustive]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct ServerReply<'a> {
pub server: Option<Ipv4Addr>,
pub domain: Option<&'a str>,
routers: &'a [u8],
resolvers: &'a [u8],
}
impl<'a> ServerReply<'a> {
pub fn routers(&self) -> impl Iterator<Item = Ipv4Addr> + 'a {
addresses(self.routers)
}
pub fn resolvers(&self) -> impl Iterator<Item = Ipv4Addr> + 'a {
addresses(self.resolvers)
}
}
#[non_exhaustive]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct ClientRequest<'a> {
pub client_mac: Option<MacAddr>,
pub hostname: Option<&'a str>,
pub vendor_class: Option<&'a str>,
pub parameter_request_list: Option<&'a [u8]>,
pub requested_address: Option<Ipv4Addr>,
}
pub fn build_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<'a>(frame: &Frame<'a>) -> Option<ServerReply<'a>> {
let (_, options) = bootp_message(frame, SERVER_PORT, BOOTREPLY)?;
let mut kind = None;
let mut reply = ServerReply {
server: None,
domain: None,
routers: &[],
resolvers: &[],
};
for (code, value) in walk_options(options) {
match code {
OPT_MESSAGE_TYPE => kind = value.first().copied(),
OPT_SERVER_ID => reply.server = ipv4(value),
OPT_ROUTER => reply.routers = value,
OPT_DOMAIN_NAME_SERVER => reply.resolvers = value,
OPT_DOMAIN_NAME => reply.domain = text(value),
_ => {}
}
}
matches!(kind, Some(DHCPOFFER | DHCPACK | DHCPNAK)).then_some(reply)
}
pub fn client_request<'a>(frame: &Frame<'a>) -> Option<ClientRequest<'a>> {
let (message, options) = bootp_message(frame, CLIENT_PORT, BOOTREQUEST)?;
let mut kind = None;
let mut request = ClientRequest {
client_mac: client_hardware_address(message),
hostname: None,
vendor_class: None,
parameter_request_list: None,
requested_address: None,
};
for (code, value) in walk_options(options) {
match code {
OPT_MESSAGE_TYPE => kind = value.first().copied(),
OPT_HOSTNAME => request.hostname = text(value),
OPT_VENDOR_CLASS => request.vendor_class = text(value),
OPT_PARAMETER_REQUEST => request.parameter_request_list = Some(value),
OPT_REQUESTED_ADDRESS => request.requested_address = ipv4(value),
_ => {}
}
}
matches!(
kind,
Some(DHCPDISCOVER | DHCPREQUEST | DHCPDECLINE | DHCPRELEASE | DHCPINFORM)
)
.then_some(request)
}
fn bootp_message<'a>(frame: &Frame<'a>, source_port: u16, op: u8) -> Option<(&'a [u8], &'a [u8])> {
if frame.ethertype() != EtherTypes::Ipv4 {
return None;
}
let packet = Ipv4Packet::new(frame.payload())?;
if packet.get_next_level_protocol() != IpNextHeaderProtocols::Udp {
return None;
}
if usize::from(packet.get_header_length()) * WORD_LEN < IP_V4_HDR_LEN {
return None;
}
let header_len = usize::from(packet.get_header_length()) * WORD_LEN;
let datagram_bytes = frame.payload().get(header_len..)?;
let datagram = UdpPacket::new(datagram_bytes)?;
if datagram.get_source() != source_port {
return None;
}
let message = datagram_bytes.get(UDP_HDR_LEN..)?;
if message.first() != Some(&op) {
return None;
}
let cookie_at = BOOTP_FIXED_LEN;
if message.get(cookie_at..cookie_at + MAGIC_COOKIE.len()) != Some(&MAGIC_COOKIE) {
return None;
}
Some((message, message.get(cookie_at + MAGIC_COOKIE.len()..)?))
}
fn client_hardware_address(message: &[u8]) -> Option<MacAddr> {
if *message.get(1)? != HTYPE_ETHERNET || *message.get(2)? != HLEN_ETHERNET {
return None;
}
let address = message.get(CHADDR_OFFSET..CHADDR_OFFSET + usize::from(HLEN_ETHERNET))?;
Some(MacAddr::new(
address[0], address[1], address[2], address[3], address[4], address[5],
))
}
fn addresses(bytes: &[u8]) -> impl Iterator<Item = Ipv4Addr> + '_ {
bytes
.as_chunks::<4>()
.0
.iter()
.map(|&group| Ipv4Addr::from(group))
}
fn walk_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)]
pub(crate) mod tests {
use super::*;
use crate::protocols::ethernet;
use pnet_packet::Packet as _;
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, 0, 2, 50)
}
fn server_addr() -> Ipv4Addr {
Ipv4Addr::new(192, 0, 2, 1)
}
fn reply_frame(message_type: u8, server_id: Option<Ipv4Addr>) -> Vec<u8> {
reply_frame_with(message_type, server_id, &[])
}
fn reply_frame_with(
message_type: u8,
server_id: Option<Ipv4Addr>,
extra: &[(u8, Vec<u8>)],
) -> 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());
}
for (code, value) in extra {
message.push(*code);
message.push(u8::try_from(value.len()).expect("an option length"));
message.extend_from_slice(value);
}
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::build_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 = build_inform(SRC_MAC, src_addr());
let frame = super::super::ethernet::parse(&bytes).expect("an ethernet frame");
assert_eq!(frame.destination(), MacAddr::broadcast());
assert_eq!(frame.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<_> = walk_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 = super::super::ethernet::parse(&bytes).unwrap();
assert_eq!(
server_reply(&frame).map(|reply| reply.server),
Some(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(&super::super::ethernet::parse(&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(&super::super::ethernet::parse(&bytes).unwrap()),
None
);
let bytes = udp_frame(53, CLIENT_PORT, vec![0u8; 300]);
assert_eq!(
server_reply(&super::super::ethernet::parse(&bytes).unwrap()),
None
);
}
#[test]
fn a_reply_without_a_server_identifier_names_nobody() {
let bytes = reply_frame(DHCPACK, None);
let frame = super::super::ethernet::parse(&bytes).unwrap();
assert_eq!(
server_reply(&frame).map(|reply| reply.server),
Some(None),
"the message is a server's; the address in it is not"
);
}
fn request_frame(kind: u8, options: &[(u8, Vec<u8>)]) -> Vec<u8> {
request_frame_from(Ipv4Addr::UNSPECIFIED, kind, options)
}
pub(crate) fn renewal_frame(from: Ipv4Addr, hostname: &str) -> Vec<u8> {
request_frame_from(
from,
DHCPREQUEST,
&[(OPT_HOSTNAME, hostname.as_bytes().to_vec())],
)
}
pub(crate) fn discover_frame(hostname: &str) -> Vec<u8> {
request_frame_from(
Ipv4Addr::UNSPECIFIED,
DHCPDISCOVER,
&[(OPT_HOSTNAME, hostname.as_bytes().to_vec())],
)
}
fn request_frame_from(from: Ipv4Addr, kind: u8, options: &[(u8, Vec<u8>)]) -> Vec<u8> {
const CLIENT_MAC: MacAddr = MacAddr(0xAA, 0xBB, 0xCC, 0x11, 0x22, 0x33);
let mut message = vec![0u8; BOOTP_FIXED_LEN];
message[0] = BOOTREQUEST;
message[1] = HTYPE_ETHERNET;
message[2] = HLEN_ETHERNET;
message[CHADDR_OFFSET..CHADDR_OFFSET + 6].copy_from_slice(&[
CLIENT_MAC.0,
CLIENT_MAC.1,
CLIENT_MAC.2,
CLIENT_MAC.3,
CLIENT_MAC.4,
CLIENT_MAC.5,
]);
message.extend_from_slice(&MAGIC_COOKIE);
message.extend_from_slice(&[OPT_MESSAGE_TYPE, 1, kind]);
for (code, value) in options {
message.push(*code);
message.push(u8::try_from(value.len()).expect("an option length"));
message.extend_from_slice(value);
}
message.push(OPT_END);
let datagram = Packet::new()
.push(Ipv4::new(from, Ipv4Addr::BROADCAST))
.push(Udp::new(CLIENT_PORT, SERVER_PORT).with_payload(message))
.build()
.expect("a test datagram");
[
super::super::ethernet::build_header(
MacAddr(0xAA, 0xBB, 0xCC, 0x11, 0x22, 0x33),
MacAddr::broadcast(),
EtherTypes::Ipv4,
),
datagram,
]
.concat()
}
#[test]
fn a_clients_request_carries_its_name_and_what_it_says_it_is() {
let bytes = request_frame(
DHCPREQUEST,
&[
(OPT_HOSTNAME, b"office-printer-3".to_vec()),
(OPT_VENDOR_CLASS, b"HP JetDirect".to_vec()),
(OPT_PARAMETER_REQUEST, vec![1, 3, 6, 15, 119, 252]),
(OPT_REQUESTED_ADDRESS, vec![192, 0, 2, 74]),
],
);
let frame = super::super::ethernet::parse(&bytes).expect("an ethernet frame");
let request = client_request(&frame).expect("a client request");
assert_eq!(request.hostname, Some("office-printer-3"));
assert_eq!(request.vendor_class, Some("HP JetDirect"));
assert_eq!(
request.requested_address,
Some(Ipv4Addr::new(192, 0, 2, 74))
);
assert_eq!(
request.client_mac,
Some(MacAddr(0xAA, 0xBB, 0xCC, 0x11, 0x22, 0x33))
);
}
#[test]
fn the_parameter_request_list_keeps_the_order_it_was_asked_in() {
let asked = vec![1u8, 121, 3, 6, 15, 119, 252];
let bytes = request_frame(DHCPDISCOVER, &[(OPT_PARAMETER_REQUEST, asked.clone())]);
let frame = super::super::ethernet::parse(&bytes).expect("an ethernet frame");
assert_eq!(
client_request(&frame)
.expect("a client request")
.parameter_request_list,
Some(asked.as_slice()),
"the order is the signal, so it is kept exactly"
);
}
#[test]
fn a_server_reply_carries_what_the_network_hands_out() {
let mut extra = vec![
(OPT_ROUTER, vec![192, 0, 2, 1]),
(OPT_DOMAIN_NAME_SERVER, vec![192, 0, 2, 1, 9, 9, 9, 9]),
(OPT_DOMAIN_NAME, b"corp.example.net".to_vec()),
];
extra.sort_by_key(|(code, _)| *code);
let bytes = reply_frame_with(DHCPACK, Some(server_addr()), &extra);
let frame = super::super::ethernet::parse(&bytes).expect("an ethernet frame");
let reply = server_reply(&frame).expect("a server reply");
assert_eq!(reply.server, Some(server_addr()));
assert_eq!(reply.domain, Some("corp.example.net"));
assert_eq!(
reply.routers().collect::<Vec<_>>(),
vec![Ipv4Addr::new(192, 0, 2, 1)]
);
assert_eq!(
reply.resolvers().collect::<Vec<_>>(),
vec![Ipv4Addr::new(192, 0, 2, 1), Ipv4Addr::new(9, 9, 9, 9)],
"in the order the server listed them, which is the order a client tries"
);
}
#[test]
fn neither_direction_is_readable_as_the_other() {
let request = request_frame(DHCPDISCOVER, &[(OPT_HOSTNAME, b"laptop".to_vec())]);
let frame = super::super::ethernet::parse(&request).expect("an ethernet frame");
assert_eq!(
server_reply(&frame),
None,
"a client asking is not a server answering"
);
let reply = reply_frame(DHCPACK, Some(server_addr()));
let frame = super::super::ethernet::parse(&reply).expect("an ethernet frame");
assert_eq!(
client_request(&frame),
None,
"a server answering is not a client asking"
);
}
#[test]
fn a_trailing_partial_address_is_dropped_rather_than_padded() {
let bytes = reply_frame_with(
DHCPACK,
Some(server_addr()),
&[(OPT_DOMAIN_NAME_SERVER, vec![198, 51, 100, 1, 198, 51])],
);
let frame = super::super::ethernet::parse(&bytes).expect("an ethernet frame");
assert_eq!(
server_reply(&frame)
.expect("a server reply")
.resolvers()
.collect::<Vec<_>>(),
vec![Ipv4Addr::new(198, 51, 100, 1)]
);
}
#[test]
fn a_nul_padded_hostname_arrives_without_its_padding() {
let frame_bytes = renewal_frame(src_addr(), "printer\0\0\0\0");
let frame = ethernet::parse(&frame_bytes).expect("a frame");
let request = client_request(&frame).expect("a client request");
assert_eq!(request.hostname, Some("printer"));
}
#[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<_> = walk_options(&padded).collect();
assert_eq!(read, vec![(OPT_MESSAGE_TYPE, [DHCPACK].as_slice())]);
let truncated = [OPT_SERVER_ID, 4, 192, 0];
assert_eq!(walk_options(&truncated).count(), 0);
let unterminated = [OPT_MESSAGE_TYPE, 1, DHCPACK];
assert_eq!(walk_options(&unterminated).count(), 1);
}
}