WEB: bounded opt-in wildcard host routing added

This commit is contained in:
Alexey
2026-10-17 23:42:26 +03:00
parent b2b088495d
commit 9738244285
67 changed files with 2572 additions and 239 deletions
+4
View File
@@ -398,6 +398,7 @@ async fn prefixed_decoy_request_keeps_its_original_path_and_query() {
let mut config = runtime_config_with_base(capability, WebCarrier::Https, "/relay/");
let profile = Arc::clone(&config.web.runtime.as_ref().unwrap().profiles[0]);
let vhost = Arc::new(WebRuntimeVhost {
wildcard: None,
host: "proxy.example.com".to_string(),
base: "/relay/".to_string(),
decoy_fasttrack_mode: WebDecoyFastTrackMode::Off,
@@ -412,6 +413,9 @@ async fn prefixed_decoy_request_keeps_its_original_path_and_query() {
let mut vhosts = BTreeMap::new();
vhosts.insert("proxy.example.com".to_string(), vhost);
config.web.runtime = Some(Arc::new(WebRuntimeConfig {
snapshot_id: 0,
wildcards: Default::default(),
catch_all: None,
vhosts,
profiles: vec![profile],
capabilities: vec![capability].into_boxed_slice(),
@@ -63,6 +63,7 @@ async fn every_authentic_credential_placement_stays_out_of_the_upstream() {
vhosts.insert(
"proxy.example.com".to_string(),
Arc::new(WebRuntimeVhost {
wildcard: None,
host: "proxy.example.com".to_string(),
base: "/relay/".to_string(),
decoy_fasttrack_mode: WebDecoyFastTrackMode::Off,
@@ -78,6 +79,7 @@ async fn every_authentic_credential_placement_stays_out_of_the_upstream() {
vhosts.insert(
"other.example.com".to_string(),
Arc::new(WebRuntimeVhost {
wildcard: None,
host: "other.example.com".to_string(),
base: "/other/".to_string(),
decoy_fasttrack_mode: WebDecoyFastTrackMode::Off,
@@ -91,6 +93,9 @@ async fn every_authentic_credential_placement_stays_out_of_the_upstream() {
}),
);
config.web.runtime = Some(Arc::new(WebRuntimeConfig {
snapshot_id: 0,
wildcards: Default::default(),
catch_all: None,
vhosts,
profiles: vec![profile],
capabilities: vec![capability].into_boxed_slice(),
+4
View File
@@ -195,6 +195,7 @@ async fn decoy_forwarding_preserves_every_reference_request_target() {
vhosts.insert(
"proxy.example.com".to_string(),
Arc::new(WebRuntimeVhost {
wildcard: None,
host: previous.host.clone(),
base: previous.base.clone(),
decoy_fasttrack_mode: previous.decoy_fasttrack_mode,
@@ -208,6 +209,9 @@ async fn decoy_forwarding_preserves_every_reference_request_target() {
}),
);
config.web.runtime = Some(Arc::new(WebRuntimeConfig {
snapshot_id: 0,
wildcards: Default::default(),
catch_all: None,
vhosts,
profiles: runtime_config.profiles.clone(),
capabilities: runtime_config.capabilities.clone(),
+3 -2
View File
@@ -19,6 +19,7 @@ pub(super) async fn handle(
request: Request<RequestBody>,
runtime: Arc<WebProcessRuntime>,
vhost: Arc<WebRuntimeVhost>,
host: &str,
token_hash: TokenHash,
client_ip: IpAddr,
) -> HttpResponse {
@@ -26,7 +27,7 @@ pub(super) async fn handle(
return serve_decoy(request, vhost, true, &runtime).await;
}
let Some((trace_session_id, profile, body_timeout)) =
runtime.bootstrap_trace_identity(token_hash, &vhost.host)
runtime.bootstrap_trace_identity(token_hash, host)
else {
return serve_decoy(request, vhost, true, &runtime).await;
};
@@ -56,7 +57,7 @@ pub(super) async fn handle(
let Some(event) = parse_event(&body) else {
return serve_decoy(request, vhost, true, &runtime).await;
};
match runtime.claim_bridge_diagnostic(token_hash, &vhost.host, event) {
match runtime.claim_bridge_diagnostic(token_hash, host, event) {
Ok(first) => {
if first {
runtime.trace().record_profile_lifecycle(
+2 -1
View File
@@ -20,6 +20,7 @@ pub(super) async fn handle_down(
request: Request<RequestBody>,
runtime: Arc<WebProcessRuntime>,
vhost: Arc<WebRuntimeVhost>,
host: &str,
token_hash: TokenHash,
) -> HttpResponse {
if !matches!(*request.method(), hyper::Method::POST | hyper::Method::PUT)
@@ -30,7 +31,7 @@ pub(super) async fn handle_down(
let Some(cursor) = canonical_u64_header(&request, "x-down-cursor") else {
return serve_decoy(request, vhost, true, &runtime).await;
};
let Ok(session) = runtime.get_session(token_hash, &vhost.host) else {
let Ok(session) = runtime.get_session(token_hash, host) else {
return serve_decoy(request, vhost, true, &runtime).await;
};
if session.carrier().uses_websocket() {
+4
View File
@@ -348,3 +348,7 @@ async fn alias_recovery_cannot_retire_a_foreign_session() {
assert!(runtime.get_session(token_hash(&b), HOSTS[1]).is_ok());
stop(runtime, &[generation]).await;
}
// Automatic hosts share policies but retain exact-host authentication and quotas.
#[path = "host_list_tests/wildcard.rs"]
mod wildcard;
+269
View File
@@ -0,0 +1,269 @@
use super::*;
use std::time::Duration;
fn wildcard_source(selector: &str, origin: std::net::SocketAddr) -> String {
source(selector, origin).replace("[web]", "[web]\nallow_wildcard_hosts = true")
+ "\n[web.limits]\nmemory_envelope_bytes = 1610612736\n"
}
fn capability(config: &ProxyConfig, host: &str) -> String {
// Independent reference derivation uses the client wire contract, not the cache.
use hmac::{Hmac, Mac};
let mut mac =
Hmac::<Sha256>::new_from_slice(&hex::decode("000102030405060708090a0b0c0d0e0f").unwrap())
.unwrap();
mac.update(b"tdesktop-web-proxy-bridge-v2\n");
mac.update(host.as_bytes());
mac.update(b"\nrelay");
let encoded =
base64::engine::general_purpose::URL_SAFE_NO_PAD.encode(mac.finalize().into_bytes());
assert!(config.web.runtime.as_ref().unwrap().route(host).is_some());
encoded
}
async fn bridge(listener: &TcpListener, runtime: &Arc<WebProcessRuntime>, host: &str) -> String {
let cap = capability(&runtime.active_generation().config(), host);
let response = request(
listener,
runtime,
raw_request("GET", &format!("/relay/?bridge={cap}"), host, "", &[]),
)
.await;
assert!(
response.starts_with(b"HTTP/1.1 200"),
"{}",
String::from_utf8_lossy(&response)
);
std::str::from_utf8(split_response(&response).1)
.unwrap()
.split_once("bootstrap=\"")
.unwrap()
.1
.split_once('"')
.unwrap()
.0
.to_string()
}
#[tokio::test]
async fn wildcard_cold_containment_canonical_host_and_positive_cache_in_all_modes() {
for mode in ["off", "shadow", "enforce"] {
let site = TcpListener::bind("127.0.0.1:0").await.unwrap();
let text = wildcard_source(
"hosts = [\"*.example.com\", \"exact.example.com\"]",
site.local_addr().unwrap(),
)
.replace(
"enabled = true",
&format!("enabled = true\ndecoy_fasttrack_mode = \"{mode}\""),
);
let generation = generation(1, &text);
let runtime = WebProcessRuntime::start(Arc::new(ArcSwap::from(generation.clone())));
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
let host = "a.deep.example.com";
let cap = capability(&generation.config(), host);
let encoded = cap
.bytes()
.map(|byte| format!("%{byte:02X}"))
.collect::<String>();
for (path, headers) in [
(format!("/wrong/{cap}"), String::new()),
(format!("/wrong/{encoded}"), String::new()),
("/wrong".to_string(), format!("Cookie: opaque={cap}\r\n")),
("/relay/".to_string(), format!("User-Agent: {encoded}\r\n")),
] {
assert_private(
&request(
&listener,
&runtime,
raw_request("GET", &path, host, &headers, &[]),
)
.await,
);
}
assert_eq!(runtime.wildcard.as_ref().unwrap().test_stats().0, 0);
let before = runtime.wildcard.as_ref().unwrap().test_stats().2;
let response = request(
&listener,
&runtime,
raw_request(
"GET",
&format!("/relay/?bridge={cap}"),
"A.DEEP.EXAMPLE.COM:443",
"",
&[],
),
)
.await;
assert!(response.starts_with(b"HTTP/1.1 200"));
let cache = runtime.wildcard.as_ref().unwrap();
assert_eq!(cache.test_stats().0, 1);
assert_eq!(cache.test_stats().2, before + 1);
bridge(&listener, &runtime, host).await;
assert_eq!(cache.test_stats().2, before + 1);
for foreign in ["b.example.com", "exact.example.com"] {
assert_private(
&request(
&listener,
&runtime,
raw_request("GET", &format!("/wrong/{cap}"), foreign, "", &[]),
)
.await,
);
}
for invalid in [
"example.com",
"127.0.0.1",
"a.example.com:0443",
"a.example.com:80",
"a..example.com",
"a.example.com.",
"a.example.com\r\nHost: b.example.com",
] {
assert!(
request(
&listener,
&runtime,
raw_request("GET", "/relay/", invalid, "", &[])
)
.await
.starts_with(b"HTTP/1.1 404")
);
}
assert!(
tokio::time::timeout(Duration::from_millis(20), site.accept())
.await
.is_err()
);
stop(runtime, &[generation]).await;
}
}
#[tokio::test]
async fn wildcard_budget_exhaustion_does_not_break_warm_bootstraps_or_authenticated_carriers() {
let text = wildcard_source(
"host = \"*.example.com\"",
"127.0.0.1:18081".parse().unwrap(),
) + "\n[web.limits.wildcard]\nmax_profiles_per_request = 1\ncold_hmac_burst = 1\ncold_hmac_per_minute = 1\n";
let generation = generation(1, &text);
let runtime = WebProcessRuntime::start(Arc::new(ArcSwap::from(generation.clone())));
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
let bootstrap = bridge(&listener, &runtime, HOSTS[0]).await;
let session = create(&runtime, HOSTS[0], &bootstrap).unwrap();
let cap = capability(&generation.config(), HOSTS[1]);
assert!(
request(
&listener,
&runtime,
raw_request("GET", &format!("/relay/?bridge={cap}"), HOSTS[1], "", &[])
)
.await
.starts_with(b"HTTP/1.1 503")
);
bridge(&listener, &runtime, HOSTS[0]).await;
let auth = format!(
"Authorization: Bearer {session}\r\nContent-Type: application/octet-stream\r\nX-Up-Seq: 1\r\n"
);
let response = request(
&listener,
&runtime,
raw_request(
"POST",
"/relay/api/v1/up",
HOSTS[0],
&auth,
&frame::encode(FrameType::Pong, 0, &[]),
),
)
.await;
assert!(
response.starts_with(b"HTTP/1.1 204"),
"{}",
String::from_utf8_lossy(&response)
);
assert_private(
&request(
&listener,
&runtime,
raw_request(
"POST",
"/relay/api/v1/up",
HOSTS[1],
&auth,
&frame::encode(FrameType::Pong, 0, &[]),
),
)
.await,
);
assert_eq!(runtime.wildcard.as_ref().unwrap().test_stats().2, 1);
stop(runtime, &[generation]).await;
}
#[tokio::test]
async fn wildcard_cache_eviction_never_resets_host_quotas_and_recovery_uses_actual_host() {
let text = wildcard_source(
"host = \"*.example.com\"",
"127.0.0.1:18081".parse().unwrap(),
) + "\n[web.limits.wildcard]\ncache_hosts = 1\n";
let generation = generation(1, &text);
let runtime = WebProcessRuntime::start(Arc::new(ArcSwap::from(generation.clone())));
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
let a = create(
&runtime,
HOSTS[0],
&bridge(&listener, &runtime, HOSTS[0]).await,
)
.unwrap();
create(
&runtime,
HOSTS[1],
&bridge(&listener, &runtime, HOSTS[1]).await,
)
.unwrap();
assert_eq!(runtime.wildcard.as_ref().unwrap().test_stats().0, 1);
assert_eq!(
create(
&runtime,
HOSTS[0],
&bridge(&listener, &runtime, HOSTS[0]).await
),
Err(ManagerError::Limit)
);
let cap = capability(&generation.config(), HOSTS[0]);
let response = request(
&listener,
&runtime,
raw_request(
"GET",
&format!("/relay/?bridge={cap}"),
HOSTS[0],
&format!(
"Accept: application/vnd.telemt.web-recovery+json\r\nAuthorization: Bearer {a}\r\n"
),
&[],
),
)
.await;
assert!(
response.starts_with(b"HTTP/1.1 200"),
"{}",
String::from_utf8_lossy(&response)
);
let doc: serde_json::Value = serde_json::from_slice(split_response(&response).1).unwrap();
assert!(doc["bootstrap"].as_str().is_some());
stop(runtime, &[generation]).await;
}
// Same-generation replacement and public decoy compatibility are independent regressions.
#[path = "wildcard/decoy.rs"]
mod decoy;
#[path = "wildcard/reload.rs"]
mod reload;
// Matched loopback measurements are opt-in and never run in the normal suite.
#[path = "wildcard/benchmarks.rs"]
mod benchmarks;
// Upgrade authentication must remain independent of cold-host admission pressure.
#[path = "wildcard/websocket.rs"]
mod websocket;
@@ -0,0 +1,116 @@
use super::*;
use std::time::Instant;
fn memory() -> (u64, u64) {
let text = std::fs::read_to_string("/proc/self/smaps_rollup").unwrap();
let value = |name: &str| {
text.lines()
.find_map(|line| line.strip_prefix(name))
.unwrap()
.split_whitespace()
.next()
.unwrap()
.parse::<u64>()
.unwrap()
};
(value("Rss:"), value("Anonymous:"))
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
#[ignore = "manual bounded wildcard loopback and retained-memory measurement"]
async fn wildcard_loopback_probe() {
let profiles = std::env::var("TELEMT_WILDCARD_PROFILES")
.unwrap_or_else(|_| "128".to_string())
.parse::<usize>()
.unwrap();
let directory = tempfile::tempdir().unwrap();
std::fs::write(directory.path().join("index.html"), "ordinary site").unwrap();
let users = (1..profiles)
.map(|index| format!("u{index} = \"{index:032x}\"\n"))
.collect::<String>();
let policies = (1..profiles)
.map(|index| {
format!("[[web.vhosts.profiles]]\nuser = \"u{index}\"\nsecret_mode = \"plain\"\n")
})
.collect::<String>();
let source = wildcard_source("host = \"*.example.com\"", "127.0.0.1:18081".parse().unwrap())
.replace("[access.users]", &format!("[access.users]\n{users}"))
.replace("mode = \"http_upstream\"\nupstream = \"http://127.0.0.1:18081\"",
&format!("mode = \"static_directory\"\ndirectory = {:?}", directory.path()))
.replace("[web.limits]", &format!("{policies}[web.limits]\nmax_profiles = {profiles}\nmax_bootstraps_global = 1024\nmax_bootstraps_per_ip = 1024\nnew_bootstraps_burst = 1024\nnew_bootstraps_per_minute = 60000"));
let path = directory.path().join("probe.toml");
std::fs::write(&path, source).unwrap();
let before = memory();
let started = Instant::now();
let config = ProxyConfig::load(path).unwrap();
let load_us = started.elapsed().as_micros();
let loaded = memory();
let generation = test_runtime_generation(1, config);
generation
.proxy_shared
.apply_user_config(&generation.config().access.users, &HashMap::new());
let runtime = WebProcessRuntime::start(Arc::new(ArcSwap::from(generation.clone())));
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
let bootstrap = bridge(&listener, &runtime, "warm.example.com").await;
let session = create(&runtime, "warm.example.com", &bootstrap).unwrap();
let mut results = serde_json::Map::new();
let hostile = base64::engine::general_purpose::URL_SAFE_NO_PAD.encode([0xbbu8; 32]);
for phase in ["warm", "cold", "carrier", "hostile"] {
let mut samples = Vec::new();
let cache_before = runtime.wildcard.as_ref().unwrap().test_stats();
for index in 0..110 {
let host = match phase {
"cold" => format!("cold{index}.example.com"),
"hostile" => format!("random{index}.example.com"),
_ => "warm.example.com".to_string(),
};
let cap = if phase == "hostile" {
hostile.clone()
} else {
capability(&generation.config(), &host)
};
let raw = if phase == "carrier" {
raw_request(
"POST",
"/relay/api/v1/up",
&host,
&format!(
"Authorization: Bearer {session}\r\nContent-Type: application/octet-stream\r\nX-Up-Seq: {}\r\n",
index + 1
),
&frame::encode(FrameType::Pong, 0, &[]),
)
} else {
raw_request("GET", &format!("/relay/?bridge={cap}"), &host, "", &[])
};
let started = Instant::now();
let response = request(&listener, &runtime, raw).await;
let elapsed = started.elapsed().as_micros();
let status = match phase {
"carrier" => b"HTTP/1.1 204",
"hostile" => b"HTTP/1.1 404",
_ => b"HTTP/1.1 200",
};
assert!(
response.starts_with(status),
"{}",
String::from_utf8_lossy(&response)
);
if index >= 10 {
samples.push(elapsed);
}
}
samples.sort_unstable();
let after = runtime.wildcard.as_ref().unwrap().test_stats();
results.insert(phase.to_string(), serde_json::json!({"p50_us": samples[50], "p95_us": samples[95],
"hmac_evaluations": after.2 - cache_before.2, "cache_hosts": after.0, "charged_cache_bytes": after.1}));
}
let retained = memory();
println!(
"WILDCARD_PROBE {}",
serde_json::json!({"profiles": profiles, "load_us": load_us,
"load_anonymous_delta_kib": loaded.1 as i64 - before.1 as i64,
"retained_anonymous_kib": retained.1, "retained_rss_kib": retained.0, "phases": results})
);
stop(runtime, &[generation]).await;
}
@@ -0,0 +1,91 @@
use super::*;
use crate::web::trace::{TraceBodyState, TraceRecordKind};
#[tokio::test]
async fn wildcard_unknown_foreign_credentials_preserve_decoy_bytes_but_not_diagnostic_copies() {
use tokio::io::{AsyncReadExt, AsyncWriteExt};
let site = TcpListener::bind("127.0.0.1:0").await.unwrap();
let text = wildcard_source(
"hosts = [\"*.example.com\", \"exact.example.com\"]",
site.local_addr().unwrap(),
) + "\n[web.debug]\nenabled = true\nbody_capture = \"full\"\ncapture_headers = true\n";
let generation = generation(1, &text);
let runtime = WebProcessRuntime::start(Arc::new(ArcSwap::from(generation.clone())));
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
let foreign = capability(&generation.config(), "unseen.example.com");
let encoded = foreign
.bytes()
.map(|byte| format!("%{byte:02X}"))
.collect::<String>();
let echoed = format!("response/{encoded}/end");
let expected = echoed.clone();
let server = tokio::spawn(async move {
let (mut stream, _) = site.accept().await.unwrap();
let mut received = Vec::new();
let mut byte = [0; 1];
while !received.ends_with(b"\r\n\r\n") {
stream.read_exact(&mut byte).await.unwrap();
received.push(byte[0]);
}
let response = format!(
"HTTP/1.1 200 OK\r\nContent-Length: {}\r\nETag: {}\r\nConnection: close\r\n\r\n{}",
echoed.len(),
echoed,
echoed
);
stream.write_all(response.as_bytes()).await.unwrap();
received
});
let response = request(
&listener,
&runtime,
raw_request(
"GET",
&format!("/public/{encoded}"),
"exact.example.com",
&format!(
"Cookie: ordinary={foreign}\r\nUser-Agent: {foreign}\r\nX-{foreign}: ordinary\r\n"
),
&[],
),
)
.await;
assert!(response.starts_with(b"HTTP/1.1 200"));
assert_eq!(split_response(&response).1, expected.as_bytes());
assert_eq!(
response_header(split_response(&response).0, "etag"),
expected
);
let forwarded = String::from_utf8(server.await.unwrap()).unwrap();
assert!(forwarded.contains(&encoded));
assert!(forwarded.contains(&foreign));
let records = runtime
.trace()
.snapshot_matching(|record| matches!(record.kind, TraceRecordKind::Http(_)));
assert_eq!(records.len(), 1);
let record = &records[0].record;
assert!(!record.user_agent.as_ref().unwrap().contains(&foreign));
let TraceRecordKind::Http(http) = &record.kind else {
panic!("HTTP trace")
};
assert!(!http.path.contains(&encoded));
assert!(http.request_headers.iter().all(|header| {
!header.name.contains(&foreign.to_ascii_lowercase())
&& !header
.value
.as_ref()
.is_some_and(|value| value.contains(&foreign))
}));
assert!(http.response_headers.iter().all(|header| {
!header
.value
.as_ref()
.is_some_and(|value| value.contains(&encoded))
}));
let body = http.response_body.as_ref().unwrap();
assert_eq!(body.state, TraceBodyState::Complete);
assert!(!String::from_utf8_lossy(&body.captured).contains(&encoded));
assert_eq!(runtime.wildcard.as_ref().unwrap().test_stats(), (0, 0, 0));
drop(records);
stop(runtime, &[generation]).await;
}
@@ -0,0 +1,175 @@
use super::*;
#[tokio::test]
async fn wildcard_same_generation_reload_fences_cache_and_preserves_only_equivalent_profiles() {
let text = wildcard_source(
"host = \"*.example.com\"",
"127.0.0.1:18081".parse().unwrap(),
);
let mut initial = generation(11, &text);
let (config_tx, config_rx) = tokio::sync::watch::channel(initial.config());
Arc::get_mut(&mut initial).unwrap().config_rx = config_rx;
let runtime = WebProcessRuntime::start(Arc::new(ArcSwap::from(initial.clone())));
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
let old = bridge(&listener, &runtime, HOSTS[0]).await;
let old_snapshot = initial.config().web.runtime.as_ref().unwrap().snapshot_id;
let equivalent = generation(99, &text.replace("max_sessions = 1", "max_sessions = 2"));
config_tx.send_replace(equivalent.config());
assert_eq!(runtime.active_generation().id, 11);
assert_ne!(
initial.config().web.runtime.as_ref().unwrap().snapshot_id,
old_snapshot
);
assert!(create(&runtime, HOSTS[0], &old).is_ok());
let before = runtime.wildcard.as_ref().unwrap().test_stats().2;
let unused = bridge(&listener, &runtime, HOSTS[0]).await;
assert_eq!(
runtime.wildcard.as_ref().unwrap().test_stats().2,
before + 1
);
let changed = generation(
99,
&text.replace("base_path = \"relay\"", "base_path = \"new\""),
);
config_tx.send_replace(changed.config());
assert_eq!(
create(&runtime, HOSTS[0], &unused),
Err(ManagerError::Authentication)
);
config_tx.send_replace(equivalent.config());
let unused = bridge(&listener, &runtime, HOSTS[0]).await;
let changed_secret = generation(
99,
&text.replace(
"000102030405060708090a0b0c0d0e0f",
"100102030405060708090a0b0c0d0e0f",
),
);
config_tx.send_replace(changed_secret.config());
assert_eq!(
create(&runtime, HOSTS[0], &unused),
Err(ManagerError::Authentication)
);
// A new exact winner fences the wildcard even when its old template remains loaded.
config_tx.send_replace(equivalent.config());
let unused = bridge(&listener, &runtime, HOSTS[1]).await;
let (prefix, group) = text.split_once("[[web.vhosts]]").unwrap();
let (group, limits) = group.split_once("[web.limits]").unwrap();
let exact = generation(
99,
&format!(
"{prefix}[[web.vhosts]]{group}\n[[web.vhosts]]{}\n[web.limits]{limits}",
group
.replace("host = \"*.example.com\"", "host = \"b.example.com\"")
.replace("base_path = \"relay\"", "base_path = \"other\"")
),
);
config_tx.send_replace(exact.config());
assert_eq!(
create(&runtime, HOSTS[1], &unused),
Err(ManagerError::Authentication)
);
stop(
runtime,
&[initial, equivalent, changed, changed_secret, exact],
)
.await;
}
#[tokio::test]
async fn wildcard_rule_precedence_never_falls_through_after_failed_authentication() {
use tokio::io::{AsyncReadExt, AsyncWriteExt};
let origin = TcpListener::bind("127.0.0.1:0").await.unwrap();
let text = wildcard_source("host = \"*\"", origin.local_addr().unwrap());
let (prefix, group) = text.split_once("[[web.vhosts]]").unwrap();
let (group, limits) = group.split_once("[web.limits]").unwrap();
let text = format!(
"{prefix}[[web.vhosts]]{group}\n[[web.vhosts]]{}\n[[web.vhosts]]{}\n[[web.vhosts]]{}\n[web.limits]{limits}",
group
.replace("host = \"*\"", "host = \"*.example.com\"")
.replace("base_path = \"relay\"", "base_path = \"suffix\""),
group
.replace("host = \"*\"", "host = \"*.deep.example.com\"")
.replace("base_path = \"relay\"", "base_path = \"deep\""),
group
.replace("host = \"*\"", "host = \"a.deep.example.com\"")
.replace("base_path = \"relay\"", "base_path = \"exact\"")
);
let generation = generation(1, &text);
let config = generation.config();
let web = config.web.runtime.as_ref().unwrap();
assert_eq!(web.route("a.deep.example.com").unwrap().base, "/exact/");
assert_eq!(web.route("b.deep.example.com").unwrap().base, "/deep/");
assert_eq!(web.route("b.example.com").unwrap().base, "/suffix/");
assert_eq!(web.route("example.com").unwrap().base, "/relay/");
assert_eq!(web.route("elsewhere.org").unwrap().base, "/relay/");
let runtime = WebProcessRuntime::start(Arc::new(ArcSwap::from(generation.clone())));
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
let cap = capability(&config, "b.deep.example.com");
let server = tokio::spawn(async move {
let (mut stream, _) = origin.accept().await.unwrap();
let mut head = Vec::new();
while !head.ends_with(b"\r\n\r\n") {
head.push(stream.read_u8().await.unwrap());
}
stream
.write_all(b"HTTP/1.1 200 OK\r\nContent-Length: 8\r\nConnection: close\r\n\r\nordinary")
.await
.unwrap();
head
});
let response = request(
&listener,
&runtime,
raw_request(
"GET",
&format!("/deep/?bridge={cap}"),
"b.deep.example.com",
"",
&[],
),
)
.await;
assert_eq!(split_response(&response).1, b"ordinary");
assert!(
String::from_utf8(server.await.unwrap())
.unwrap()
.contains("/deep/")
);
assert_eq!(runtime.wildcard.as_ref().unwrap().test_stats().0, 0);
stop(runtime, &[generation]).await;
}
#[tokio::test]
async fn wildcard_reordered_profiles_do_not_reuse_stale_capability_indexes() {
let text = wildcard_source(
"host = \"*.example.com\"",
"127.0.0.1:18081".parse().unwrap(),
)
.replace(
"[access.users]",
"[access.users]\nbob = \"100102030405060708090a0b0c0d0e0f\"",
)
.replace(
"[web.limits]",
"[[web.vhosts.profiles]]\nuser = \"bob\"\nsecret_mode = \"plain\"\n[web.limits]",
);
let mut initial = generation(1, &text);
let (tx, rx) = tokio::sync::watch::channel(initial.config());
Arc::get_mut(&mut initial).unwrap().config_rx = rx;
let runtime = WebProcessRuntime::start(Arc::new(ArcSwap::from(initial.clone())));
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
let unused = bridge(&listener, &runtime, HOSTS[0]).await;
let mut config = (*initial.config()).clone();
config.web.vhosts[0].profiles.reverse();
config.rebuild_runtime_web().unwrap();
tx.send_replace(Arc::new(config));
assert!(create(&runtime, HOSTS[0], &unused).is_ok());
let fresh = bridge(&listener, &runtime, HOSTS[0]).await;
let (_, profile, _) = runtime
.bootstrap_trace_identity(token_hash(&fresh), HOSTS[0])
.unwrap();
assert_eq!(profile.shared.user, "alice");
assert_eq!(runtime.wildcard.as_ref().unwrap().test_stats().2, 4);
stop(runtime, &[initial]).await;
}
@@ -0,0 +1,57 @@
use super::*;
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio_util::sync::CancellationToken;
#[tokio::test]
async fn wildcard_websocket_upgrade_uses_actual_host_without_cold_derivation() {
let text = wildcard_source(
"host = \"*.example.com\"",
"127.0.0.1:18081".parse().unwrap(),
)
.replace("carrier = \"https\"", "carrier = \"websocket\"")
+ "\n[web.limits.wildcard]\nmax_profiles_per_request = 1\ncold_hmac_burst = 1\ncold_hmac_per_minute = 1\ncache_hosts = 0\n";
let generation = generation(1, &text);
let runtime = WebProcessRuntime::start(Arc::new(ArcSwap::from(generation.clone())));
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
let bootstrap = bridge(&listener, &runtime, HOSTS[0]).await;
let session = create(&runtime, HOSTS[0], &bootstrap).unwrap();
for (host, status) in [(HOSTS[1], b"HTTP/1.1 404"), (HOSTS[0], b"HTTP/1.1 101")] {
let (accepted, client) = tokio::join!(
listener.accept(),
TcpStream::connect(listener.local_addr().unwrap())
);
let (server, peer) = accepted.unwrap();
let mut client = client.unwrap();
let cancel = CancellationToken::new();
let task = tokio::spawn(crate::web::http::serve_connection(
server,
peer,
crate::config::WebClientIpSource::XForwardedFor,
Arc::from(["127.0.0.1/32".parse().unwrap()]),
runtime.clone(),
cancel.clone(),
runtime.try_http_connection().unwrap(),
));
client.write_all(format!("GET /relay/api/v1/ws HTTP/1.1\r\nHost: {host}\r\nX-Forwarded-For: 192.0.2.10\r\nConnection: Upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Version: 13\r\nSec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\nSec-WebSocket-Protocol: tproxy-v1.{session}\r\nCookie: ordinary=allowed\r\n\r\n").as_bytes()).await.unwrap();
let mut response = Vec::new();
while !response.ends_with(b"\r\n\r\n") {
response.push(
tokio::time::timeout(Duration::from_secs(2), client.read_u8())
.await
.unwrap()
.unwrap(),
);
assert!(response.len() < 16 * 1024);
}
assert!(
response.starts_with(status),
"{}",
String::from_utf8_lossy(&response)
);
drop(client);
cancel.cancel();
task.await.unwrap();
}
assert_eq!(runtime.wildcard.as_ref().unwrap().test_stats(), (0, 0, 1));
stop(runtime, &[generation]).await;
}
+3 -3
View File
@@ -6,7 +6,7 @@ use serde::Serialize;
use super::request::{bearer_token_hash, compatible_cookie_header};
use super::response::{full_response, insert_header};
use super::{HttpResponse, RequestBody};
use crate::config::{WebRuntimeProfile, WebRuntimeVhost};
use crate::config::WebRuntimeProfile;
use crate::web::manager::{BootstrapResult, TokenHash};
pub(super) const MEDIA_TYPE: &str = "application/vnd.telemt.web-recovery+json";
@@ -71,7 +71,7 @@ pub(super) fn has_media_type(request: &Request<RequestBody>) -> bool {
/// Builds the bounded no-store recovery representation.
pub(super) fn response(
bootstrap: &BootstrapResult,
vhost: &WebRuntimeVhost,
host: &str,
profile: &WebRuntimeProfile,
limits: &crate::config::WebLimitsConfig,
timeouts: &crate::config::WebTimeoutsConfig,
@@ -101,7 +101,7 @@ pub(super) fn response(
},
};
let body = serde_json::to_vec(&document).ok()?;
if body.len() > MAX_RESPONSE_BYTES || profile.host != vhost.host {
if body.len() > MAX_RESPONSE_BYTES || profile.host != host {
return None;
}
let mut response = full_response(StatusCode::OK, Bytes::from(body));
+3 -1
View File
@@ -17,7 +17,9 @@ use super::capability::scan_capabilities;
// Canonical host and forwarded-address provenance remain isolated from credentials.
mod identity;
pub(super) use identity::{canonical_request_host, carrier_ip_learning_eligible, client_ip};
pub(super) use identity::{
canonical_request_host, carrier_ip_learning_eligible, client_ip, wildcard_request_host,
};
/// Matches one capability after a complete branchless scan of the virtual host table.
pub(super) fn match_profile(
+43
View File
@@ -25,6 +25,49 @@ pub(in crate::web::http) fn canonical_request_host<B>(request: &Request<B>) -> O
Some(host)
}
/// Canonicalizes one ASCII DNS authority into bounded request-local storage.
/// Only the literal public HTTPS port is permitted; forwarding headers are ignored.
pub(in crate::web::http) fn wildcard_request_host<'a, B>(
request: &Request<B>,
storage: &'a mut [u8; 253],
) -> Option<&'a str> {
let mut values = request.headers().get_all(header::HOST).iter();
let value = values.next()?.to_str().ok()?;
if values.next().is_some() {
return None;
}
let host = value.strip_suffix(":443").unwrap_or(value);
if host.len() > storage.len() || !host.contains('.') || !host.is_ascii() {
return None;
}
for (out, byte) in storage.iter_mut().zip(host.bytes()) {
*out = byte.to_ascii_lowercase();
}
let host = std::str::from_utf8(&storage[..host.len()]).ok()?;
if host.parse::<IpAddr>().is_ok()
|| host.split('.').any(|label| {
label.is_empty()
|| label.len() > 63
|| label.starts_with('-')
|| label.ends_with('-')
|| !label
.bytes()
.all(|byte| byte.is_ascii_alphanumeric() || byte == b'-')
})
{
return None;
}
let last = host.rsplit('.').next()?;
if last.bytes().all(|byte| byte.is_ascii_digit())
|| last
.strip_prefix("0x")
.is_some_and(|digits| digits.bytes().all(|byte| byte.is_ascii_hexdigit()))
{
return None;
}
Some(host)
}
/// Accepts one forwarded client address or the direct address of a trusted peer.
pub(in crate::web::http) fn client_ip<B>(
request: &Request<B>,
+40 -16
View File
@@ -14,20 +14,39 @@ pub(super) fn mark_internal_credential<B>(
config: &WebRuntimeConfig,
runtime: &WebProcessRuntime,
) {
let found = visit_metadata(request, |candidate| {
bool::from(scan_capabilities(&config.capabilities, candidate).matched)
|| runtime.authentic_token(candidate)
|| runtime
.wildcard
.as_ref()
.is_some_and(|cache| cache.contains(candidate))
});
if found {
mark(request);
}
}
/// Marks a request after a full selected-host capability scan authenticated metadata.
pub(super) fn mark<B>(request: &mut Request<B>) {
request.extensions_mut().insert(InternalCredential);
}
/// Visits canonical raw or percent-decoded credential windows without allocating.
pub(super) fn visit_metadata<B>(
request: &Request<B>,
mut visit: impl FnMut(&[u8; 32]) -> bool,
) -> bool {
let uri = request.uri();
let uri_contains = uri
.authority()
.is_some_and(|authority| contains_secret(authority.as_str().as_bytes(), config, runtime))
uri.authority()
.is_some_and(|value| visit_text(value.as_str().as_bytes(), &mut visit))
|| uri
.path_and_query()
.is_some_and(|path| contains_secret(path.as_str().as_bytes(), config, runtime));
let headers_contain = request.headers().iter().any(|(name, value)| {
contains_secret(name.as_str().as_bytes(), config, runtime)
|| contains_secret(value.as_bytes(), config, runtime)
});
if uri_contains || headers_contain {
request.extensions_mut().insert(InternalCredential);
}
.is_some_and(|value| visit_text(value.as_str().as_bytes(), &mut visit))
|| request.headers().iter().any(|(name, value)| {
visit_text(name.as_str().as_bytes(), &mut visit)
|| visit_text(value.as_bytes(), &mut visit)
})
}
/// Returns whether request metadata was authenticated before routing.
@@ -35,7 +54,7 @@ pub(super) fn has_internal_credential<B>(request: &Request<B>) -> bool {
request.extensions().get::<InternalCredential>().is_some()
}
fn contains_secret(text: &[u8], config: &WebRuntimeConfig, runtime: &WebProcessRuntime) -> bool {
fn visit_text(text: &[u8], visit: &mut impl FnMut(&[u8; 32]) -> bool) -> bool {
let mut window = [0; 43];
let mut run_len = 0usize;
let mut offset = 0usize;
@@ -58,10 +77,7 @@ fn contains_secret(text: &[u8], config: &WebRuntimeConfig, runtime: &WebProcessR
window[42] = byte;
}
if run_len >= window.len()
&& canonical_credential(&window).is_some_and(|candidate| {
bool::from(scan_capabilities(&config.capabilities, &candidate).matched)
|| runtime.authentic_token(&candidate)
})
&& canonical_credential(&window).is_some_and(|candidate| visit(&candidate))
{
return true;
}
@@ -88,3 +104,11 @@ fn hex_value(value: u8) -> Option<u8> {
#[cfg(test)]
#[path = "secrets/tests.rs"]
mod tests;
#[cfg(test)]
fn contains_secret(text: &[u8], config: &WebRuntimeConfig, runtime: &WebProcessRuntime) -> bool {
visit_text(text, &mut |candidate| {
bool::from(scan_capabilities(&config.capabilities, candidate).matched)
|| runtime.authentic_token(candidate)
})
}
+7 -8
View File
@@ -26,6 +26,7 @@ pub(super) async fn handle_session(
request: Request<RequestBody>,
runtime: Arc<WebProcessRuntime>,
vhost: Arc<WebRuntimeVhost>,
host: &str,
token_hash: TokenHash,
client_ip: IpAddr,
) -> HttpResponse {
@@ -39,7 +40,7 @@ pub(super) async fn handle_session(
let Some(carrier_failure) = optional_failure_header(&request) else {
return serve_decoy(request, vhost, true, &runtime).await;
};
let session = runtime.get_session(token_hash, &vhost.host).ok();
let session = runtime.get_session(token_hash, host).ok();
if let Some(trace) = request_trace(&request)
&& let Some(session) = &session
{
@@ -63,7 +64,7 @@ pub(super) async fn handle_session(
};
if !body.is_empty()
|| runtime
.close_token(token_hash, &vhost.host, carrier_failure)
.close_token(token_hash, host, carrier_failure)
.is_err()
{
return serve_decoy(request, vhost, true, &runtime).await;
@@ -73,7 +74,7 @@ pub(super) async fn handle_session(
if request.method() != Method::POST || !binary_content_type(&request) {
return serve_decoy(request, vhost, true, &runtime).await;
}
let Some(carrier_request) = carrier_request(&request, &vhost.host) else {
let Some(carrier_request) = carrier_request(&request, host) else {
return serve_decoy(request, vhost, true, &runtime).await;
};
let up_window = if request.headers().contains_key("x-telemt-up-window") {
@@ -89,7 +90,7 @@ pub(super) async fn handle_session(
let carrier_request = carrier_request.with_up_window(up_window);
let ip_learning_eligible = carrier_ip_learning_eligible(&request, client_ip);
let Some((trace_session_id, profile, body_timeout)) =
runtime.bootstrap_trace_identity(token_hash, &vhost.host)
runtime.bootstrap_trace_identity(token_hash, host)
else {
return serve_decoy(request, vhost, true, &runtime).await;
};
@@ -117,7 +118,7 @@ pub(super) async fn handle_session(
}
match runtime.create_session(
token_hash,
&vhost.host,
host,
client_ip,
&body,
carrier_request,
@@ -185,9 +186,7 @@ pub(super) async fn handle_session(
}
Err(ManagerError::Committed) => {
let mut response = carrier_empty(StatusCode::CONFLICT);
if let Some(echo) =
runtime.carrier_echo(token_hash, &vhost.host, client_ip, carrier_request)
{
if let Some(echo) = runtime.carrier_echo(token_hash, host, client_ip, carrier_request) {
response.headers_mut().insert(
HeaderName::from_static("x-carrier-mode"),
HeaderValue::from_static(echo.carrier.as_str()),
+6
View File
@@ -129,6 +129,7 @@ fn runtime_config_with_carriers_and_deadlines(
host: "proxy.example.com".to_string(),
capability,
shared: Arc::new(crate::config::WebRuntimeProfileShared {
derivation_context: [0; 32],
public_addr: "203.0.113.10:443".parse().unwrap(),
user: "alice".to_string(),
secret_mode: WebSecretMode::Plain,
@@ -158,6 +159,7 @@ fn runtime_config_with_carriers_and_deadlines(
index: "index.html".to_string(),
});
let vhost = Arc::new(WebRuntimeVhost {
wildcard: None,
host: "proxy.example.com".to_string(),
base: base.to_string(),
decoy_fasttrack_mode: WebDecoyFastTrackMode::Off,
@@ -171,6 +173,7 @@ fn runtime_config_with_carriers_and_deadlines(
vhosts.insert(
"other.example.com".to_string(),
Arc::new(WebRuntimeVhost {
wildcard: None,
host: "other.example.com".to_string(),
base: "/".to_string(),
decoy_fasttrack_mode: WebDecoyFastTrackMode::Off,
@@ -193,6 +196,9 @@ fn runtime_config_with_carriers_and_deadlines(
config.web.limits.max_bootstraps_per_ip = 1;
config.web.timeouts.shutdown_secs = 1;
config.web.runtime = Some(Arc::new(WebRuntimeConfig {
snapshot_id: 0,
wildcards: Default::default(),
catch_all: None,
vhosts,
profiles: vec![profile],
capabilities: vec![capability].into_boxed_slice(),
+2 -1
View File
@@ -6,6 +6,7 @@ pub(super) async fn handle_up(
request: Request<RequestBody>,
runtime: Arc<WebProcessRuntime>,
vhost: Arc<WebRuntimeVhost>,
host: &str,
token_hash: crate::web::manager::TokenHash,
) -> HttpResponse {
if !matches!(*request.method(), Method::POST | Method::PUT) || !binary_content_type(&request) {
@@ -15,7 +16,7 @@ pub(super) async fn handle_up(
else {
return serve_decoy(request, vhost, true, &runtime).await;
};
let Ok(session) = runtime.get_session(token_hash, &vhost.host) else {
let Ok(session) = runtime.get_session(token_hash, host) else {
return serve_decoy(request, vhost, true, &runtime).await;
};
if session.carrier().uses_websocket() {
+2 -1
View File
@@ -253,6 +253,7 @@ pub(super) async fn handle(
trusted_proxy_cidrs: &[IpNetwork],
runtime: Arc<WebProcessRuntime>,
vhost: Arc<WebRuntimeVhost>,
host: &str,
) -> HttpResponse {
let request_deadline = super::request_deadline(&request);
let Some(parsed) = parse_upgrade(&request) else {
@@ -265,7 +266,7 @@ pub(super) async fn handle(
else {
return serve_decoy(request, vhost, true, &runtime).await;
};
let Ok(session) = runtime.get_session(parsed.token_hash, &vhost.host) else {
let Ok(session) = runtime.get_session(parsed.token_hash, host) else {
return serve_decoy(request, vhost, true, &runtime).await;
};
let kind = match (parsed.carrier, session.carrier()) {
+72
View File
@@ -0,0 +1,72 @@
use super::*;
use crate::config::{ProxyConfig, WebRuntimeProfile};
use crate::web::manager::wildcard::CapabilityTable;
/// Contains actual credentials and derives at most one selected-host table per request.
pub(super) fn prepare<B>(
request: &mut Request<B>,
config: &ProxyConfig,
vhost: &WebRuntimeVhost,
host: &str,
runtime: &WebProcessRuntime,
) -> Result<Option<CapabilityTable>, ()> {
// A process-authentic credential can never reach the decoy. Established carriers
// need no host-table lookup, HMAC derivation or host binding allocation.
let suffix = request.uri().path().strip_prefix(&vhost.base);
if suffix
.is_some_and(|suffix| TRANSPORT_SUFFIXES.contains(&suffix) || suffix == WEBSOCKET_SUFFIX)
&& runtime.wildcard.is_some()
&& secrets::visit_metadata(request, |candidate| runtime.authentic_token(candidate))
{
secrets::mark(request);
return Ok(None);
}
let web = config.web.runtime.as_ref().ok_or(())?;
secrets::mark_internal_credential(request, web, runtime);
if vhost.wildcard.is_none() {
return Ok(None);
}
let root_full_scan = request.uri().path() == vhost.base
&& matches!(*request.method(), Method::GET | Method::HEAD)
&& vhost.decoy_fasttrack_mode != WebDecoyFastTrackMode::Enforce;
let candidate_present = secrets::visit_metadata(request, |_| true);
if !root_full_scan && !candidate_present {
return Ok(None);
}
let cache = runtime.wildcard.as_ref().ok_or(())?;
let table = cache.prepare(config, vhost, host).ok_or(())?;
if secrets::visit_metadata(request, |candidate| {
bool::from(capability::scan_capabilities(table.capabilities(), candidate).matched)
}) {
secrets::mark(request);
}
Ok(Some(table))
}
/// Creates one host binding only after a complete constant-time capability scan.
pub(super) fn match_profile(
vhost: &WebRuntimeVhost,
host: &str,
table: Option<&CapabilityTable>,
candidate: &[u8; 32],
) -> Option<Arc<WebRuntimeProfile>> {
let Some(group) = &vhost.wildcard else {
return super::match_profile(vhost, candidate);
};
let capabilities = table?.capabilities();
if capabilities.len() != group.profiles.len() {
return None;
}
let scan = capability::scan_capabilities(capabilities, candidate);
if !bool::from(scan.matched) {
return None;
}
let shared = group
.profiles
.get(usize::try_from(scan.matched_index).ok()?)?;
Some(Arc::new(WebRuntimeProfile {
host: host.to_string(),
capability: *candidate,
shared: Arc::clone(shared),
}))
}