guard/tests/filter_logic.rs
loki5512344 918e561a61
feat(xdp): IPv6 UDP rate limit, working loader; English JavaDoc comments
XDP behaviour:
- udp_rate_limit6 (LRU, 128-bit source key) + throttle_hit6, so
  udp_policy = "rate-limit" now 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).

XDP loader (was completely broken, never reached the verifier):
- .rodata is now one struct rampart_config with frozen offsets enforced by
  _Static_assert; XdpGlobals is #[repr(C)] and the image is built with
  offset_of!. Previously 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 the 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: verifies map names and .rodata size without root;
  the real binary was confirmed to attach in a netns.

Docs and style:
- Code comments are English, JavaDoc/Rustdoc style, without emoji or
  decorative banners (new project rule, TODO §0.8).
- README rewritten bilingual: Russian first, English below, 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 describes the real-kernel smoke; stale research links removed.
2026-11-15 23:44:07 +01:00

59 lines
1.8 KiB
Rust

//! Integration tests for the accept-path filters: token-bucket rate limiting
//! and blacklist TTL handling.
use std::net::{IpAddr, Ipv4Addr};
use std::time::Duration;
use rampart::filter::blacklist::Blacklist;
use rampart::filter::rate_limit::RateLimiter;
fn ip(octet: u8) -> IpAddr {
IpAddr::V4(Ipv4Addr::new(192, 168, 0, octet))
}
#[test]
fn rate_limiter_allows_burst_then_blocks() {
let limiter = RateLimiter::new(1.0, 3.0);
for _ in 0..3 {
assert!(limiter.check(ip(1)), "burst tokens must be available");
}
assert!(!limiter.check(ip(1)), "exhausted bucket must block");
assert!(limiter.check(ip(2)), "other IPs are independent buckets");
}
#[test]
fn rate_limiter_refills_over_time() {
let limiter = RateLimiter::new(100.0, 1.0);
assert!(limiter.check(ip(3)));
assert!(!limiter.check(ip(3)));
std::thread::sleep(Duration::from_millis(30));
assert!(limiter.check(ip(3)), "tokens must refill at configured rate");
}
#[test]
fn rate_limiter_buckets_are_independent() {
let limiter = RateLimiter::new(1.0, 1.0);
assert!(limiter.check(ip(4)));
assert!(!limiter.check(ip(4)));
assert!(limiter.check(ip(5)), "other IPs are independent buckets");
}
#[test]
fn blacklist_blocks_until_ttl_expires() {
let blacklist = Blacklist::new();
blacklist.add(ip(6), Duration::from_millis(30), "test");
assert!(blacklist.is_blocked(ip(6)), "fresh ban must block");
assert_eq!(blacklist.len(), 1);
std::thread::sleep(Duration::from_millis(40));
assert!(!blacklist.is_blocked(ip(6)), "expired ban must not block");
assert!(blacklist.is_empty(), "expired entry must be dropped on check");
}
#[test]
fn blacklist_remove_clears_ban() {
let blacklist = Blacklist::new();
blacklist.add(ip(7), Duration::from_secs(60), "test");
blacklist.remove(ip(7));
assert!(!blacklist.is_blocked(ip(7)));
}