use std::net::Ipv4Addr;
pub const MAX_PACKET_SIZE: usize = 1514;
pub const MIN_SYN_SIZE: usize = 40;
#[derive(Clone)]
pub struct RawPacket {
pub buf: [u8; MAX_PACKET_SIZE],
pub len: u16,
}
impl RawPacket {
#[must_use]
pub const fn empty() -> Self {
Self {
buf: [0u8; MAX_PACKET_SIZE],
len: 0,
}
}
#[must_use]
pub fn from_bytes(data: &[u8]) -> Option<Self> {
if data.len() > MAX_PACKET_SIZE {
return None;
}
let mut pkt = Self::empty();
pkt.buf[..data.len()].copy_from_slice(data);
pkt.len = data.len() as u16;
Some(pkt)
}
#[inline]
pub fn as_bytes(&self) -> &[u8] {
&self.buf[..self.clamped_len()]
}
#[inline]
pub fn as_bytes_mut(&mut self) -> &mut [u8] {
let end = self.clamped_len();
&mut self.buf[..end]
}
#[inline]
pub(crate) fn clamped_len(&self) -> usize {
(self.len as usize).min(MAX_PACKET_SIZE)
}
}
impl Default for RawPacket {
fn default() -> Self {
Self::empty()
}
}
impl std::fmt::Debug for RawPacket {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("RawPacket")
.field("len", &self.len)
.finish()
}
}
pub mod offsets {
pub const IP_DST: usize = 16;
pub const IP_SRC: usize = 12;
pub const IP_TOTAL_LEN: usize = 2;
pub const IP_CHECKSUM: usize = 10;
pub const TCP_START: usize = 20;
pub const TCP_SRC_PORT: usize = 20;
pub const TCP_DST_PORT: usize = 22;
pub const TCP_SEQ: usize = 24;
pub const TCP_ACK: usize = 28;
pub const TCP_FLAGS: usize = 32;
pub const TCP_WINDOW: usize = 34;
pub const TCP_CHECKSUM: usize = 36;
}
pub fn build_syn_template(src_ip: Ipv4Addr, src_port: u16) -> RawPacket {
let mut pkt = RawPacket::empty();
pkt.len = MIN_SYN_SIZE as u16;
let buf = &mut pkt.buf;
buf[0] = 0x45; buf[1] = 0x00; let total_len = MIN_SYN_SIZE as u16;
buf[offsets::IP_TOTAL_LEN..offsets::IP_TOTAL_LEN + 2]
.copy_from_slice(&total_len.to_be_bytes());
buf[4..6].copy_from_slice(&[0x00, 0x00]); buf[6..8].copy_from_slice(&[0x40, 0x00]); buf[8] = 64; buf[9] = 6; let src_octets = src_ip.octets();
buf[offsets::IP_SRC..offsets::IP_SRC + 4].copy_from_slice(&src_octets);
buf[offsets::TCP_SRC_PORT..offsets::TCP_SRC_PORT + 2]
.copy_from_slice(&src_port.to_be_bytes());
buf[offsets::TCP_ACK..offsets::TCP_ACK + 4].copy_from_slice(&0u32.to_be_bytes());
buf[offsets::TCP_FLAGS] = 0x50; buf[offsets::TCP_FLAGS + 1] = 0x02; buf[offsets::TCP_WINDOW..offsets::TCP_WINDOW + 2]
.copy_from_slice(&64240u16.to_be_bytes()); buf[38..40].copy_from_slice(&[0x00, 0x00]);
pkt
}
pub fn stamp_syn(
template: &mut RawPacket,
dst_ip: Ipv4Addr,
dst_port: u16,
seq: u32,
) {
if template.len < MIN_SYN_SIZE as u16 {
template.len = MIN_SYN_SIZE as u16;
}
let tcp_end = template.clamped_len();
let buf = &mut template.buf;
let dst_octets = dst_ip.octets();
buf[offsets::IP_DST..offsets::IP_DST + 4].copy_from_slice(&dst_octets);
buf[offsets::TCP_DST_PORT..offsets::TCP_DST_PORT + 2]
.copy_from_slice(&dst_port.to_be_bytes());
buf[offsets::TCP_SEQ..offsets::TCP_SEQ + 4]
.copy_from_slice(&seq.to_be_bytes());
buf[offsets::IP_CHECKSUM..offsets::IP_CHECKSUM + 2].copy_from_slice(&[0, 0]);
let ip_cksum = crate::checksum::ip_checksum(&buf[..20]);
buf[offsets::IP_CHECKSUM..offsets::IP_CHECKSUM + 2]
.copy_from_slice(&ip_cksum.to_be_bytes());
buf[offsets::TCP_CHECKSUM..offsets::TCP_CHECKSUM + 2].copy_from_slice(&[0, 0]);
let src_ip: [u8; 4] = buf[offsets::IP_SRC..offsets::IP_SRC + 4]
.try_into()
.expect("IP_SRC..+4 is exactly 4 bytes");
let dst_ip: [u8; 4] = buf[offsets::IP_DST..offsets::IP_DST + 4]
.try_into()
.expect("IP_DST..+4 is exactly 4 bytes");
let tcp_cksum = crate::checksum::tcp_checksum(
src_ip,
dst_ip,
&buf[offsets::TCP_START..tcp_end],
);
buf[offsets::TCP_CHECKSUM..offsets::TCP_CHECKSUM + 2]
.copy_from_slice(&tcp_cksum.to_be_bytes());
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn syn_template_has_correct_length() {
let pkt = build_syn_template(Ipv4Addr::new(10, 0, 0, 1), 49152);
assert_eq!(pkt.len, 40);
}
#[test]
fn stamp_syn_produces_valid_checksums() {
let mut pkt = build_syn_template(Ipv4Addr::new(10, 0, 0, 1), 49152);
stamp_syn(&mut pkt, Ipv4Addr::new(1, 1, 1, 1), 80, 0x12345678);
let ip_sum = crate::checksum::ip_checksum(&pkt.buf[..20]);
assert_eq!(
ip_sum, 0,
"IP header did not verify against its own embedded checksum"
);
}
#[test]
fn empty_packet_is_zeroed() {
let pkt = RawPacket::empty();
assert_eq!(pkt.len, 0);
assert!(pkt.buf.iter().all(|&b| b == 0));
}
#[test]
fn from_bytes_respects_max_size() {
let data = vec![0xABu8; MAX_PACKET_SIZE];
assert!(RawPacket::from_bytes(&data).is_some());
let too_big = vec![0xABu8; MAX_PACKET_SIZE + 1];
assert!(RawPacket::from_bytes(&too_big).is_none());
}
#[test]
fn oversized_public_len_is_clamped_not_panicking() {
let mut pkt = build_syn_template(Ipv4Addr::new(10, 0, 0, 1), 49152);
pkt.len = u16::MAX;
assert_eq!(pkt.as_bytes().len(), MAX_PACKET_SIZE);
assert_eq!(pkt.as_bytes_mut().len(), MAX_PACKET_SIZE);
stamp_syn(&mut pkt, Ipv4Addr::new(1, 1, 1, 1), 80, 0x1234_5678);
}
#[test]
fn undersized_template_is_expanded_without_panicking() {
let mut pkt = RawPacket::empty();
assert_eq!(pkt.len, 0);
stamp_syn(&mut pkt, Ipv4Addr::new(1, 1, 1, 1), 80, 0x1234_5678);
assert_eq!(pkt.len, MIN_SYN_SIZE as u16);
}
}