guard/xdp/core/maps.h
loki5512344 a8a3057719
feat(xdp): IPv6 UDP rate limit, working loader; English comments and docs
XDP behaviour:
- udp_rate_limit6 (LRU, full 128-bit source key) plus throttle_hit6, so
  udp_policy = "rate-limit" applies to native IPv6 as well.
- scripts/xdp_ipv6_smoke.sh: phase 4 patches .rodata before load and
  verifies policy=2 on a real kernel (3 pass / 3 rate-limited).

Loader (XDP could never load before this):
- .rodata is one struct rampart_config with frozen offsets enforced by
  _Static_assert; XdpGlobals is #[repr(C)] and the image is built with
  offset_of!. Before, a 96-byte image was written into a 76-byte map at
  offsets clang had reordered, so load() failed with EINVAL.
- patch_rodata fails loudly when the map size and image size diverge.
- build.rs tracks xdp/core and xdp/hooks, not just universal_filter.c.
- build_ringbuf looked for "events_map"; the map is "events_ringbuf".
- tests/xdp_object_maps.rs checks map names and .rodata size without root.

Docs and style:
- Code comments are English, JavaDoc/Rustdoc style, without emoji or
  banners (new project rule, TODO §0.8).
- README rewritten bilingual: Russian first, English below, nav buttons,
  compact TOC and copy-paste quick start.
- docs/README.md: documentation index and maintenance rules;
  configuration.md documents the whole [xdp] section and IPv4/IPv6
  coverage; testing.md covers the real-kernel smoke; stale links removed.
2026-11-15 23:50:52 +01:00

172 lines
5.1 KiB
C

#ifndef RAMPART_MAPS_H
#define RAMPART_MAPS_H
/**
* IPv4 blacklist.
*
* An LPM trie so operators can ban a CIDR range rather than single hosts.
* The value is the ban expiry as a bpf_ktime_get_ns() timestamp; expired
* entries are removed lazily by the lookup helpers. BPF_F_NO_PREALLOC is
* required by the LPM trie type.
*/
struct {
__uint(type, BPF_MAP_TYPE_LPM_TRIE);
__uint(max_entries, 100000);
__type(key, struct lpm_key);
__type(value, __u64); // ban expiry (ktime_ns)
__uint(map_flags, BPF_F_NO_PREALLOC);
} blacklist_map SEC(".maps");
/**
* IPv6 blacklist.
*
* LPM trie over 128-bit prefix keys, the exact analogue of blacklist_map:
* same expiry semantics, same required map flags.
*/
struct {
__uint(type, BPF_MAP_TYPE_LPM_TRIE);
__uint(max_entries, 100000);
__type(key, struct lpm_key6);
__type(value, __u64); // ban expiry (ktime_ns)
__uint(map_flags, BPF_F_NO_PREALLOC);
} blacklist6_map SEC(".maps");
/**
* Whitelist.
*
* LPM trie of trusted CIDRs; the filter consults it before any other check
* so allowlisted traffic can never be throttled or banned away.
*/
struct {
__uint(type, BPF_MAP_TYPE_LPM_TRIE);
__uint(max_entries, 1000);
__type(key, struct lpm_key);
__type(value, __u8);
__uint(map_flags, BPF_F_NO_PREALLOC);
} whitelist_map SEC(".maps");
/**
* Connection tracking table (SYN_RECEIVED to ESTABLISHED).
*
* LRU so a flood of half-open flows evicts old entries instead of failing
* map updates; RST/FIN removes entries explicitly on the normal path.
*/
struct {
__uint(type, BPF_MAP_TYPE_LRU_HASH);
__uint(max_entries, 16384);
__type(key, struct flow_key);
__type(value, struct conntrack_entry);
} conntrack_map SEC(".maps");
/**
* Per-source SYN throttle state.
*
* LRU keeps memory bounded under spoofed-source floods, where the number of
* distinct keys is unbounded and an exact table would simply fill up.
*/
struct {
__uint(type, BPF_MAP_TYPE_LRU_HASH);
__uint(max_entries, 65535);
__type(key, __u32); // src_ip
__type(value, struct throttle_entry);
} connection_throttle SEC(".maps");
/**
* Per-source UDP rate-limit state.
*
* The window and threshold come from G_UDP_POLICY / G_UDP_HIT_COUNT, so the
* same map serves pass, drop and rate-limit modes without reloading.
*/
struct {
__uint(type, BPF_MAP_TYPE_LRU_HASH);
__uint(max_entries, 65535);
__type(key, __u32); // src_ip
__type(value, struct throttle_entry);
} udp_rate_limit SEC(".maps");
/**
* IPv6 twin of udp_rate_limit.
*
* Native IPv6 has no 32-bit source address to key on, so the key is the full
* 128-bit address; the value and window contract are identical.
*/
struct {
__uint(type, BPF_MAP_TYPE_LRU_HASH);
__uint(max_entries, 65535);
__type(key, struct in6_addr); // src6
__type(value, struct throttle_entry);
} udp_rate_limit6 SEC(".maps");
/**
* RST-challenge pending state, one record per challenged flow.
*
* marker is our chosen ISN and bad_ack is the deliberately unacceptable
* acknowledgement we sent; either one echoed back proves the source saw the
* challenge, so both are kept until the proof arrives or the TTL expires.
*/
struct challenge_pending {
__u64 sent_at; // ktime_ns of the reflected SYN-ACK
__u32 marker; // our ISN (client may echo it as ack)
__u32 bad_ack; // bogus ack sent (live client echoes it as RST seq)
};
/**
* Sources that already passed the RST challenge.
*
* The value is the last time the source proved liveness: the TTL is slid
* forward on each verified SYN, and LRU eviction is the hard cap when more
* sources are active than the table holds.
*/
struct {
__uint(type, BPF_MAP_TYPE_LRU_HASH);
__uint(max_entries, 65536);
__type(key, __u32); // src_ip
__type(value, __u64); // last_seen (ktime_ns)
} challenge_verified SEC(".maps");
/**
* Outstanding challenges, keyed by the flow 4-tuple.
*
* Keyed per flow rather than per source so two concurrent connections from
* the same host cannot overwrite each other's expected proof.
*/
struct {
__uint(type, BPF_MAP_TYPE_LRU_HASH);
__uint(max_entries, 16384);
__type(key, struct flow_key);
__type(value, struct challenge_pending);
} challenge_pending SEC(".maps");
/**
* Statistics counters, indexed by the STAT_* constants below.
*
* Per-CPU array: increments need no atomics between CPUs, userspace sums the
* per-CPU values when it reads the map.
*/
#define STAT_TOTAL 0
#define STAT_TCP 1
#define STAT_WHITELIST 2
#define STAT_BLACKLIST 3
#define STAT_SYN_THROTTLE 4
#define STAT_PASS 5
#define STAT_DROP 6
#define STAT_UDP 7
#define STAT_RATE_LIMIT 8
#define STAT_CHALLENGE_SENT 9
#define STAT_CHALLENGE_VERIFIED 10
#define STAT_CHALLENGE_FAILED 11
/**
* Per-CPU counter storage.
*
* max_entries is rounded up past the highest STAT_* index so slots can be
* added without touching the map definition.
*/
struct {
__uint(type, BPF_MAP_TYPE_PERCPU_ARRAY);
__uint(max_entries, 16);
__type(key, __u32);
__type(value, __u64);
} stats_map SEC(".maps");
#endif /* RAMPART_MAPS_H */