use std::hash::{Hash, Hasher};
use std::net::Ipv4Addr;
use siphasher::sip::SipHasher24;
#[derive(Clone)]
pub struct StatelessCookie {
key: u64,
}
impl StatelessCookie {
#[must_use]
pub fn new() -> Self {
let mut buf = [0u8; 8];
getrandom::fill(&mut buf)
.expect("OS CSPRNG (getrandom) must be available to seed the stateless cookie key");
Self {
key: u64::from_ne_bytes(buf),
}
}
#[must_use]
pub const fn with_key(key: u64) -> Self {
Self { key }
}
#[must_use]
pub const fn key(&self) -> u64 {
self.key
}
}
impl Default for StatelessCookie {
fn default() -> Self {
Self::new()
}
}
pub struct SeqEncoder {
cookie: StatelessCookie,
}
impl SeqEncoder {
#[must_use]
pub fn new() -> Self {
Self {
cookie: StatelessCookie::new(),
}
}
#[must_use]
pub const fn with_cookie(cookie: StatelessCookie) -> Self {
Self { cookie }
}
#[inline]
pub fn encode(
&self,
dst_ip: Ipv4Addr,
dst_port: u16,
src_port: u16,
phase: u8,
) -> u32 {
let mut hasher = SipHasher24::new_with_keys(self.cookie.key, self.cookie.key);
dst_ip.hash(&mut hasher);
dst_port.hash(&mut hasher);
src_port.hash(&mut hasher);
phase.hash(&mut hasher);
(hasher.finish() & 0xFFFF_FFFF) as u32
}
#[inline]
pub fn verify_synack(
&self,
ack_num: u32,
src_ip: Ipv4Addr,
src_port: u16,
our_dst_port: u16,
) -> bool {
let expected = self.encode(src_ip, src_port, our_dst_port, 0);
ack_num == expected.wrapping_add(1)
}
#[inline]
pub fn verify_data_ack(
&self,
ack_num: u32,
src_ip: Ipv4Addr,
src_port: u16,
our_dst_port: u16,
payload_len: u32,
) -> bool {
let expected = self.encode(src_ip, src_port, our_dst_port, 1);
ack_num == expected.wrapping_add(payload_len)
}
#[must_use]
pub const fn cookie(&self) -> &StatelessCookie {
&self.cookie
}
}
impl Default for SeqEncoder {
fn default() -> Self {
Self::new()
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn encode_is_deterministic() {
let enc = SeqEncoder::with_cookie(StatelessCookie::with_key(42));
let ip = Ipv4Addr::new(1, 2, 3, 4);
let s1 = enc.encode(ip, 80, 49152, 0);
let s2 = enc.encode(ip, 80, 49152, 0);
assert_eq!(s1, s2);
}
#[test]
fn fresh_cookie_keys_are_random_not_constant() {
const N: usize = 256;
let keys: std::collections::HashSet<u64> =
(0..N).map(|_| StatelessCookie::new().key()).collect();
assert_eq!(
keys.len(),
N,
"all {N} fresh cookie keys must be distinct; a collision means the key source is not random"
);
assert!(!keys.contains(&0), "a fresh key of 0 indicates a broken RNG source");
}
#[test]
fn encode_differs_by_target() {
let enc = SeqEncoder::with_cookie(StatelessCookie::with_key(42));
let ip_a = Ipv4Addr::new(1, 2, 3, 4);
let ip_b = Ipv4Addr::new(5, 6, 7, 8);
assert_ne!(
enc.encode(ip_a, 80, 49152, 0),
enc.encode(ip_b, 80, 49152, 0),
);
}
#[test]
fn encode_differs_by_port() {
let enc = SeqEncoder::with_cookie(StatelessCookie::with_key(42));
let ip = Ipv4Addr::new(1, 2, 3, 4);
assert_ne!(
enc.encode(ip, 80, 49152, 0),
enc.encode(ip, 443, 49152, 0),
);
}
#[test]
fn encode_differs_by_phase() {
let enc = SeqEncoder::with_cookie(StatelessCookie::with_key(42));
let ip = Ipv4Addr::new(1, 2, 3, 4);
assert_ne!(
enc.encode(ip, 80, 49152, 0),
enc.encode(ip, 80, 49152, 1),
);
}
#[test]
fn encode_differs_by_key() {
let enc_a = SeqEncoder::with_cookie(StatelessCookie::with_key(1));
let enc_b = SeqEncoder::with_cookie(StatelessCookie::with_key(2));
let ip = Ipv4Addr::new(1, 2, 3, 4);
assert_ne!(
enc_a.encode(ip, 80, 49152, 0),
enc_b.encode(ip, 80, 49152, 0),
);
}
#[test]
fn verify_synack_accepts_valid() {
let enc = SeqEncoder::with_cookie(StatelessCookie::with_key(42));
let ip = Ipv4Addr::new(1, 2, 3, 4);
let seq = enc.encode(ip, 80, 49152, 0);
let ack = seq.wrapping_add(1);
assert!(enc.verify_synack(ack, ip, 80, 49152));
}
#[test]
fn verify_synack_rejects_invalid() {
let enc = SeqEncoder::with_cookie(StatelessCookie::with_key(42));
let ip = Ipv4Addr::new(1, 2, 3, 4);
assert!(!enc.verify_synack(0xDEADBEEF, ip, 80, 49152));
}
#[test]
fn verify_synack_rejects_wrong_target() {
let enc = SeqEncoder::with_cookie(StatelessCookie::with_key(42));
let ip_a = Ipv4Addr::new(1, 2, 3, 4);
let ip_b = Ipv4Addr::new(5, 6, 7, 8);
let seq = enc.encode(ip_a, 80, 49152, 0);
let ack = seq.wrapping_add(1);
assert!(!enc.verify_synack(ack, ip_b, 80, 49152));
}
#[test]
fn verify_data_ack_works() {
let enc = SeqEncoder::with_cookie(StatelessCookie::with_key(42));
let ip = Ipv4Addr::new(1, 2, 3, 4);
let seq = enc.encode(ip, 80, 49152, 1);
let payload_len = 100u32;
let ack = seq.wrapping_add(payload_len);
assert!(enc.verify_data_ack(ack, ip, 80, 49152, payload_len));
}
}
#[cfg(test)]
mod proptests {
use super::*;
use proptest::prelude::*;
proptest! {
#[test]
fn encode_roundtrips(
a in any::<u8>(), b in any::<u8>(), c in any::<u8>(), d in any::<u8>(),
port in any::<u16>(),
src_port in any::<u16>(),
phase in 0u8..4,
key in any::<u64>(),
) {
let enc = SeqEncoder::with_cookie(StatelessCookie::with_key(key));
let ip = Ipv4Addr::new(a, b, c, d);
let seq = enc.encode(ip, port, src_port, phase);
prop_assert_eq!(seq, enc.encode(ip, port, src_port, phase));
if phase == 0 {
prop_assert!(enc.verify_synack(seq.wrapping_add(1), ip, port, src_port));
prop_assert!(!enc.verify_synack(seq.wrapping_add(2), ip, port, src_port));
}
}
}
}