Compare commits
No commits in common. "15f3fcb895c5be1e525da7f4093c8a00959e6b95" and "08b7292ac4e0b00a6caa2709e382ed2e4abd806d" have entirely different histories.
15f3fcb895
...
08b7292ac4
20 changed files with 182 additions and 1163 deletions
228
Cargo.lock
generated
228
Cargo.lock
generated
|
|
@ -26,12 +26,6 @@ dependencies = [
|
|||
"libc",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "anes"
|
||||
version = "0.1.6"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "4b46cbb362ab8752921c97e041f5e366ee6297bd428a31275b9fcf1e380f7299"
|
||||
|
||||
[[package]]
|
||||
name = "anstream"
|
||||
version = "1.0.0"
|
||||
|
|
@ -310,12 +304,6 @@ version = "1.12.1"
|
|||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "fc652a48c352aef3ea3aed32080501cf3ef6ed5da78602a020c991775b0aff04"
|
||||
|
||||
[[package]]
|
||||
name = "cast"
|
||||
version = "0.3.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5"
|
||||
|
||||
[[package]]
|
||||
name = "castaway"
|
||||
version = "0.2.4"
|
||||
|
|
@ -374,33 +362,6 @@ dependencies = [
|
|||
"windows-link",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "ciborium"
|
||||
version = "0.2.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "42e69ffd6f0917f5c029256a24d0161db17cea3997d185db0d35926308770f0e"
|
||||
dependencies = [
|
||||
"ciborium-io",
|
||||
"ciborium-ll",
|
||||
"serde",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "ciborium-io"
|
||||
version = "0.2.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "05afea1e0a06c9be33d539b876f1ce3692f4afea2cb41f740e7743225ed1c757"
|
||||
|
||||
[[package]]
|
||||
name = "ciborium-ll"
|
||||
version = "0.2.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "57663b653d948a338bfb3eeba9bb2fd5fcfaecb9e199e87e1eda4d9e8b240fd9"
|
||||
dependencies = [
|
||||
"ciborium-io",
|
||||
"half",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "clap"
|
||||
version = "4.6.7"
|
||||
|
|
@ -533,67 +494,12 @@ dependencies = [
|
|||
"libc",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "criterion"
|
||||
version = "0.5.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "f2b12d017a929603d80db1831cd3a24082f8137ce19c69e6447f54f5fc8d692f"
|
||||
dependencies = [
|
||||
"anes",
|
||||
"cast",
|
||||
"ciborium",
|
||||
"clap",
|
||||
"criterion-plot",
|
||||
"is-terminal",
|
||||
"itertools 0.10.5",
|
||||
"num-traits",
|
||||
"once_cell",
|
||||
"oorandom",
|
||||
"plotters",
|
||||
"rayon",
|
||||
"regex",
|
||||
"serde",
|
||||
"serde_derive",
|
||||
"serde_json",
|
||||
"tinytemplate",
|
||||
"walkdir",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "criterion-plot"
|
||||
version = "0.5.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "6b50826342786a51a89e2da3a28f1c32b06e387201bc2d19791f622c673706b1"
|
||||
dependencies = [
|
||||
"cast",
|
||||
"itertools 0.10.5",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "critical-section"
|
||||
version = "1.2.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "790eea4361631c5e7d22598ecd5723ff611904e3344ce8720784c93e3d83d40b"
|
||||
|
||||
[[package]]
|
||||
name = "crossbeam-deque"
|
||||
version = "0.8.8"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "622f3fc73690be383c7214310406f28a90e6edeadc3cea882f9d71e495b9711a"
|
||||
dependencies = [
|
||||
"crossbeam-epoch",
|
||||
"crossbeam-utils",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "crossbeam-epoch"
|
||||
version = "0.9.21"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "dc74980687109a3b14c72fd458107bf0baa1da1a1a805e178d15501ba9b86d9d"
|
||||
dependencies = [
|
||||
"crossbeam-utils",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "crossbeam-utils"
|
||||
version = "0.8.23"
|
||||
|
|
@ -627,12 +533,6 @@ dependencies = [
|
|||
"winapi",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "crunchy"
|
||||
version = "0.2.4"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5"
|
||||
|
||||
[[package]]
|
||||
name = "crypto-common"
|
||||
version = "0.1.7"
|
||||
|
|
@ -1051,17 +951,6 @@ dependencies = [
|
|||
"wasm-bindgen",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "half"
|
||||
version = "2.7.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "6ea2d84b969582b4b1864a92dc5d27cd2b77b622a8d79306834f1be5ba20d84b"
|
||||
dependencies = [
|
||||
"cfg-if",
|
||||
"crunchy",
|
||||
"zerocopy",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "hashbrown"
|
||||
version = "0.14.5"
|
||||
|
|
@ -1085,12 +974,6 @@ version = "0.5.0"
|
|||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
|
||||
|
||||
[[package]]
|
||||
name = "hermit-abi"
|
||||
version = "0.5.3"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "e17592d60ebacc7d5e169f4663c5f84f9161cc90328abcfe8456f41e4dfcb284"
|
||||
|
||||
[[package]]
|
||||
name = "hex"
|
||||
version = "0.4.3"
|
||||
|
|
@ -1388,32 +1271,12 @@ version = "0.21.1"
|
|||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "cf370abdafd54d13e54a620e8c3e1145f28e46cc9d704bc6d94414559df41763"
|
||||
|
||||
[[package]]
|
||||
name = "is-terminal"
|
||||
version = "0.4.17"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "3640c1c38b8e4e43584d8df18be5fc6b0aa314ce6ebf51b53313d4306cca8e46"
|
||||
dependencies = [
|
||||
"hermit-abi",
|
||||
"libc",
|
||||
"windows-sys 0.61.2",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "is_terminal_polyfill"
|
||||
version = "1.70.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "a6cb138bb79a146c1bd460005623e142ef0181e3d0219cb493e02f7d08a35695"
|
||||
|
||||
[[package]]
|
||||
name = "itertools"
|
||||
version = "0.10.5"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "b0fd2260e829bddf4cb6ea802289de2f86d6a7a690192fbe91b3f46e0f2c8473"
|
||||
dependencies = [
|
||||
"either",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "itertools"
|
||||
version = "0.14.0"
|
||||
|
|
@ -1840,12 +1703,6 @@ version = "1.70.2"
|
|||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "384b8ab6d37215f3c5301a95a4accb5d64aa607f1fcb26a11b5303878451b4fe"
|
||||
|
||||
[[package]]
|
||||
name = "oorandom"
|
||||
version = "11.1.5"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "d6790f58c7ff633d8771f42965289203411a5e5c68388703c06e14f24770b41e"
|
||||
|
||||
[[package]]
|
||||
name = "openssl-probe"
|
||||
version = "0.2.1"
|
||||
|
|
@ -2047,34 +1904,6 @@ version = "0.3.34"
|
|||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "f6b464fbc74e149a392436b17d523f769e057cb6877f6a5c4618bc6f11800548"
|
||||
|
||||
[[package]]
|
||||
name = "plotters"
|
||||
version = "0.3.7"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "5aeb6f403d7a4911efb1e33402027fc44f29b5bf6def3effcc22d7bb75f2b747"
|
||||
dependencies = [
|
||||
"num-traits",
|
||||
"plotters-backend",
|
||||
"plotters-svg",
|
||||
"wasm-bindgen",
|
||||
"web-sys",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "plotters-backend"
|
||||
version = "0.3.7"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "df42e13c12958a16b3f7f4386b9ab1f3e7933914ecea48da7139435263a4172a"
|
||||
|
||||
[[package]]
|
||||
name = "plotters-svg"
|
||||
version = "0.3.7"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "51bae2ac328883f7acdfea3d66a7c35751187f870bc81f94563733a154d7a670"
|
||||
dependencies = [
|
||||
"plotters-backend",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "portable-atomic"
|
||||
version = "1.15.0"
|
||||
|
|
@ -2259,7 +2088,6 @@ dependencies = [
|
|||
"axum",
|
||||
"chrono",
|
||||
"clap",
|
||||
"criterion",
|
||||
"crossterm",
|
||||
"dashmap",
|
||||
"futures",
|
||||
|
|
@ -2358,7 +2186,7 @@ dependencies = [
|
|||
"compact_str",
|
||||
"critical-section",
|
||||
"hashbrown 0.17.1",
|
||||
"itertools 0.14.0",
|
||||
"itertools",
|
||||
"kasuari",
|
||||
"lru",
|
||||
"palette",
|
||||
|
|
@ -2423,7 +2251,7 @@ dependencies = [
|
|||
"hashbrown 0.17.1",
|
||||
"indoc",
|
||||
"instability",
|
||||
"itertools 0.14.0",
|
||||
"itertools",
|
||||
"line-clipping",
|
||||
"ratatui-core",
|
||||
"serde",
|
||||
|
|
@ -2433,26 +2261,6 @@ dependencies = [
|
|||
"unicode-width",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "rayon"
|
||||
version = "1.12.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "fb39b166781f92d482534ef4b4b1b2568f42613b53e5b6c160e24cfbfa30926d"
|
||||
dependencies = [
|
||||
"either",
|
||||
"rayon-core",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "rayon-core"
|
||||
version = "1.13.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "22e18b0f0062d30d4230b2e85ff77fdfe4326feb054b9783a3460d8435c8ab91"
|
||||
dependencies = [
|
||||
"crossbeam-deque",
|
||||
"crossbeam-utils",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "redis"
|
||||
version = "1.7.1"
|
||||
|
|
@ -3244,16 +3052,6 @@ dependencies = [
|
|||
"zerovec",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "tinytemplate"
|
||||
version = "1.2.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "be4d6b5f19ff7664e8c98d03e2139cb510db9b0a60b55f8e8709b689d939b6bc"
|
||||
dependencies = [
|
||||
"serde",
|
||||
"serde_json",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "tinyvec"
|
||||
version = "1.13.3"
|
||||
|
|
@ -3535,7 +3333,7 @@ version = "2.0.1"
|
|||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "16b380a1238663e5f8a691f9039c73e1cdae598a30e9855f541d29b08b53e9a5"
|
||||
dependencies = [
|
||||
"itertools 0.14.0",
|
||||
"itertools",
|
||||
"unicode-segmentation",
|
||||
"unicode-width",
|
||||
]
|
||||
|
|
@ -4044,26 +3842,6 @@ dependencies = [
|
|||
"synstructure",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "zerocopy"
|
||||
version = "0.8.63"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "e5fe1f8f1b06191a00962174c61aa5005e0bb391a6d80d07e24d115c01a92ed8"
|
||||
dependencies = [
|
||||
"zerocopy-derive",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "zerocopy-derive"
|
||||
version = "0.8.63"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "863ad3ac83293fb4d740aedbfdc9240dd8d1a50c1099acd76ce80ce7c7230c7f"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"syn 2.0.119",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "zerofrom"
|
||||
version = "0.1.8"
|
||||
|
|
|
|||
|
|
@ -80,10 +80,3 @@ libc = { version = "0.2", optional = true }
|
|||
[dev-dependencies]
|
||||
# `ServiceExt::oneshot` drives the axum router in integration tests.
|
||||
tower = { version = "0.5", features = ["util"] }
|
||||
# Micro-benchmarks of the per-connection hot path (`cargo bench --all-features`).
|
||||
criterion = { version = "0.5", features = ["html_reports"] }
|
||||
|
||||
[[bench]]
|
||||
name = "hot_paths"
|
||||
harness = false
|
||||
required-features = ["protocol-http"]
|
||||
|
|
|
|||
5
Makefile
5
Makefile
|
|
@ -3,7 +3,7 @@
|
|||
CARGO = cargo
|
||||
TARGET_DIR = target
|
||||
|
||||
.PHONY: all build release test test-all check check-all fmt fmt-check clippy clean deny audit fuzz bench
|
||||
.PHONY: all build release test test-all check check-all fmt fmt-check clippy clean deny audit fuzz
|
||||
.PHONY: ebpf ebpf-clean
|
||||
.PHONY: docker docker-build docker-up docker-down docker-logs
|
||||
.PHONY: ci ci-full repo-gates
|
||||
|
|
@ -78,9 +78,6 @@ docker-logs:
|
|||
checkstyle: fmt-check clippy
|
||||
@echo "✓ Checkstyle passed (rustfmt + clippy)"
|
||||
|
||||
bench:
|
||||
$(CARGO) bench --all-features --bench hot_paths
|
||||
|
||||
# Parser fuzzing (nightly + cargo-fuzz). 60 s per target is a smoke run;
|
||||
# longer campaigns are run locally before a release.
|
||||
fuzz:
|
||||
|
|
|
|||
7
TODO.md
7
TODO.md
|
|
@ -287,10 +287,9 @@ module-size, secrets, `cargo deny`, rustdoc без warning'ов, clang+verifier,
|
|||
|
||||
### Осталось
|
||||
|
||||
- [x] Monitor (`add_cidr`) и `traffic/hook` autoban сверяются с `trusted_cidrs`: бан
|
||||
подавляется, если префикс пересекается с доверенной сетью (`TrustedProxyCidr::overlaps_prefix`),
|
||||
о чём пишется warn. Тесты: `tests/subnet_detection.rs`, `tests/traffic_intel.rs`,
|
||||
`tests/proxy_identity.rs`.
|
||||
- [ ] Monitor (`add_cidr`) и `traffic/hook` autoban не сверяются с `trusted_cidrs`: если
|
||||
доверенный прокси физически живёт в банимой подсети, его адрес может попасть под
|
||||
префиксный бан. Нужна общая проверка перед любым баном.
|
||||
|
||||
### Сделано в этом раунде
|
||||
|
||||
|
|
|
|||
|
|
@ -1,107 +0,0 @@
|
|||
//! Micro-benchmarks for the per-connection hot path.
|
||||
//!
|
||||
//! Run with `cargo bench --all-features --bench hot_paths`. Baseline numbers
|
||||
//! live in `docs/research/benchmark.md`; compare medians before and after a
|
||||
//! change instead of absolute values, which depend on the machine.
|
||||
|
||||
use std::net::{IpAddr, Ipv4Addr};
|
||||
use std::time::Duration;
|
||||
|
||||
use criterion::{Criterion, black_box, criterion_group, criterion_main};
|
||||
|
||||
use rampart::filter::blacklist::Blacklist;
|
||||
use rampart::filter::rate_limit::RateLimiter;
|
||||
use rampart::protocol::http::parser::{Policy, evaluate};
|
||||
use rampart::traffic::prefix::{PrefixSnapshot, SubnetDetector};
|
||||
|
||||
fn addr(last: u8) -> IpAddr {
|
||||
IpAddr::V4(Ipv4Addr::new(198, 51, 100, last))
|
||||
}
|
||||
|
||||
/// Token-bucket admission, the first filter on every accepted connection.
|
||||
fn bench_rate_limiter(c: &mut Criterion) {
|
||||
c.bench_function("rate_limiter/check", |b| {
|
||||
let limiter = RateLimiter::new(1_000_000.0, 1_000_000.0);
|
||||
let mut n = 0u32;
|
||||
b.iter(|| {
|
||||
n = n.wrapping_add(1);
|
||||
black_box(limiter.check(addr((n % 200) as u8)));
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
/// Exact-IP and CIDR lookups of the ban tables (both on the accept path).
|
||||
fn bench_blacklist(c: &mut Criterion) {
|
||||
let blacklist = Blacklist::new();
|
||||
for octet in 1..=200u8 {
|
||||
blacklist.add(addr(octet), Duration::from_secs(60), "bench");
|
||||
}
|
||||
blacklist.add_cidr(
|
||||
IpAddr::V4(Ipv4Addr::new(203, 0, 113, 0)),
|
||||
24,
|
||||
Duration::from_secs(60),
|
||||
"bench",
|
||||
);
|
||||
|
||||
c.bench_function("blacklist/is_blocked_exact", |b| {
|
||||
let mut n = 0u32;
|
||||
b.iter(|| {
|
||||
n = n.wrapping_add(1);
|
||||
black_box(blacklist.is_blocked(addr((n % 200) as u8 + 1)));
|
||||
});
|
||||
});
|
||||
|
||||
c.bench_function("blacklist/is_blocked_cidr", |b| {
|
||||
b.iter(|| black_box(blacklist.is_blocked(IpAddr::V4(Ipv4Addr::new(203, 0, 113, 42)))));
|
||||
});
|
||||
|
||||
c.bench_function("blacklist/is_blocked_miss", |b| {
|
||||
b.iter(|| black_box(blacklist.is_blocked(IpAddr::V4(Ipv4Addr::new(192, 0, 2, 1)))));
|
||||
});
|
||||
}
|
||||
|
||||
/// Subnet detector over a full window (called once per monitor tick).
|
||||
fn bench_detector(c: &mut Criterion) {
|
||||
let snapshots: Vec<(IpAddr, PrefixSnapshot)> = (0..256u32)
|
||||
.map(|i| {
|
||||
let prefix = IpAddr::V4(Ipv4Addr::new(10, (i / 256) as u8, (i % 256) as u8, 0));
|
||||
(
|
||||
prefix,
|
||||
PrefixSnapshot {
|
||||
syn_count: 120,
|
||||
pkt_count: 400,
|
||||
last_seen_ns: 0,
|
||||
unique_sources: 40,
|
||||
},
|
||||
)
|
||||
})
|
||||
.collect();
|
||||
let detector = SubnetDetector::new(100, 16);
|
||||
|
||||
c.bench_function("subnet_detector/evaluate_256", |b| {
|
||||
b.iter(|| black_box(detector.evaluate(black_box(&snapshots))));
|
||||
});
|
||||
}
|
||||
|
||||
/// HTTP request-head validation for every new HTTP connection.
|
||||
fn bench_http_parser(c: &mut Criterion) {
|
||||
let request = b"GET /api/v1/status HTTP/1.1\r\nHost: edge.example\r\nUser-Agent: bench/1.0\r\nAccept: */*\r\n\r\n";
|
||||
let policy = Policy {
|
||||
max_header_bytes: 8192,
|
||||
blocked_paths: vec!["/admin".to_string()],
|
||||
require_user_agent: true,
|
||||
};
|
||||
|
||||
c.bench_function("http_parser/evaluate", |b| {
|
||||
b.iter(|| black_box(evaluate(black_box(request), &policy)));
|
||||
});
|
||||
}
|
||||
|
||||
criterion_group!(
|
||||
hot_paths,
|
||||
bench_rate_limiter,
|
||||
bench_blacklist,
|
||||
bench_detector,
|
||||
bench_http_parser
|
||||
);
|
||||
criterion_main!(hot_paths);
|
||||
|
|
@ -31,14 +31,6 @@ cargo clippy --all-targets --all-features -- -D warnings
|
|||
cargo deny check
|
||||
```
|
||||
|
||||
E2E-сценарии живут в `tests/edge_e2e.rs`: реальный TCP-клиент через продакшн-accept-loop и
|
||||
pipeline до upstream на loopback (обычный HTTP, PoW с решённым и неверным nonce, rate-limit,
|
||||
blacklist). Root и внешняя сеть не нужны, каждый тест укладывается в 5 с:
|
||||
|
||||
```bash
|
||||
cargo test --all-features --test edge_e2e
|
||||
```
|
||||
|
||||
XDP: smoke-check компиляции BPF-программы:
|
||||
|
||||
```bash
|
||||
|
|
@ -99,30 +91,7 @@ cargo +nightly fuzz run proxy_v2 -- -max_total_time=600
|
|||
|
||||
---
|
||||
|
||||
## 4. Бенчмарки горячего пути
|
||||
|
||||
Микробенчмарки (criterion) для того, что выполняется на каждое соединение:
|
||||
|
||||
```bash
|
||||
cargo bench --all-features --bench hot_paths
|
||||
# HTML-отчёт: target/criterion/report/index.html
|
||||
```
|
||||
|
||||
Замеряются: `RateLimiter::check`, exact/CIDR/miss lookup в `Blacklist`, `SubnetDetector::evaluate`
|
||||
на окне из 256 префиксов и разбор HTTP request-head. Сравнивай медианы до/после изменения на
|
||||
одной машине; абсолютные числа зависят от CPU. Порядок величин на dev-машине (2 vCPU):
|
||||
|
||||
| Бенчмарк | Медиана |
|
||||
|----------|---------|
|
||||
| `rate_limiter/check` | ~110 ns |
|
||||
| `blacklist/is_blocked_exact` | ~70 ns |
|
||||
| `blacklist/is_blocked_cidr` | ~220 ns |
|
||||
| `subnet_detector/evaluate_256` | ~2.6 µs |
|
||||
| `http_parser/evaluate` | ~280 ns |
|
||||
|
||||
---
|
||||
|
||||
## 5. Локальный integration-стенд (Docker)
|
||||
## 3. Локальный integration-стенд (Docker)
|
||||
|
||||
```bash
|
||||
bash deploy/test/run_test.sh
|
||||
|
|
@ -133,7 +102,7 @@ attacker-контейнер. Сценарии — в [deploy/test/README.md](../
|
|||
|
||||
---
|
||||
|
||||
## 6. Нагрузочное тестирование
|
||||
## 4. Нагрузочное тестирование
|
||||
|
||||
### Много-IP TCP flood на VDS (edge-only)
|
||||
|
||||
|
|
@ -161,7 +130,7 @@ hping3 -S --flood -p 25565 --rand-source EDGE_IP # только на свои
|
|||
|
||||
---
|
||||
|
||||
## 7. Метрики для проверки во время теста
|
||||
## 5. Метрики для проверки во время теста
|
||||
|
||||
```bash
|
||||
curl -s http://localhost:9090/metrics | grep rampart_
|
||||
|
|
|
|||
|
|
@ -64,15 +64,12 @@ pub async fn run() -> anyhow::Result<RunExit> {
|
|||
let blacklist = Arc::new(Blacklist::new());
|
||||
let reputation = Arc::new(IpReputation::new());
|
||||
let detector = Arc::new(Mutex::new(AttackDetector::new()));
|
||||
let hook = Arc::new(
|
||||
TrafficHook::new(
|
||||
reputation.clone(),
|
||||
blacklist.clone(),
|
||||
config.detect.autoban.clone(),
|
||||
config.ban.ban_duration_secs,
|
||||
)
|
||||
.with_trusted(config.proxy_protocol.trusted_cidrs.clone()),
|
||||
);
|
||||
let hook = Arc::new(TrafficHook::new(
|
||||
reputation.clone(),
|
||||
blacklist.clone(),
|
||||
config.detect.autoban.clone(),
|
||||
config.ban.ban_duration_secs,
|
||||
));
|
||||
let alert_dispatcher = AlertDispatcher::new();
|
||||
let webhook_url = config.detect.alert.webhook_url.clone();
|
||||
let allowed_1s = Arc::new(AtomicU64::new(0));
|
||||
|
|
@ -135,14 +132,11 @@ pub async fn run() -> anyhow::Result<RunExit> {
|
|||
let subnet_tracker = start_subnet_tracker(&config);
|
||||
monitor::spawn(
|
||||
&config.detect.prefix,
|
||||
monitor::MonitorSetup {
|
||||
ban_ttl: Duration::from_secs(config.ban.ban_duration_secs),
|
||||
blacklist: blacklist.clone(),
|
||||
trusted_peer: !config.proxy_protocol.ingress_enabled,
|
||||
trusted_networks: config.proxy_protocol.trusted_cidrs.clone(),
|
||||
tracker: subnet_tracker.clone(),
|
||||
xdp: xdp_filter.clone(),
|
||||
},
|
||||
Duration::from_secs(config.ban.ban_duration_secs),
|
||||
blacklist.clone(),
|
||||
!config.proxy_protocol.ingress_enabled,
|
||||
subnet_tracker.clone(),
|
||||
xdp_filter.clone(),
|
||||
shutdown_rx.clone(),
|
||||
);
|
||||
|
||||
|
|
|
|||
|
|
@ -3,7 +3,6 @@
|
|||
//! Owns the [`Config`] root type, its serde defaults and the semantic validation
|
||||
//! that runs before the daemon binds a socket.
|
||||
mod sections;
|
||||
mod trusted;
|
||||
|
||||
#[cfg(feature = "protocol-http")]
|
||||
pub use sections::HttpProtocolConfig;
|
||||
|
|
@ -13,9 +12,9 @@ pub use sections::MinecraftProtocolConfig;
|
|||
pub use sections::ProtocolConfig;
|
||||
pub use sections::{
|
||||
BackendConfig, BanConfig, BindConfig, DetectAlertConfig, DetectAutobanConfig, DetectConfig, DetectPrefixConfig,
|
||||
LimitsConfig, LoggingConfig, MetricsConfig, PowConfig, ProxyProtocolConfig, StoreConfig, WorkerConfig, XdpConfig,
|
||||
LimitsConfig, LoggingConfig, MetricsConfig, PowConfig, ProxyProtocolConfig, StoreConfig, TrustedProxyCidr,
|
||||
WorkerConfig, XdpConfig,
|
||||
};
|
||||
pub use trusted::TrustedProxyCidr;
|
||||
|
||||
use serde::Deserialize;
|
||||
use std::fs;
|
||||
|
|
|
|||
|
|
@ -1,7 +1,8 @@
|
|||
//! Edge sections: bind, backend, workers, limits, ban, PoW and PROXY protocol.
|
||||
|
||||
use crate::config::trusted::TrustedProxyCidr;
|
||||
use serde::{Deserialize, Deserializer};
|
||||
use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
|
||||
use std::str::FromStr;
|
||||
|
||||
/// `[bind]` section: listen address and port of the edge node.
|
||||
#[derive(Debug, Clone, Deserialize)]
|
||||
|
|
@ -158,6 +159,66 @@ fn default_pow_difficulty() -> u8 {
|
|||
4
|
||||
}
|
||||
|
||||
/// CIDR network allowed to send inbound PROXY protocol headers.
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||
pub struct TrustedProxyCidr {
|
||||
network: IpAddr,
|
||||
prefix_len: u8,
|
||||
}
|
||||
|
||||
impl TrustedProxyCidr {
|
||||
/// Returns whether `ip` belongs to this network.
|
||||
#[must_use]
|
||||
pub fn contains(&self, ip: IpAddr) -> bool {
|
||||
// Masks are family-specific: a prefix above 32 would underflow the v4 shift.
|
||||
let prefix = self.prefix_len;
|
||||
match (self.network, ip) {
|
||||
(IpAddr::V4(net), IpAddr::V4(ip)) => u32::from(net) & mask_v4(prefix) == u32::from(ip) & mask_v4(prefix),
|
||||
(IpAddr::V6(net), IpAddr::V6(ip)) => u128::from(net) & mask_v6(prefix) == u128::from(ip) & mask_v6(prefix),
|
||||
_ => false,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl FromStr for TrustedProxyCidr {
|
||||
type Err = String;
|
||||
|
||||
fn from_str(value: &str) -> Result<Self, Self::Err> {
|
||||
let (address, prefix) = value.split_once('/').map_or((value, None), |(a, p)| (a, Some(p)));
|
||||
let network = IpAddr::from_str(address).map_err(|_| format!("invalid trusted proxy CIDR: {value}"))?;
|
||||
let max_prefix = if network.is_ipv4() { 32 } else { 128 };
|
||||
let prefix_len = prefix
|
||||
.map_or(Ok(max_prefix), |prefix| prefix.parse::<u8>())
|
||||
.map_err(|_| format!("invalid trusted proxy CIDR prefix: {value}"))?;
|
||||
if prefix_len > max_prefix {
|
||||
return Err(format!("trusted proxy CIDR prefix is too large: {value}"));
|
||||
}
|
||||
let network = match network {
|
||||
IpAddr::V4(ip) => IpAddr::V4(Ipv4Addr::from(u32::from(ip) & mask_v4(prefix_len))),
|
||||
IpAddr::V6(ip) => IpAddr::V6(Ipv6Addr::from(u128::from(ip) & mask_v6(prefix_len))),
|
||||
};
|
||||
Ok(Self { network, prefix_len })
|
||||
}
|
||||
}
|
||||
|
||||
impl<'de> Deserialize<'de> for TrustedProxyCidr {
|
||||
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
|
||||
where
|
||||
D: Deserializer<'de>,
|
||||
{
|
||||
let value = String::deserialize(deserializer)?;
|
||||
value.parse().map_err(serde::de::Error::custom)
|
||||
}
|
||||
}
|
||||
|
||||
fn mask_v4(prefix: u8) -> u32 {
|
||||
if prefix == 0 { 0 } else { u32::MAX << (32 - prefix) }
|
||||
}
|
||||
|
||||
fn mask_v6(prefix: u8) -> u128 {
|
||||
if prefix == 0 { 0 } else { u128::MAX << (128 - prefix) }
|
||||
}
|
||||
|
||||
/// `[proxy_protocol]` section: inbound PROXY protocol ingestion.
|
||||
#[derive(Debug, Clone, Deserialize)]
|
||||
pub struct ProxyProtocolConfig {
|
||||
|
|
|
|||
|
|
@ -11,5 +11,7 @@ pub use detect::MinecraftProtocolConfig;
|
|||
#[cfg(any(feature = "protocol-http", feature = "protocol-minecraft"))]
|
||||
pub use detect::ProtocolConfig;
|
||||
pub use detect::{DetectAlertConfig, DetectAutobanConfig, DetectConfig, DetectPrefixConfig};
|
||||
pub use edge::{BackendConfig, BanConfig, BindConfig, LimitsConfig, PowConfig, ProxyProtocolConfig, WorkerConfig};
|
||||
pub use edge::{
|
||||
BackendConfig, BanConfig, BindConfig, LimitsConfig, PowConfig, ProxyProtocolConfig, TrustedProxyCidr, WorkerConfig,
|
||||
};
|
||||
pub use platform::{LoggingConfig, MetricsConfig, StoreConfig, XdpConfig};
|
||||
|
|
|
|||
|
|
@ -1,108 +0,0 @@
|
|||
//! Trusted PROXY-protocol networks and CIDR helpers shared by the edge paths.
|
||||
|
||||
use serde::{Deserialize, Deserializer};
|
||||
use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
|
||||
use std::str::FromStr;
|
||||
|
||||
/// CIDR network allowed to send inbound PROXY protocol headers.
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||
pub struct TrustedProxyCidr {
|
||||
network: IpAddr,
|
||||
prefix_len: u8,
|
||||
}
|
||||
|
||||
impl TrustedProxyCidr {
|
||||
/// Returns whether `ip` belongs to this network.
|
||||
#[must_use]
|
||||
pub fn contains(&self, ip: IpAddr) -> bool {
|
||||
// Masks are family-specific: a prefix above 32 would underflow the v4 shift.
|
||||
let prefix = self.prefix_len;
|
||||
match (self.network, normalize(ip)) {
|
||||
(IpAddr::V4(net), IpAddr::V4(ip)) => u32::from(net) & mask_v4(prefix) == u32::from(ip) & mask_v4(prefix),
|
||||
(IpAddr::V6(net), IpAddr::V6(ip)) => u128::from(net) & mask_v6(prefix) == u128::from(ip) & mask_v6(prefix),
|
||||
_ => false,
|
||||
}
|
||||
}
|
||||
|
||||
/// Returns whether `ip/prefix_len` intersects this network.
|
||||
///
|
||||
/// Used before banning a prefix: a ban covering a trusted proxy address
|
||||
/// would punish the proxy and every client behind it.
|
||||
#[must_use]
|
||||
pub fn overlaps_prefix(&self, ip: IpAddr, prefix_len: u8) -> bool {
|
||||
match (self.network, normalize(ip)) {
|
||||
(IpAddr::V4(net), IpAddr::V4(other)) => {
|
||||
if prefix_len == 0 || prefix_len > 32 {
|
||||
return false;
|
||||
}
|
||||
let net_mask = mask_v4(self.prefix_len);
|
||||
let other_mask = mask_v4(prefix_len);
|
||||
let net_start = u32::from(net) & net_mask;
|
||||
let net_end = net_start | !net_mask;
|
||||
let other_start = u32::from(other) & other_mask;
|
||||
let other_end = other_start | !other_mask;
|
||||
net_start <= other_end && other_start <= net_end
|
||||
},
|
||||
(IpAddr::V6(net), IpAddr::V6(other)) => {
|
||||
if prefix_len == 0 || prefix_len > 128 {
|
||||
return false;
|
||||
}
|
||||
let net_mask = mask_v6(self.prefix_len);
|
||||
let other_mask = mask_v6(prefix_len);
|
||||
let net_start = u128::from(net) & net_mask;
|
||||
let net_end = net_start | !net_mask;
|
||||
let other_start = u128::from(other) & other_mask;
|
||||
let other_end = other_start | !other_mask;
|
||||
net_start <= other_end && other_start <= net_end
|
||||
},
|
||||
_ => false,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl FromStr for TrustedProxyCidr {
|
||||
type Err = String;
|
||||
|
||||
fn from_str(value: &str) -> Result<Self, Self::Err> {
|
||||
let (address, prefix) = value.split_once('/').map_or((value, None), |(a, p)| (a, Some(p)));
|
||||
let network = IpAddr::from_str(address).map_err(|_| format!("invalid trusted proxy CIDR: {value}"))?;
|
||||
let max_prefix = if network.is_ipv4() { 32 } else { 128 };
|
||||
let prefix_len = prefix
|
||||
.map_or(Ok(max_prefix), |prefix| prefix.parse::<u8>())
|
||||
.map_err(|_| format!("invalid trusted proxy CIDR prefix: {value}"))?;
|
||||
if prefix_len > max_prefix {
|
||||
return Err(format!("trusted proxy CIDR prefix is too large: {value}"));
|
||||
}
|
||||
let network = match network {
|
||||
IpAddr::V4(ip) => IpAddr::V4(Ipv4Addr::from(u32::from(ip) & mask_v4(prefix_len))),
|
||||
IpAddr::V6(ip) => IpAddr::V6(Ipv6Addr::from(u128::from(ip) & mask_v6(prefix_len))),
|
||||
};
|
||||
Ok(Self { network, prefix_len })
|
||||
}
|
||||
}
|
||||
|
||||
impl<'de> Deserialize<'de> for TrustedProxyCidr {
|
||||
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
|
||||
where
|
||||
D: Deserializer<'de>,
|
||||
{
|
||||
let value = String::deserialize(deserializer)?;
|
||||
value.parse().map_err(serde::de::Error::custom)
|
||||
}
|
||||
}
|
||||
|
||||
/// Collapses IPv4-mapped IPv6 addresses to IPv4.
|
||||
fn normalize(ip: IpAddr) -> IpAddr {
|
||||
match ip {
|
||||
IpAddr::V6(v6) => v6.to_ipv4_mapped().map_or(ip, IpAddr::V4),
|
||||
IpAddr::V4(_) => ip,
|
||||
}
|
||||
}
|
||||
|
||||
fn mask_v4(prefix: u8) -> u32 {
|
||||
if prefix == 0 { 0 } else { u32::MAX << (32 - prefix) }
|
||||
}
|
||||
|
||||
fn mask_v6(prefix: u8) -> u128 {
|
||||
if prefix == 0 { 0 } else { u128::MAX << (128 - prefix) }
|
||||
}
|
||||
|
|
@ -1,108 +0,0 @@
|
|||
//! Verdict enforcement: turning subnet `Block` verdicts into bans.
|
||||
//!
|
||||
//! Kept apart from [`super::monitor`] so the monitor task and the ban policy
|
||||
//! stay within the module-size budget.
|
||||
|
||||
use crate::filter::blacklist::Blacklist;
|
||||
use crate::traffic::prefix::{PrefixVerdict, SubnetVerdict};
|
||||
use std::net::IpAddr;
|
||||
use std::sync::Arc;
|
||||
use std::time::Duration;
|
||||
|
||||
/// Verdict enforcement settings shared by every snapshot tick.
|
||||
pub(super) struct BanPolicy {
|
||||
pub(super) blacklist: Arc<Blacklist>,
|
||||
pub(super) ttl: Duration,
|
||||
pub(super) trusted: bool,
|
||||
/// Trusted PROXY-protocol networks; a prefix ban overlapping one of them is
|
||||
/// suppressed, because it would punish the proxy and every client behind it.
|
||||
pub(super) trusted_networks: Vec<crate::config::TrustedProxyCidr>,
|
||||
}
|
||||
|
||||
/// Applies userspace `Block` verdicts to the shared blacklist.
|
||||
///
|
||||
/// Returns the number of banned prefixes. When `trusted` is false the observed
|
||||
/// addresses belong to an unverified ingress path, so the verdict is only logged
|
||||
/// at warn level and no ban is installed.
|
||||
///
|
||||
/// The ban is inserted as a CIDR range, so every address inside the detected
|
||||
/// `/24` or `/64` is blocked, not just its network address.
|
||||
pub fn enforce_tracker_verdicts(
|
||||
verdicts: &[PrefixVerdict],
|
||||
blacklist: &Blacklist,
|
||||
ttl: Duration,
|
||||
trusted: bool,
|
||||
trusted_networks: &[crate::config::TrustedProxyCidr],
|
||||
) -> usize {
|
||||
let mut banned = 0;
|
||||
for pv in verdicts.iter().filter(|pv| pv.verdict == SubnetVerdict::Block) {
|
||||
if !trusted {
|
||||
tracing::warn!(
|
||||
prefix = %pv.prefix,
|
||||
"subnet block verdict on an untrusted peer path; not adding to the blacklist"
|
||||
);
|
||||
continue;
|
||||
}
|
||||
if overlaps_trusted(pv.prefix, trusted_networks) {
|
||||
tracing::warn!(
|
||||
prefix = %pv.prefix,
|
||||
"subnet ban suppressed: the prefix contains a trusted proxy network"
|
||||
);
|
||||
continue;
|
||||
}
|
||||
blacklist.add_cidr(pv.prefix, prefix_len(pv.prefix), ttl, "subnet_attack");
|
||||
banned += 1;
|
||||
tracing::warn!(
|
||||
prefix = %pv.prefix,
|
||||
ttl_secs = ttl.as_secs(),
|
||||
"subnet blocked in the userspace blacklist"
|
||||
);
|
||||
}
|
||||
banned
|
||||
}
|
||||
|
||||
/// Installs XDP prefix bans for `Block` verdicts.
|
||||
#[cfg(feature = "xdp")]
|
||||
pub(super) fn ban_xdp_verdicts(
|
||||
xdp: &crate::traffic::prefix::XdpPrefixStats,
|
||||
verdicts: &[PrefixVerdict],
|
||||
ttl: Duration,
|
||||
trusted_networks: &[crate::config::TrustedProxyCidr],
|
||||
) {
|
||||
for pv in verdicts.iter().filter(|pv| pv.verdict == SubnetVerdict::Block) {
|
||||
if overlaps_trusted(pv.prefix, trusted_networks) {
|
||||
tracing::warn!(
|
||||
prefix = %pv.prefix,
|
||||
"subnet kernel ban suppressed: the prefix contains a trusted proxy network"
|
||||
);
|
||||
continue;
|
||||
}
|
||||
let result = {
|
||||
let guard = xdp.filter_lock();
|
||||
guard.ban_cidr(pv.prefix, prefix_len(pv.prefix), ttl.as_secs())
|
||||
};
|
||||
match result {
|
||||
Ok(()) => tracing::warn!(
|
||||
prefix = %pv.prefix,
|
||||
ttl_secs = ttl.as_secs(),
|
||||
"subnet blocked in XDP"
|
||||
),
|
||||
Err(e) => tracing::warn!("subnet block failed for {}: {e}", pv.prefix),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Returns whether a ban of `prefix/prefix_len` would cover a trusted proxy.
|
||||
fn overlaps_trusted(prefix: IpAddr, trusted_networks: &[crate::config::TrustedProxyCidr]) -> bool {
|
||||
trusted_networks
|
||||
.iter()
|
||||
.any(|net| net.overlaps_prefix(prefix, prefix_len(prefix)))
|
||||
}
|
||||
|
||||
/// Prefix length matching the detection granularity (v4 /24, v6 /64).
|
||||
pub(super) fn prefix_len(prefix: IpAddr) -> u8 {
|
||||
match prefix {
|
||||
IpAddr::V4(_) => 24,
|
||||
IpAddr::V6(_) => 64,
|
||||
}
|
||||
}
|
||||
|
|
@ -1,4 +1,3 @@
|
|||
//! Subnet-level detector: userspace prefix aggregator and verdict monitor.
|
||||
mod enforce;
|
||||
pub mod monitor;
|
||||
pub mod tracker;
|
||||
|
|
|
|||
|
|
@ -4,9 +4,6 @@
|
|||
//! (feature `xdp` with a loaded filter) or the userspace aggregator
|
||||
//! [`SubnetTracker`].
|
||||
|
||||
use super::enforce::BanPolicy;
|
||||
#[cfg(feature = "xdp")]
|
||||
use super::enforce::ban_xdp_verdicts;
|
||||
use crate::config::DetectPrefixConfig;
|
||||
use crate::engine::subnet_tracker::{SubnetTracker, TrackerSource};
|
||||
use crate::filter::blacklist::Blacklist;
|
||||
|
|
@ -20,8 +17,6 @@ use std::sync::{Arc, Mutex};
|
|||
use std::time::Duration;
|
||||
use tokio::sync::watch;
|
||||
|
||||
pub use super::enforce::enforce_tracker_verdicts;
|
||||
|
||||
enum Source {
|
||||
#[cfg(feature = "xdp")]
|
||||
Xdp(XdpPrefixStats),
|
||||
|
|
@ -38,37 +33,35 @@ impl Source {
|
|||
}
|
||||
}
|
||||
|
||||
/// Everything the monitor task needs besides the detection config.
|
||||
pub struct MonitorSetup {
|
||||
/// Ban lifetime, from `[ban].ban_duration_secs`.
|
||||
pub ban_ttl: Duration,
|
||||
/// Shared ban table.
|
||||
pub blacklist: Arc<Blacklist>,
|
||||
/// False when the observed address comes from an unverified ingress path
|
||||
/// (inbound PROXY protocol), where banning it could punish the transport
|
||||
/// proxy instead of the real client.
|
||||
pub trusted_peer: bool,
|
||||
/// Trusted proxy networks; a prefix ban overlapping one is suppressed.
|
||||
pub trusted_networks: Vec<crate::config::TrustedProxyCidr>,
|
||||
/// Userspace aggregator, used when XDP is not available.
|
||||
pub tracker: Option<Arc<SubnetTracker>>,
|
||||
/// Loaded XDP filter, preferred over the userspace tracker when present.
|
||||
pub xdp: Option<Arc<Mutex<XdpFilter>>>,
|
||||
/// Verdict enforcement settings shared by every snapshot tick.
|
||||
struct BanPolicy {
|
||||
blacklist: Arc<Blacklist>,
|
||||
ttl: Duration,
|
||||
trusted: bool,
|
||||
}
|
||||
|
||||
/// Spawns the background subnet monitor when `[detect.prefix] enabled`.
|
||||
pub fn spawn(detect: &DetectPrefixConfig, setup: MonitorSetup, mut shutdown: watch::Receiver<bool>) {
|
||||
///
|
||||
/// Source priority: the XDP map when a filter is loaded, otherwise the userspace
|
||||
/// aggregator. Without either source the monitor stays disabled and logs a
|
||||
/// warning.
|
||||
///
|
||||
/// `ban_ttl` comes from `[ban].ban_duration_secs`. `trusted_peer` is false when
|
||||
/// the observed address comes from an unverified ingress path (inbound PROXY
|
||||
/// protocol), where banning it could punish the transport proxy instead of the
|
||||
/// real client.
|
||||
pub fn spawn(
|
||||
detect: &DetectPrefixConfig,
|
||||
ban_ttl: Duration,
|
||||
blacklist: Arc<Blacklist>,
|
||||
trusted_peer: bool,
|
||||
tracker: Option<Arc<SubnetTracker>>,
|
||||
xdp: Option<Arc<Mutex<XdpFilter>>>,
|
||||
mut shutdown: watch::Receiver<bool>,
|
||||
) {
|
||||
if !detect.enabled {
|
||||
return;
|
||||
}
|
||||
let MonitorSetup {
|
||||
ban_ttl,
|
||||
blacklist,
|
||||
trusted_peer,
|
||||
trusted_networks,
|
||||
tracker,
|
||||
xdp,
|
||||
} = setup;
|
||||
let Some(source) = build_source(tracker, xdp) else {
|
||||
tracing::warn!("detect.prefix enabled but no stats source available; monitor disabled");
|
||||
return;
|
||||
|
|
@ -79,7 +72,6 @@ pub fn spawn(detect: &DetectPrefixConfig, setup: MonitorSetup, mut shutdown: wat
|
|||
blacklist,
|
||||
ttl: ban_ttl,
|
||||
trusted: trusted_peer,
|
||||
trusted_networks,
|
||||
};
|
||||
|
||||
tokio::spawn(async move {
|
||||
|
|
@ -132,7 +124,7 @@ fn apply_verdicts(verdicts: &[PrefixVerdict], source: &Source, policy: &BanPolic
|
|||
}
|
||||
match source {
|
||||
#[cfg(feature = "xdp")]
|
||||
Source::Xdp(xdp) if policy.trusted => ban_xdp_verdicts(xdp, verdicts, policy.ttl, &policy.trusted_networks),
|
||||
Source::Xdp(xdp) if policy.trusted => ban_xdp_verdicts(xdp, verdicts, policy.ttl),
|
||||
#[cfg(feature = "xdp")]
|
||||
Source::Xdp(_) => {
|
||||
if verdicts.iter().any(|pv| pv.verdict == SubnetVerdict::Block) {
|
||||
|
|
@ -140,17 +132,71 @@ fn apply_verdicts(verdicts: &[PrefixVerdict], source: &Source, policy: &BanPolic
|
|||
}
|
||||
},
|
||||
Source::Tracker(_) => {
|
||||
enforce_tracker_verdicts(
|
||||
verdicts,
|
||||
&policy.blacklist,
|
||||
policy.ttl,
|
||||
policy.trusted,
|
||||
&policy.trusted_networks,
|
||||
);
|
||||
enforce_tracker_verdicts(verdicts, &policy.blacklist, policy.ttl, policy.trusted);
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
/// Applies userspace `Block` verdicts to the shared blacklist.
|
||||
///
|
||||
/// Returns the number of banned prefixes. When `trusted` is false the observed
|
||||
/// addresses belong to an unverified ingress path, so the verdict is only logged
|
||||
/// at warn level and no ban is installed.
|
||||
///
|
||||
/// The ban is inserted as a CIDR range, so every address inside the detected
|
||||
/// `/24` or `/64` is blocked, not just its network address.
|
||||
pub fn enforce_tracker_verdicts(
|
||||
verdicts: &[PrefixVerdict],
|
||||
blacklist: &Blacklist,
|
||||
ttl: Duration,
|
||||
trusted: bool,
|
||||
) -> usize {
|
||||
let mut banned = 0;
|
||||
for pv in verdicts.iter().filter(|pv| pv.verdict == SubnetVerdict::Block) {
|
||||
if !trusted {
|
||||
tracing::warn!(
|
||||
prefix = %pv.prefix,
|
||||
"subnet block verdict on an untrusted peer path; not adding to the blacklist"
|
||||
);
|
||||
continue;
|
||||
}
|
||||
blacklist.add_cidr(pv.prefix, prefix_len(pv.prefix), ttl, "subnet_attack");
|
||||
banned += 1;
|
||||
tracing::warn!(
|
||||
prefix = %pv.prefix,
|
||||
ttl_secs = ttl.as_secs(),
|
||||
"subnet blocked in the userspace blacklist"
|
||||
);
|
||||
}
|
||||
banned
|
||||
}
|
||||
|
||||
#[cfg(feature = "xdp")]
|
||||
fn ban_xdp_verdicts(xdp: &XdpPrefixStats, verdicts: &[PrefixVerdict], ttl: Duration) {
|
||||
for pv in verdicts.iter().filter(|pv| pv.verdict == SubnetVerdict::Block) {
|
||||
let result = {
|
||||
let guard = xdp.filter_lock();
|
||||
guard.ban_cidr(pv.prefix, prefix_len(pv.prefix), ttl.as_secs())
|
||||
};
|
||||
match result {
|
||||
Ok(()) => tracing::warn!(
|
||||
prefix = %pv.prefix,
|
||||
ttl_secs = ttl.as_secs(),
|
||||
"subnet blocked in XDP"
|
||||
),
|
||||
Err(e) => tracing::warn!("subnet block failed for {}: {e}", pv.prefix),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Prefix length matching the detection granularity (v4 /24, v6 /64).
|
||||
fn prefix_len(prefix: IpAddr) -> u8 {
|
||||
match prefix {
|
||||
IpAddr::V4(_) => 24,
|
||||
IpAddr::V6(_) => 64,
|
||||
}
|
||||
}
|
||||
|
||||
#[must_use]
|
||||
fn verdict_name(verdict: SubnetVerdict) -> &'static str {
|
||||
match verdict {
|
||||
|
|
|
|||
|
|
@ -25,8 +25,6 @@ pub struct TrafficHook {
|
|||
autoban: DetectAutobanConfig,
|
||||
ban_ttl_secs: u64,
|
||||
conn_window: AtomicU64,
|
||||
/// Trusted PROXY-protocol networks; addresses inside them are never banned.
|
||||
trusted: Vec<crate::config::TrustedProxyCidr>,
|
||||
}
|
||||
|
||||
impl TrafficHook {
|
||||
|
|
@ -42,17 +40,9 @@ impl TrafficHook {
|
|||
autoban,
|
||||
ban_ttl_secs,
|
||||
conn_window: AtomicU64::new(0),
|
||||
trusted: Vec::new(),
|
||||
}
|
||||
}
|
||||
|
||||
/// Marks the networks whose addresses must never be banned (trusted proxies).
|
||||
#[must_use]
|
||||
pub fn with_trusted(mut self, trusted: Vec<crate::config::TrustedProxyCidr>) -> Self {
|
||||
self.trusted = trusted;
|
||||
self
|
||||
}
|
||||
|
||||
/// A new connection was accepted by the accept loop.
|
||||
///
|
||||
/// Only bumps the cps window counter; the counter is drained by
|
||||
|
|
@ -86,9 +76,8 @@ impl TrafficHook {
|
|||
if self.blacklist.is_blocked(ip) {
|
||||
continue;
|
||||
}
|
||||
if self.ban(ip, BAN_REASON_ATTACK) {
|
||||
banned += 1;
|
||||
}
|
||||
self.ban(ip, BAN_REASON_ATTACK);
|
||||
banned += 1;
|
||||
}
|
||||
banned
|
||||
}
|
||||
|
|
@ -102,21 +91,12 @@ impl TrafficHook {
|
|||
if self.reputation.score(ip) > self.autoban.reputation_threshold {
|
||||
return;
|
||||
}
|
||||
let _ = self.ban(ip, reason);
|
||||
self.ban(ip, reason);
|
||||
}
|
||||
|
||||
/// Bans `ip` unless it belongs to a trusted proxy network.
|
||||
///
|
||||
/// Returns whether the ban was actually installed.
|
||||
fn ban(&self, ip: IpAddr, reason: &str) -> bool {
|
||||
let host_prefix = if ip.is_ipv4() { 32 } else { 128 };
|
||||
if self.trusted.iter().any(|net| net.overlaps_prefix(ip, host_prefix)) {
|
||||
tracing::warn!(%ip, reason, "auto-ban suppressed: address belongs to a trusted proxy network");
|
||||
return false;
|
||||
}
|
||||
fn ban(&self, ip: IpAddr, reason: &str) {
|
||||
self.blacklist.add(ip, Duration::from_secs(self.ban_ttl_secs), reason);
|
||||
metrics::AUTO_BANS_TOTAL.with_label_values(&[reason]).inc();
|
||||
tracing::warn!(%ip, reason, ttl_secs = self.ban_ttl_secs, "auto-ban issued by traffic intelligence");
|
||||
true
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,153 +0,0 @@
|
|||
//! End-to-end tests of the real edge connection path over loopback.
|
||||
//!
|
||||
//! A TCP client is driven through the production accept loop (`engine::listener`)
|
||||
//! and pipeline (`engine::tunnel::Gateway`) to a real upstream socket on
|
||||
//! `127.0.0.1`: framing, the PoW gate, the admission filters and the relay are
|
||||
//! exercised as one system, without root and without any external network.
|
||||
#![cfg(feature = "protocol-http")]
|
||||
|
||||
#[path = "edge_e2e/support.rs"]
|
||||
mod support;
|
||||
|
||||
use rampart::engine::challenge::solve;
|
||||
use sha2::{Digest, Sha256};
|
||||
use std::net::Ipv4Addr;
|
||||
use std::sync::atomic::Ordering;
|
||||
use std::time::Duration;
|
||||
use support::{
|
||||
IO_BUDGET, POW_DIFFICULTY, REQUEST, RESPONSE, exchange, read_to_close, rejected_reply, start_edge, start_upstream,
|
||||
};
|
||||
use tokio::io::{AsyncReadExt, AsyncWriteExt};
|
||||
use tokio::net::TcpStream;
|
||||
|
||||
/// Reads one newline-terminated line (the PoW challenge).
|
||||
async fn read_line(stream: &mut TcpStream) -> anyhow::Result<String> {
|
||||
let mut line = Vec::new();
|
||||
for _ in 0..128 {
|
||||
let mut byte = [0u8; 1];
|
||||
if stream.read(&mut byte).await? == 0 || byte[0] == b'\n' {
|
||||
break;
|
||||
}
|
||||
line.push(byte[0]);
|
||||
}
|
||||
Ok(String::from_utf8_lossy(&line).trim().to_string())
|
||||
}
|
||||
|
||||
fn hash_satisfies(challenge: &str, nonce: &str, difficulty: u8) -> bool {
|
||||
let digest = Sha256::digest(format!("{challenge}{nonce}").as_bytes());
|
||||
hex::encode(digest)
|
||||
.as_bytes()
|
||||
.iter()
|
||||
.take(difficulty as usize)
|
||||
.all(|byte| byte.is_ascii_digit() && *byte <= b'3')
|
||||
}
|
||||
|
||||
/// Finds a nonce the gate must reject; the caller re-checks the result.
|
||||
fn invalid_nonce(challenge: &str, difficulty: u8) -> String {
|
||||
// At difficulty 2 about fifteen of sixteen candidates fail, so this stops
|
||||
// within a handful of iterations.
|
||||
for candidate in 0u64..1_000_000 {
|
||||
let nonce = candidate.to_string();
|
||||
if !hash_satisfies(challenge, &nonce, difficulty) {
|
||||
return nonce;
|
||||
}
|
||||
}
|
||||
"0".to_string()
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn plain_http_request_is_proxied_to_the_upstream() -> anyhow::Result<()> {
|
||||
let (upstream, accepted, seen) = start_upstream().await;
|
||||
let edge = start_edge(upstream, |_| {}).await?;
|
||||
|
||||
let response = exchange(edge.addr, REQUEST).await?;
|
||||
assert_eq!(response.as_slice(), RESPONSE);
|
||||
assert_eq!(accepted.load(Ordering::SeqCst), 1);
|
||||
assert_eq!(*seen.lock().expect("requests lock"), vec![REQUEST.to_vec()]);
|
||||
|
||||
edge.stop().await
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn pow_gate_accepts_a_solved_challenge_and_drops_a_wrong_nonce() -> anyhow::Result<()> {
|
||||
let (upstream, accepted, seen) = start_upstream().await;
|
||||
let edge = start_edge(upstream, |config| {
|
||||
config.pow.enabled = true;
|
||||
config.pow.difficulty = POW_DIFFICULTY;
|
||||
})
|
||||
.await?;
|
||||
|
||||
let mut client = TcpStream::connect(edge.addr).await?;
|
||||
let challenge = tokio::time::timeout(IO_BUDGET, read_line(&mut client)).await??;
|
||||
let nonce = solve(&challenge, POW_DIFFICULTY)
|
||||
.ok_or_else(|| anyhow::anyhow!("no solution found for challenge {challenge}"))?;
|
||||
// Coalesced write: the PoW reader must consume exactly the nonce line and
|
||||
// leave the HTTP head buffered for the handshake that runs next.
|
||||
let mut payload = format!("{nonce}\r\n").into_bytes();
|
||||
payload.extend_from_slice(REQUEST);
|
||||
client.write_all(&payload).await?;
|
||||
let response = tokio::time::timeout(IO_BUDGET, read_to_close(&mut client)).await??;
|
||||
assert_eq!(response.as_slice(), RESPONSE);
|
||||
assert_eq!(accepted.load(Ordering::SeqCst), 1);
|
||||
|
||||
let mut hostile = TcpStream::connect(edge.addr).await?;
|
||||
let challenge = tokio::time::timeout(IO_BUDGET, read_line(&mut hostile)).await??;
|
||||
let wrong = invalid_nonce(&challenge, POW_DIFFICULTY);
|
||||
assert!(!hash_satisfies(&challenge, &wrong, POW_DIFFICULTY));
|
||||
// Send the request after the wrong nonce: if the gate accepted it, the head
|
||||
// would be buffered and proxied, and the upstream response would come back.
|
||||
let mut payload = format!("{wrong}\r\n").into_bytes();
|
||||
payload.extend_from_slice(REQUEST);
|
||||
let _ = hostile.write_all(&payload).await;
|
||||
let reply = tokio::time::timeout(IO_BUDGET, read_to_close(&mut hostile)).await??;
|
||||
assert!(reply.is_empty(), "a wrong nonce must be dropped, got {reply:?}");
|
||||
assert_eq!(
|
||||
accepted.load(Ordering::SeqCst),
|
||||
1,
|
||||
"a failed PoW must not reach the upstream"
|
||||
);
|
||||
assert_eq!(seen.lock().expect("requests lock").len(), 1);
|
||||
|
||||
edge.stop().await
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn rate_limit_drops_the_second_connection_before_the_upstream() -> anyhow::Result<()> {
|
||||
let (upstream, accepted, _seen) = start_upstream().await;
|
||||
let edge = start_edge(upstream, |config| {
|
||||
// One token, practically no refill: the second connection is over budget.
|
||||
config.limits.rate_limit_pps = 0.001;
|
||||
config.limits.rate_limit_burst = 1.0;
|
||||
})
|
||||
.await?;
|
||||
|
||||
let response = exchange(edge.addr, REQUEST).await?;
|
||||
assert_eq!(response.as_slice(), RESPONSE);
|
||||
assert_eq!(accepted.load(Ordering::SeqCst), 1);
|
||||
|
||||
let reply = rejected_reply(edge.addr, REQUEST).await?;
|
||||
assert!(
|
||||
reply.is_empty(),
|
||||
"rate-limited connection must not be proxied, got {reply:?}"
|
||||
);
|
||||
// EOF above means the reject path already ran; it precedes the upstream
|
||||
// stage, so a second accept cannot appear afterwards.
|
||||
assert_eq!(accepted.load(Ordering::SeqCst), 1);
|
||||
|
||||
edge.stop().await
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn blacklisted_client_never_reaches_the_upstream() -> anyhow::Result<()> {
|
||||
let (upstream, accepted, seen) = start_upstream().await;
|
||||
let edge = start_edge(upstream, |_| {}).await?;
|
||||
edge.blacklist
|
||||
.add(Ipv4Addr::LOCALHOST.into(), Duration::from_secs(60), "edge_e2e");
|
||||
|
||||
let reply = rejected_reply(edge.addr, REQUEST).await?;
|
||||
assert!(reply.is_empty(), "a banned client must be dropped, got {reply:?}");
|
||||
assert_eq!(accepted.load(Ordering::SeqCst), 0);
|
||||
assert!(seen.lock().expect("requests lock").is_empty());
|
||||
|
||||
edge.stop().await
|
||||
}
|
||||
|
|
@ -1,250 +0,0 @@
|
|||
//! Shared loopback harness for `tests/edge_e2e.rs`; cargo does not build it as
|
||||
//! its own test binary because it lives in a subdirectory.
|
||||
|
||||
use rampart::config::Config;
|
||||
use rampart::engine::challenge::DifficultyAdjuster;
|
||||
use rampart::engine::listener;
|
||||
use rampart::engine::tunnel::Gateway;
|
||||
use rampart::filter::blacklist::Blacklist;
|
||||
use rampart::filter::rate_limit::RateLimiter;
|
||||
use rampart::protocol::ProtocolRegistry;
|
||||
use rampart::protocol::http::HttpProtocolHandler;
|
||||
use rampart::traffic::hook::TrafficHook;
|
||||
use rampart::traffic::reputation::IpReputation;
|
||||
use std::collections::HashSet;
|
||||
use std::io::ErrorKind;
|
||||
use std::net::{Ipv4Addr, SocketAddr};
|
||||
use std::sync::atomic::{AtomicU64, AtomicUsize, Ordering};
|
||||
use std::sync::{Arc, Mutex};
|
||||
use std::time::{Duration, Instant};
|
||||
use tokio::io::{AsyncReadExt, AsyncWriteExt};
|
||||
use tokio::net::TcpStream;
|
||||
use tokio::sync::watch;
|
||||
use tokio::task::JoinHandle;
|
||||
|
||||
pub const REQUEST: &[u8] = b"GET / HTTP/1.1\r\nHost: edge\r\n\r\n";
|
||||
pub const RESPONSE: &[u8] = b"HTTP/1.1 200 OK\r\nContent-Length: 2\r\nConnection: close\r\n\r\nOK";
|
||||
pub const POW_DIFFICULTY: u8 = 2;
|
||||
/// Upper bound of every I/O wait, so a regression fails instead of hanging.
|
||||
pub const IO_BUDGET: Duration = Duration::from_secs(4);
|
||||
const READY_BUDGET: Duration = Duration::from_secs(2);
|
||||
const MAX_REPLY_BYTES: usize = 64 * 1024;
|
||||
|
||||
// --- upstream -------------------------------------------------------------
|
||||
|
||||
/// Real upstream: returns its address, an accept counter and the heads it saw.
|
||||
pub async fn start_upstream() -> (SocketAddr, Arc<AtomicUsize>, Arc<Mutex<Vec<Vec<u8>>>>) {
|
||||
let listener = tokio::net::TcpListener::bind((Ipv4Addr::LOCALHOST, 0))
|
||||
.await
|
||||
.expect("bind upstream");
|
||||
let addr = listener.local_addr().expect("upstream address");
|
||||
let accepted = Arc::new(AtomicUsize::new(0));
|
||||
let requests = Arc::new(Mutex::new(Vec::new()));
|
||||
let (count, seen) = (Arc::clone(&accepted), Arc::clone(&requests));
|
||||
// Detached: the per-test runtime drops this server when the test ends.
|
||||
tokio::spawn(async move {
|
||||
while let Ok((mut stream, _)) = listener.accept().await {
|
||||
count.fetch_add(1, Ordering::SeqCst);
|
||||
let seen = Arc::clone(&seen);
|
||||
tokio::spawn(async move {
|
||||
let head = read_head(&mut stream).await;
|
||||
seen.lock().expect("requests lock").push(head);
|
||||
let _ = stream.write_all(RESPONSE).await;
|
||||
let _ = stream.shutdown().await;
|
||||
});
|
||||
}
|
||||
});
|
||||
(addr, accepted, requests)
|
||||
}
|
||||
|
||||
/// Reads until the request head ends (`\r\n\r\n`), the peer closes or a read fails.
|
||||
async fn read_head(stream: &mut TcpStream) -> Vec<u8> {
|
||||
let mut head = Vec::new();
|
||||
let mut buf = [0u8; 512];
|
||||
while head.len() < 4096 {
|
||||
match stream.read(&mut buf).await {
|
||||
Ok(0) | Err(_) => break,
|
||||
Ok(n) => {
|
||||
head.extend_from_slice(&buf[..n]);
|
||||
if head.windows(4).any(|w| w == b"\r\n\r\n".as_slice()) {
|
||||
break;
|
||||
}
|
||||
},
|
||||
}
|
||||
}
|
||||
head
|
||||
}
|
||||
|
||||
// --- edge -----------------------------------------------------------------
|
||||
|
||||
/// Production-shaped config from serde defaults, plus the per-test overrides.
|
||||
fn test_config(port: u16, upstream: SocketAddr) -> Config {
|
||||
let mut config = Config::default();
|
||||
config.bind.address = Ipv4Addr::LOCALHOST.to_string();
|
||||
config.bind.port = port;
|
||||
config.backend.upstreams = vec![upstream.to_string()];
|
||||
config.workers.count = 1;
|
||||
config.limits.handshake_timeout_secs = 2;
|
||||
config.limits.relay_idle_timeout_secs = 5;
|
||||
config.limits.max_connections_per_ip = 8;
|
||||
config.protocol.http.max_header_bytes = 4096;
|
||||
config.protocol.http.timeout_secs = 2;
|
||||
config
|
||||
}
|
||||
|
||||
/// Running accept loop plus the shared state a test may pre-seed.
|
||||
pub struct Edge {
|
||||
pub addr: SocketAddr,
|
||||
pub blacklist: Arc<Blacklist>,
|
||||
shutdown: watch::Sender<bool>,
|
||||
task: JoinHandle<anyhow::Result<()>>,
|
||||
}
|
||||
|
||||
impl Edge {
|
||||
/// Stops the accept loop and waits for it, so no task outlives the test.
|
||||
pub async fn stop(mut self) -> anyhow::Result<()> {
|
||||
let _ = self.shutdown.send(true);
|
||||
match tokio::time::timeout(IO_BUDGET, &mut self.task).await {
|
||||
Ok(result) => result?,
|
||||
Err(_) => anyhow::bail!("edge accept loop did not stop within {IO_BUDGET:?}"),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Drop for Edge {
|
||||
fn drop(&mut self) {
|
||||
// Panic path: still wake the accept loop instead of leaking it.
|
||||
let _ = self.shutdown.send(true);
|
||||
}
|
||||
}
|
||||
|
||||
/// Starts `listener::run`, retrying once if the throwaway port was stolen.
|
||||
///
|
||||
/// The port comes from binding `:0` and dropping the probe, so another process
|
||||
/// can claim it before the edge binds; `run` then fails immediately and a fresh
|
||||
/// port is used. The retry is bounded, never a loop.
|
||||
pub async fn start_edge(upstream: SocketAddr, tune: impl Fn(&mut Config)) -> anyhow::Result<Edge> {
|
||||
let mut last_error = anyhow::anyhow!("edge listener did not bind");
|
||||
for _ in 0..2 {
|
||||
let port = free_port()?;
|
||||
let mut config = test_config(port, upstream);
|
||||
tune(&mut config);
|
||||
let config = Arc::new(config);
|
||||
let (gateway, blacklist, hook) = build_gateway(&config);
|
||||
let (shutdown, shutdown_rx) = watch::channel(false);
|
||||
let task = tokio::spawn(listener::run(config, gateway, hook, shutdown_rx));
|
||||
let addr = SocketAddr::from((Ipv4Addr::LOCALHOST, port));
|
||||
if wait_until_bound(addr, &task).await {
|
||||
return Ok(Edge {
|
||||
addr,
|
||||
blacklist,
|
||||
shutdown,
|
||||
task,
|
||||
});
|
||||
}
|
||||
let _ = shutdown.send(true);
|
||||
if let Ok(Err(error)) = task.await {
|
||||
last_error = error;
|
||||
}
|
||||
}
|
||||
Err(last_error.context("edge listener failed to bind a loopback port after two attempts"))
|
||||
}
|
||||
|
||||
/// Binds `127.0.0.1:0`, reads the assigned port and releases it.
|
||||
fn free_port() -> anyhow::Result<u16> {
|
||||
let probe = std::net::TcpListener::bind((Ipv4Addr::LOCALHOST, 0))?;
|
||||
let port = probe.local_addr()?.port();
|
||||
drop(probe);
|
||||
Ok(port)
|
||||
}
|
||||
|
||||
/// Waits until the edge owns `addr`. A second bind without `SO_REUSEPORT` fails
|
||||
/// with `EADDRINUSE` exactly then, so no throwaway connection spends a
|
||||
/// rate-limit token and pollutes the assertions.
|
||||
async fn wait_until_bound(addr: SocketAddr, task: &JoinHandle<anyhow::Result<()>>) -> bool {
|
||||
let deadline = Instant::now() + READY_BUDGET;
|
||||
while Instant::now() < deadline {
|
||||
if task.is_finished() {
|
||||
return false;
|
||||
}
|
||||
if std::net::TcpListener::bind(addr).is_err() {
|
||||
return true;
|
||||
}
|
||||
tokio::time::sleep(Duration::from_millis(2)).await;
|
||||
}
|
||||
false
|
||||
}
|
||||
|
||||
/// Assembles the edge state as `app::runtime` does, minus XDP, Redis and the
|
||||
/// ClickHouse writer (all optional, all `None` here).
|
||||
fn build_gateway(config: &Arc<Config>) -> (Arc<Gateway>, Arc<Blacklist>, Arc<TrafficHook>) {
|
||||
let blacklist = Arc::new(Blacklist::new());
|
||||
let reputation = Arc::new(IpReputation::new());
|
||||
let mut registry = ProtocolRegistry::new();
|
||||
registry.register(Box::new(HttpProtocolHandler::new(
|
||||
&config.protocol.http,
|
||||
&config.backend.upstreams,
|
||||
)));
|
||||
let gateway = Gateway::new(
|
||||
Arc::clone(config),
|
||||
Arc::new(RateLimiter::new(
|
||||
config.limits.rate_limit_pps,
|
||||
config.limits.rate_limit_burst,
|
||||
)),
|
||||
Arc::clone(&blacklist),
|
||||
Arc::new(Mutex::new(DifficultyAdjuster::with_floor(config.pow.difficulty))),
|
||||
Arc::new(HashSet::new()),
|
||||
Arc::clone(&reputation),
|
||||
None,
|
||||
None,
|
||||
Arc::new(AtomicU64::new(0)),
|
||||
Arc::new(registry),
|
||||
None,
|
||||
);
|
||||
// Auto-ban stays at its default (disabled), so a drop cannot leak a ban into
|
||||
// a later assertion.
|
||||
let hook = Arc::new(TrafficHook::new(
|
||||
reputation,
|
||||
Arc::clone(&blacklist),
|
||||
config.detect.autoban.clone(),
|
||||
config.ban.ban_duration_secs,
|
||||
));
|
||||
(Arc::new(gateway), blacklist, hook)
|
||||
}
|
||||
|
||||
// --- client ---------------------------------------------------------------
|
||||
|
||||
/// Reads until the peer closes; a reset also means "closed, no extra data".
|
||||
pub async fn read_to_close(stream: &mut TcpStream) -> anyhow::Result<Vec<u8>> {
|
||||
let mut out = Vec::new();
|
||||
let mut buf = [0u8; 512];
|
||||
loop {
|
||||
match stream.read(&mut buf).await {
|
||||
Ok(0) => return Ok(out),
|
||||
Ok(n) => {
|
||||
out.extend_from_slice(&buf[..n]);
|
||||
if out.len() > MAX_REPLY_BYTES {
|
||||
anyhow::bail!("peer kept sending past {MAX_REPLY_BYTES} bytes");
|
||||
}
|
||||
},
|
||||
Err(error) if error.kind() == ErrorKind::ConnectionReset => return Ok(out),
|
||||
Err(error) => return Err(error.into()),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Sends `payload` on a fresh connection and returns everything until the close.
|
||||
pub async fn exchange(addr: SocketAddr, payload: &[u8]) -> anyhow::Result<Vec<u8>> {
|
||||
let mut client = TcpStream::connect(addr).await?;
|
||||
client.write_all(payload).await?;
|
||||
tokio::time::timeout(IO_BUDGET, read_to_close(&mut client)).await?
|
||||
}
|
||||
|
||||
/// Best-effort request on a fresh connection: a rejected peer may already be
|
||||
/// gone, so write errors are ignored. The reply is what the caller asserts on —
|
||||
/// a gate that let the request through would return the upstream response.
|
||||
pub async fn rejected_reply(addr: SocketAddr, payload: &[u8]) -> anyhow::Result<Vec<u8>> {
|
||||
let mut client = TcpStream::connect(addr).await?;
|
||||
let _ = client.write_all(payload).await;
|
||||
tokio::time::timeout(IO_BUDGET, read_to_close(&mut client)).await?
|
||||
}
|
||||
|
|
@ -237,25 +237,3 @@ async fn plain_connection_uses_the_transport_peer() {
|
|||
let outcome = handle_plain(&gateway, peer).await;
|
||||
assert_eq!(outcome.client_ip, Some(peer.ip()));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn trusted_network_overlap_checks_prefix_intersection() {
|
||||
let net: TrustedProxyCidr = "10.0.0.0/8".parse().expect("cidr");
|
||||
assert!(net.overlaps_prefix("10.1.2.0".parse().expect("ip"), 24), "same range");
|
||||
assert!(
|
||||
net.overlaps_prefix("10.0.0.0".parse().expect("ip"), 7),
|
||||
"wider prefix overlaps"
|
||||
);
|
||||
assert!(
|
||||
!net.overlaps_prefix("11.0.0.0".parse().expect("ip"), 8),
|
||||
"sibling range"
|
||||
);
|
||||
assert!(
|
||||
!net.overlaps_prefix("10.0.0.0".parse().expect("ip"), 0),
|
||||
"/0 is rejected"
|
||||
);
|
||||
|
||||
let v6: TrustedProxyCidr = "fd00::/8".parse().expect("cidr");
|
||||
assert!(v6.overlaps_prefix("fd12::".parse().expect("ip"), 16));
|
||||
assert!(!v6.overlaps_prefix("2001:db8::".parse().expect("ip"), 32));
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
//! Integration tests for subnet-level detection: tracker, detector and verdicts.
|
||||
|
||||
use rampart::config::{Config, TrustedProxyCidr};
|
||||
use rampart::config::Config;
|
||||
use rampart::engine::subnet::monitor::enforce_tracker_verdicts;
|
||||
use rampart::engine::subnet_tracker::SubnetTracker;
|
||||
use rampart::filter::blacklist::Blacklist;
|
||||
|
|
@ -299,7 +299,7 @@ fn block_verdict(prefix: IpAddr) -> PrefixVerdict {
|
|||
fn trusted_tracker_block_reaches_the_blacklist_with_the_configured_ttl() {
|
||||
let blacklist = Blacklist::new();
|
||||
let verdicts = [block_verdict(v4([203, 0, 113, 0]))];
|
||||
let banned = enforce_tracker_verdicts(&verdicts, &blacklist, Duration::from_secs(120), true, &[]);
|
||||
let banned = enforce_tracker_verdicts(&verdicts, &blacklist, Duration::from_secs(120), true);
|
||||
assert_eq!(banned, 1);
|
||||
assert!(blacklist.is_blocked(v4([203, 0, 113, 0])));
|
||||
}
|
||||
|
|
@ -308,7 +308,7 @@ fn trusted_tracker_block_reaches_the_blacklist_with_the_configured_ttl() {
|
|||
fn untrusted_tracker_block_only_warns() {
|
||||
let blacklist = Blacklist::new();
|
||||
let verdicts = [block_verdict(v4([198, 51, 100, 0]))];
|
||||
let banned = enforce_tracker_verdicts(&verdicts, &blacklist, Duration::from_secs(120), false, &[]);
|
||||
let banned = enforce_tracker_verdicts(&verdicts, &blacklist, Duration::from_secs(120), false);
|
||||
assert_eq!(banned, 0);
|
||||
assert!(blacklist.is_empty());
|
||||
}
|
||||
|
|
@ -317,7 +317,7 @@ fn untrusted_tracker_block_only_warns() {
|
|||
fn tracker_ban_uses_the_given_duration() {
|
||||
let blacklist = Blacklist::new();
|
||||
let verdicts = [block_verdict(v4([192, 0, 2, 0]))];
|
||||
enforce_tracker_verdicts(&verdicts, &blacklist, Duration::from_millis(1), true, &[]);
|
||||
enforce_tracker_verdicts(&verdicts, &blacklist, Duration::from_millis(1), true);
|
||||
std::thread::sleep(Duration::from_millis(2));
|
||||
assert!(
|
||||
!blacklist.is_blocked(v4([192, 0, 2, 0])),
|
||||
|
|
@ -331,7 +331,7 @@ fn non_block_verdicts_do_not_ban() {
|
|||
let mut verdict = block_verdict(v4([203, 0, 113, 0]));
|
||||
verdict.verdict = SubnetVerdict::Challenge;
|
||||
assert_eq!(
|
||||
enforce_tracker_verdicts(&[verdict], &blacklist, Duration::from_secs(60), true, &[]),
|
||||
enforce_tracker_verdicts(&[verdict], &blacklist, Duration::from_secs(60), true),
|
||||
0
|
||||
);
|
||||
assert!(blacklist.is_empty());
|
||||
|
|
@ -375,23 +375,3 @@ fn prefix_key_normalises_ipv4_mapped_addresses() {
|
|||
assert_eq!(PrefixKey::new(mapped).to_prefix(), Some(prefix_of(mapped)));
|
||||
assert_eq!(PrefixKey::new(mapped).to_prefix(), Some(v4([1, 2, 3, 0])));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn tracker_block_is_suppressed_when_a_trusted_proxy_lives_in_the_prefix() {
|
||||
let blacklist = Blacklist::new();
|
||||
let verdicts = [block_verdict(v4([10, 9, 0, 0]))];
|
||||
let trusted: Vec<TrustedProxyCidr> = vec!["10.9.0.5/32".parse().expect("trusted cidr")];
|
||||
let banned = enforce_tracker_verdicts(&verdicts, &blacklist, Duration::from_secs(120), true, &trusted);
|
||||
assert_eq!(banned, 0, "a ban covering a trusted proxy must be suppressed");
|
||||
assert!(blacklist.is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn tracker_block_still_applies_when_trusted_networks_do_not_overlap() {
|
||||
let blacklist = Blacklist::new();
|
||||
let verdicts = [block_verdict(v4([10, 9, 0, 0]))];
|
||||
let trusted: Vec<TrustedProxyCidr> = vec!["192.0.2.0/24".parse().expect("trusted cidr")];
|
||||
let banned = enforce_tracker_verdicts(&verdicts, &blacklist, Duration::from_secs(120), true, &trusted);
|
||||
assert_eq!(banned, 1);
|
||||
assert!(blacklist.is_blocked(v4([10, 9, 0, 7])));
|
||||
}
|
||||
|
|
|
|||
|
|
@ -446,33 +446,3 @@ fn alerts_fire_only_on_state_transitions() {
|
|||
assert!(alerts[0].message.contains("attack started"));
|
||||
assert!(alerts[1].message.contains("attack ended"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn auto_ban_never_targets_a_trusted_proxy_network() {
|
||||
let reputation = Arc::new(IpReputation::new());
|
||||
let blacklist = Arc::new(Blacklist::new());
|
||||
let trusted: Vec<rampart::config::TrustedProxyCidr> = vec!["10.0.0.0/8".parse().expect("trusted cidr")];
|
||||
let hook =
|
||||
TrafficHook::new(Arc::clone(&reputation), Arc::clone(&blacklist), autoban_cfg(true), 60).with_trusted(trusted);
|
||||
let inside = ip([10, 1, 2, 3]);
|
||||
|
||||
for _ in 0..6 {
|
||||
reputation.record_bad(inside);
|
||||
hook.on_connection_end(inside);
|
||||
}
|
||||
assert!(
|
||||
reputation.score(inside) <= -50,
|
||||
"reputation must fall below the threshold"
|
||||
);
|
||||
assert_eq!(hook.ban_offenders(), 0, "trusted addresses are never banned");
|
||||
|
||||
let public = ip([198, 51, 100, 9]);
|
||||
for _ in 0..6 {
|
||||
reputation.record_bad(public);
|
||||
hook.on_connection_end(public);
|
||||
}
|
||||
assert!(
|
||||
blacklist.is_blocked(public),
|
||||
"non-trusted offenders are still banned by the reputation path"
|
||||
);
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue