guard/xdp/core/syn_challenge.h
loki5512344 14dcaccdbf
fix(xdp): correct payload length, attach/detach, whitelist and ban upkeep
BPF program (the first two made the filter wrong on real hardware):
- Compute the TCP payload length from ip->tot_len (IPv4) / payload_len
  (IPv6) instead of data_end. Ethernet padding on a real NIC added 6 bogus
  payload bytes, broke expected_seq and dropped every connection after the
  fourth segment. scripts/xdp_pkt_test.sh reproduces it on synthetic frames
  and fails against the old code.
- Read map values (conn->fails, sent_at) before bpf_map_delete_elem; the LRU
  element is freed by the delete.
- Parse up to two VLAN/QinQ tags before L3; fragments are checked against the
  blacklist and passed instead of bypassing all filtering; first fragments are
  no longer dropped.
- Unknown non-SYN flows PASS: the program is a stateless filter fed by the
  conntrack state machine, not a firewall, so spoofed SYNs cannot evict
  established flows into a drop and replies to the daemon's own outbound TCP
  keep working.
- Reset conn->fails on in-order segments, honour SYN payload (TFO), fix the
  IPv6 SYN-ACK address swap, count every DROP path, drop SYN with IP options.
- Expired prefix bans are no longer deleted with the wrong LPM key; userspace
  reaps them with the exact key.

Loader:
- Remember the effective attach flags (native vs generic) and use them for
  detach/query, verifying the interface is clean afterwards. The old code
  always detached the native slot, leaving a generic program attached after
  shutdown.
- DetachGuard rolls back the attach if anything after it fails.
- ban_cidr validates the prefix length and masks host bits.
- Whitelist maps (v4 and the new v6 LPM trie) are populated from the config at
  startup and fail fast on error.
- Stats read all 13 counters, and a test asserts every map's key/value size
  against the Rust encodings.

Tests: xdp_pkt_test (padding, VLAN/QinQ, fragments), xdp_loader (attach flags,
rollback, detach), xdp_ban_keys, xdp_whitelist_keys, xdp_services, live
xdp_attach_smoke (ignored, needs root).
2026-11-16 12:06:05 +01:00

309 lines
11 KiB
C

#ifndef RAMPART_SYN_CHALLENGE_H
#define RAMPART_SYN_CHALLENGE_H
/**
* Rampart RST challenge (Oubliette-style liveness proof).
*
* Protocol-agnostic source verification that any TCP client can pass:
*
* 1. A SYN from a source that is neither whitelisted nor verified makes
* the filter reflect a SYN-ACK with a deliberately wrong ack number
* (derived deterministically from the 4-tuple and the secret) and drop
* the original SYN.
* 2. A spoofed source never reacts, because it does not own the address.
* 3. A live client's TCP stack rejects the unacceptable SYN-ACK
* (RFC 9293 SYN-SENT: a SEG.ACK outside [ISS+1, SND.NXT] triggers a
* RST) and echoes secret-derived values in that RST. Seeing the RST
* marks the source verified; the application reconnects and its next
* SYN reaches the backend.
*
* Pending challenges expire after G_CHALLENGE_TIMEOUT_MS, so a silent
* spoofed source is forgotten instead of accumulating state.
*/
#include "common.h"
#include "config.h"
#include "maps.h"
#include "stats.h"
#define CHAL_CONTINUE (-1) // fall through to the normal filter path
/**
* Secret-dependent 64-bit mixing step (splitmix-style finalizer).
*
* @param h running hash
* @param v value to fold in
* @return mixed hash
*/
static __always_inline __u64 chal_mix64(__u64 h, __u64 v)
{
h ^= v;
h *= 0x9E3779B97F4A7C15ULL;
h ^= h >> 29;
return h;
}
/**
* Derive the per-flow challenge values.
*
* Both the ISN and the bogus ack come from this hash, so forging a passing
* RST is infeasible without G_CHALLENGE_SECRET while the values stay stable
* for the same flow.
*
* @param k flow key of the connection being challenged
* @return 64-bit secret-derived value (high half ISN, low half bad ack)
*/
static __always_inline __u64 chal_derive(const struct flow_key *k)
{
__u64 h = (__u64)G_CHALLENGE_SECRET ^ 0x5253544348414C53ULL;
h = chal_mix64(h, ((__u64)k->src_ip << 32) | k->dst_ip);
h = chal_mix64(h, ((__u64)k->src_port << 48) | ((__u64)k->dst_port << 32));
h *= 0xFF51AFD7ED558CCDULL;
h ^= h >> 32;
return h;
}
/**
* Sum the ten 16-bit words of a 20-byte header.
*
* Both the IPv4 and the TCP headers are exactly 20 bytes, so one helper
* serves each of them.
*
* @param w header viewed as ten 16-bit words
* @return unfolded ones-complement sum
*/
static __always_inline __u32 chal_sum10(const __u16 *w)
{
__u32 s = 0;
s += w[0]; s += w[1]; s += w[2]; s += w[3]; s += w[4];
s += w[5]; s += w[6]; s += w[7]; s += w[8]; s += w[9];
return s;
}
/**
* Fold an accumulated sum into a ones-complement checksum.
*
* @param sum unfolded 32-bit sum of 16-bit words
* @return checksum, already complemented and ready for the header
*/
static __always_inline __u16 chal_csum_fold(__u32 sum)
{
sum = (sum >> 16) + (sum & 0xFFFF);
sum += sum >> 16;
return (__u16)~sum;
}
/**
* Rewrite the packet in place into a SYN-ACK carrying the challenge.
*
* MAC addresses and IP addresses are swapped, ports are swapped, seq is set
* to marker and ack to bad_ack; a guaranteed-unacceptable ack is what forces
* the live client into an RST. The TCP header is rebuilt clean (options
* gone), the IPv4 checksum recomputed and the TCP checksum rebuilt over the
* pseudo-header. The frame is trimmed so the peer sees no leftover option
* bytes from the original SYN.
*
* @param ctx XDP context, used to trim the tail
* @param eth Ethernet header of the packet
* @param l3 start of the IPv4 or IPv6 header
* @param is_ipv6 1 when l3 is an IPv6 header
* @param tcp TCP header of the packet
* @param marker ISN to advertise (our seq)
* @param bad_ack unacceptable ack number to advertise
*/
static __always_inline void chal_build_synack(struct xdp_md *ctx,
struct ethhdr *eth, void *l3,
__u8 is_ipv6, struct tcphdr *tcp,
__u32 marker, __u32 bad_ack)
{
// Snapshot phase: every read happens before any write, because a write
// invalidates the verifier's bounds knowledge for later reads.
__u16 ipw[10];
__u16 tcpw[10];
__u8 ms[ETH_ALEN], md[ETH_ALEN];
__u32 saddr[4] = {0}, daddr[4] = {0};
__builtin_memcpy(ms, eth->h_source, ETH_ALEN);
__builtin_memcpy(md, eth->h_dest, ETH_ALEN);
__builtin_memcpy(ipw, l3, 20);
__builtin_memcpy(tcpw, tcp, 20);
if (is_ipv6) {
// saddr/daddr hold the addresses of the reply: the new source is the
// original destination and the new destination is the original
// source. The checksum below is computed over exactly these values.
__builtin_memcpy(saddr, &((struct ipv6hdr *)l3)->daddr, 16);
__builtin_memcpy(daddr, &((struct ipv6hdr *)l3)->saddr, 16);
} else {
saddr[0] = ((struct iphdr *)l3)->daddr;
daddr[0] = ((struct iphdr *)l3)->saddr;
}
// Compute phase: build both header images in registers.
// IPv4: swap addresses, fresh TTL, recompute the checksum.
if (!is_ipv6) {
__u16 s0 = ipw[6], s1 = ipw[7];
ipw[6] = ipw[8];
ipw[7] = ipw[9];
ipw[8] = s0;
ipw[9] = s1;
((__u8 *)ipw)[8] = 64; // TTL
// tot_len must match the trimmed frame: 20 (IP) + 20 (TCP).
// Without this the peer sees "truncated IP" and drops the challenge.
ipw[1] = bpf_htons(sizeof(struct iphdr) + sizeof(struct tcphdr));
ipw[5] = 0; // checksum placeholder
ipw[5] = chal_csum_fold(chal_sum10(ipw));
} else {
((struct ipv6hdr *)l3)->payload_len =
bpf_htons(sizeof(struct tcphdr));
}
// TCP: swap ports, inject the secret-derived seq/ack and SYN|ACK.
__u16 nsport = tcpw[1]; // new source = old dest
__u16 ndport = tcpw[0]; // new dest = old source
tcpw[0] = nsport;
tcpw[1] = ndport;
// seq/ack are written per-halfword with htons: tcpw is a view over
// network-order memory, raw host-order stores would swap halfword bytes.
tcpw[2] = bpf_htons((__u16)(marker >> 16));
tcpw[3] = bpf_htons((__u16)(marker & 0xFFFF));
tcpw[4] = bpf_htons((__u16)(bad_ack >> 16));
tcpw[5] = bpf_htons((__u16)(bad_ack & 0xFFFF));
tcpw[6] = bpf_htons(0x5012); // doff=5, flags SYN|ACK
tcpw[7] = bpf_htons(0xFFFF); // window
tcpw[8] = 0; // checksum placeholder
tcpw[9] = 0; // urg_ptr
// TCP checksum over pseudo-header plus the 20-byte header.
__u32 sum = 0;
if (is_ipv6) {
__u16 *w = (__u16 *)saddr;
sum += w[0] + w[1] + w[2] + w[3] + w[4] + w[5] + w[6] + w[7];
w = (__u16 *)daddr;
sum += w[0] + w[1] + w[2] + w[3] + w[4] + w[5] + w[6] + w[7];
} else {
sum += ipw[6] + ipw[7] + ipw[8] + ipw[9]; // new IPv4 saddr/daddr
}
sum += bpf_htons(IPPROTO_TCP);
sum += bpf_htons((__u16)sizeof(struct tcphdr));
sum += chal_sum10(tcpw);
tcpw[8] = chal_csum_fold(sum);
// Write phase: commit the images built above.
__builtin_memcpy(eth->h_dest, ms, ETH_ALEN);
__builtin_memcpy(eth->h_source, md, ETH_ALEN);
if (is_ipv6) {
struct ipv6hdr *ip6 = l3;
// Write the header with the same orientation the checksum was built
// from: saddr is the new source (original destination), daddr the
// new destination (original source).
__builtin_memcpy(&ip6->saddr, saddr, 16);
__builtin_memcpy(&ip6->daddr, daddr, 16);
ip6->hop_limit = 64;
} else {
__builtin_memcpy(l3, ipw, 20);
}
__builtin_memcpy(tcp, tcpw, 20);
// Trim to the bare header so SYN options and payload remnants are gone.
long trim = (long)((void *)(long)ctx->data_end -
((void *)tcp + sizeof(struct tcphdr)));
if (trim > 0)
bpf_xdp_adjust_tail(ctx, -trim);
}
/**
* Handle a bare SYN from a source that may not have proven liveness yet.
*
* A verified source refreshes its TTL and continues down the normal filter
* path. Anything else receives the reflected challenge.
*
* @param ctx XDP context
* @param eth Ethernet header
* @param l3 start of the IPv4 or IPv6 header
* @param is_ipv6 1 when l3 is an IPv6 header
* @param tcp TCP header
* @param flow flow key of this connection
* @param now current bpf_ktime_get_ns() timestamp
* @return CHAL_CONTINUE to process normally, XDP_TX when a challenge
* was sent, or XDP_DROP on failure
*/
static __always_inline int chal_on_syn(struct xdp_md *ctx, struct ethhdr *eth,
void *l3, __u8 is_ipv6,
struct tcphdr *tcp,
const struct flow_key *flow, __u64 now)
{
__u64 *v = bpf_map_lookup_elem(&challenge_verified, &flow->src_ip);
if (v) {
if (now - *v <= G_CHALLENGE_VERIFIED_TTL_NS) {
*v = now; // sliding TTL refresh
return CHAL_CONTINUE;
}
bpf_map_delete_elem(&challenge_verified, &flow->src_ip); // expired
}
__u64 h = chal_derive(flow);
__u32 marker = (__u32)(h >> 32); // our ISN
__u32 bad_ack = (__u32)h; // bogus ack the client must reject
__u32 expect = bpf_ntohl(tcp->seq) + 1;
if (bad_ack == expect) // ~2^-32 collision with a valid handshake — kill it
bad_ack = ~bad_ack;
struct challenge_pending p = {
.sent_at = now,
.marker = marker,
.bad_ack = bad_ack,
};
if (bpf_map_update_elem(&challenge_pending, flow, &p, BPF_ANY)) {
inc_drop(); // cannot track the challenge — fail closed
return XDP_DROP;
}
inc_chal_sent();
chal_build_synack(ctx, eth, l3, is_ipv6, tcp, marker, bad_ack);
return XDP_TX;
}
/**
* Handle a RST that may answer a pending challenge.
*
* Only a RST echoing a secret-derived value counts as proof of life: our bad
* ack as its seq, or our marker+1 as its ack. Everything else, including a
* reply that arrives after the timeout, fails the challenge and is dropped.
*
* @param tcp TCP header of the RST
* @param flow flow key of the connection
* @param now current bpf_ktime_get_ns() timestamp
* @return CHAL_CONTINUE when no challenge was pending, otherwise XDP_DROP
*/
static __always_inline int chal_on_rst(struct tcphdr *tcp,
const struct flow_key *flow, __u64 now)
{
struct challenge_pending *p = bpf_map_lookup_elem(&challenge_pending, flow);
if (!p)
return CHAL_CONTINUE;
__u64 timeout_ns = (__u64)G_CHALLENGE_TIMEOUT_MS * 1000000ULL;
__u32 seq = bpf_ntohl(tcp->seq);
__u32 ack = bpf_ntohl(tcp->ack_seq);
__u8 ok = (seq == p->bad_ack) ||
(tcp->ack && ack == p->marker + 1);
__u64 sent_at = p->sent_at;
// Copy every field needed before deleting: an LRU element may be freed
// as soon as it is removed, so p must never be dereferenced afterwards.
bpf_map_delete_elem(&challenge_pending, flow);
if (!ok || now - sent_at > timeout_ns) {
inc_chal_failed();
return XDP_DROP;
}
__u64 seen = now;
bpf_map_update_elem(&challenge_verified, &flow->src_ip, &seen, BPF_ANY);
inc_chal_verified();
return XDP_DROP; // client app will retry connect; next SYN passes
}
#endif /* RAMPART_SYN_CHALLENGE_H */