mirror of
https://github.com/telemt/telemt.git
synced 2026-11-22 07:16:38 +03:00
WEB: bounded opt-in wildcard host routing added
This commit is contained in:
@@ -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(),
|
||||
|
||||
@@ -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(),
|
||||
|
||||
@@ -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(
|
||||
|
||||
@@ -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() {
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
@@ -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));
|
||||
|
||||
@@ -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(
|
||||
|
||||
@@ -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
@@ -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)
|
||||
})
|
||||
}
|
||||
|
||||
@@ -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()),
|
||||
|
||||
@@ -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
@@ -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() {
|
||||
|
||||
@@ -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()) {
|
||||
|
||||
@@ -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),
|
||||
}))
|
||||
}
|
||||
Reference in New Issue
Block a user