#[inline]
pub fn ones_complement_sum(data: &[u8]) -> u16 {
let mut sum: u32 = 0;
let mut chunks = data.chunks_exact(2);
for chunk in &mut chunks {
sum += u16::from_be_bytes([chunk[0], chunk[1]]) as u32;
}
if let Some(&last) = chunks.remainder().first() {
sum += (last as u32) << 8;
}
while sum >> 16 != 0 {
sum = (sum & 0xFFFF) + (sum >> 16);
}
!(sum as u16)
}
#[inline]
pub fn ip_checksum(ip_header: &[u8]) -> u16 {
ones_complement_sum(ip_header)
}
pub fn tcp_checksum(src_ip: [u8; 4], dst_ip: [u8; 4], tcp_segment: &[u8]) -> u16 {
debug_assert!(
tcp_segment.len() <= u16::MAX as usize,
"tcp_segment length {} exceeds the 16-bit TCP length field; checksum would be wrong",
tcp_segment.len()
);
let tcp_len = u16::try_from(tcp_segment.len()).unwrap_or(u16::MAX);
let mut sum: u32 = 0;
sum += u16::from_be_bytes([src_ip[0], src_ip[1]]) as u32;
sum += u16::from_be_bytes([src_ip[2], src_ip[3]]) as u32;
sum += u16::from_be_bytes([dst_ip[0], dst_ip[1]]) as u32;
sum += u16::from_be_bytes([dst_ip[2], dst_ip[3]]) as u32;
sum += 6u32; sum += tcp_len as u32;
let mut chunks = tcp_segment.chunks_exact(2);
for chunk in &mut chunks {
sum += u16::from_be_bytes([chunk[0], chunk[1]]) as u32;
}
if let Some(&last) = chunks.remainder().first() {
sum += (last as u32) << 8;
}
while sum >> 16 != 0 {
sum = (sum & 0xFFFF) + (sum >> 16);
}
!(sum as u16)
}
pub fn batch_ip_checksum(packets: &mut [crate::RawPacket]) {
for pkt in packets.iter_mut() {
let len = pkt.clamped_len();
if len < 20 {
continue;
}
let version = pkt.buf[0] >> 4;
let ihl = (pkt.buf[0] & 0x0F) as usize;
let header_len = ihl * 4;
if version != 4 || ihl < 5 || header_len > len {
continue;
}
pkt.buf[10] = 0;
pkt.buf[11] = 0;
let cksum = ip_checksum(&pkt.buf[..header_len]);
pkt.buf[10..12].copy_from_slice(&cksum.to_be_bytes());
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn ip_checksum_known_value() {
let mut header = [0u8; 20];
header[0] = 0x45;
header[2..4].copy_from_slice(&20u16.to_be_bytes());
header[6] = 0x40; header[8] = 64; header[9] = 6; header[12..16].copy_from_slice(&[10, 0, 0, 1]); header[16..20].copy_from_slice(&[1, 1, 1, 1]);
let cksum = ip_checksum(&header);
header[10..12].copy_from_slice(&cksum.to_be_bytes());
let verify: u32 = (0..20)
.step_by(2)
.map(|i| u16::from_be_bytes([header[i], header[i + 1]]) as u32)
.sum();
let folded = {
let mut s = verify;
while s >> 16 != 0 {
s = (s & 0xFFFF) + (s >> 16);
}
s as u16
};
assert_eq!(folded, 0xFFFF);
}
#[test]
fn tcp_checksum_roundtrip() {
let src_ip = [10, 0, 0, 1];
let dst_ip = [1, 1, 1, 1];
let mut tcp = [0u8; 20];
tcp[0..2].copy_from_slice(&49152u16.to_be_bytes()); tcp[2..4].copy_from_slice(&80u16.to_be_bytes()); tcp[4..8].copy_from_slice(&0x12345678u32.to_be_bytes()); tcp[12] = 0x50; tcp[13] = 0x02; tcp[14..16].copy_from_slice(&64240u16.to_be_bytes());
let cksum = tcp_checksum(src_ip, dst_ip, &tcp);
assert_ne!(cksum, 0, "TCP checksum should not be zero for valid packet");
}
#[test]
fn empty_checksum_is_ffff() {
assert_eq!(ones_complement_sum(&[]), 0xFFFF);
}
#[test]
fn tcp_checksum_verifies_to_ffff_when_embedded() {
let src_ip = [10, 0, 0, 1];
let dst_ip = [1, 1, 1, 1];
let mut tcp = [0u8; 20];
tcp[0..2].copy_from_slice(&49152u16.to_be_bytes());
tcp[2..4].copy_from_slice(&80u16.to_be_bytes());
tcp[12] = 0x50;
tcp[13] = 0x02;
let cksum = tcp_checksum(src_ip, dst_ip, &tcp);
tcp[16..18].copy_from_slice(&cksum.to_be_bytes());
let verify = tcp_checksum(src_ip, dst_ip, &tcp);
assert_eq!(verify, 0, "embedded TCP checksum must self-verify to 0");
}
#[test]
fn batch_ip_checksum_covers_ihl_options_header() {
let mut pkt = crate::RawPacket::empty();
pkt.len = 24;
pkt.buf[0] = 0x46; pkt.buf[2..4].copy_from_slice(&24u16.to_be_bytes()); pkt.buf[8] = 64; pkt.buf[9] = 6; pkt.buf[12..16].copy_from_slice(&[10, 0, 0, 1]); pkt.buf[16..20].copy_from_slice(&[1, 1, 1, 1]); pkt.buf[20..24].copy_from_slice(&[0x01, 0x01, 0x01, 0x00]);
batch_ip_checksum(std::slice::from_mut(&mut pkt));
let verify: u32 = (0..24)
.step_by(2)
.map(|i| u16::from_be_bytes([pkt.buf[i], pkt.buf[i + 1]]) as u32)
.sum();
let mut folded = verify;
while folded >> 16 != 0 {
folded = (folded & 0xFFFF) + (folded >> 16);
}
assert_eq!(
folded as u16, 0xFFFF,
"24-byte IHL=6 header checksum must self-verify"
);
let full = u16::from_be_bytes([pkt.buf[10], pkt.buf[11]]);
pkt.buf[10] = 0;
pkt.buf[11] = 0;
let only_20 = ip_checksum(&pkt.buf[..20]);
assert_ne!(
full, only_20,
"checksum over 24-byte header must differ from a 20-byte-only checksum"
);
}
#[test]
fn batch_ip_checksum_skips_invalid_ihl() {
let mut pkt = crate::RawPacket::empty();
pkt.len = 20;
pkt.buf[0] = 0x44; pkt.buf[10] = 0xAB; pkt.buf[11] = 0xCD;
batch_ip_checksum(std::slice::from_mut(&mut pkt));
assert_eq!(
[pkt.buf[10], pkt.buf[11]],
[0xAB, 0xCD],
"invalid IHL packet must be skipped, not rewritten"
);
}
#[test]
fn batch_ip_checksum_skips_non_ipv4_version() {
let mut pkt = crate::RawPacket::empty();
pkt.len = 20;
pkt.buf[0] = 0x65; pkt.buf[10] = 0xAB; pkt.buf[11] = 0xCD;
batch_ip_checksum(std::slice::from_mut(&mut pkt));
assert_eq!(
[pkt.buf[10], pkt.buf[11]],
[0xAB, 0xCD],
"non-IPv4 version packet must be skipped, not rewritten"
);
}
}