From bcac6c76e64bfbf513390e6bbc30fd7dc1f438ae Mon Sep 17 00:00:00 2001 From: ari Date: Mon, 19 Oct 2026 20:14:40 -0400 Subject: [PATCH] A: A2 validate peer names, URLs, token files and timeouts --- Cargo.toml | 1 + src/config.rs | 1 + src/peers/config.rs | 461 ++++++++++++++++++++++++++++++++++++++++++ src/peers/mod.rs | 1 + tests/peers_config.rs | 126 +++++++++++- 5 files changed, 582 insertions(+), 8 deletions(-) create mode 100644 src/peers/config.rs diff --git a/Cargo.toml b/Cargo.toml index 7b4880e..a45653e 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -44,6 +44,7 @@ bytes = "1.12.1" serde = { version = "1.0.229", features = ["derive"] } serde_json = "1.0.154" url = { version = "2.5.8", features = ["serde"] } +ipnet = "2.12" percent-encoding = "2.3.2" schemars = { version = "1.2.3", features = ["jiff02"] } jiff = { version = "0.2.38", features = ["serde"] } diff --git a/src/config.rs b/src/config.rs index 4d1e465..22a887b 100644 --- a/src/config.rs +++ b/src/config.rs @@ -314,6 +314,7 @@ impl Config { "otel.metrics_interval_secs must be greater than zero".into(), )); } + crate::peers::config::validate(&self.peers)?; Ok(()) } diff --git a/src/peers/config.rs b/src/peers/config.rs new file mode 100644 index 0000000..0741bbe --- /dev/null +++ b/src/peers/config.rs @@ -0,0 +1,461 @@ +//! Validation for the `[peers]` section. +//! +//! Structural checks run even when the feature is off, so a bad entry is not +//! silent until someone flips `enabled`. Token files are opened only for +//! peers that would actually be contacted. + +use std::collections::BTreeSet; +use std::net::IpAddr; + +use ipnet::IpNet; +use url::Url; + +use crate::config::ConfigError; +use crate::peers::types::{PeerConfig, PeersConfig, MAX_PEERS}; + +pub fn validate(cfg: &PeersConfig) -> Result<(), ConfigError> { + timeout_below("tcp", cfg.tcp_timeout_secs, cfg.tcp_interval_secs)?; + timeout_below("api", cfg.api_timeout_secs, cfg.api_interval_secs)?; + let deny = parse_deny(&cfg.deny_cidrs)?; + if cfg.peer.len() > MAX_PEERS { + return Err(ConfigError::Invalid(format!( + "at most {MAX_PEERS} peers may be configured (got {})", + cfg.peer.len() + ))); + } + let mut seen = BTreeSet::new(); + for peer in &cfg.peer { + if !seen.insert(peer.name.clone()) { + return Err(ConfigError::Invalid(format!( + "duplicate peer name '{}'", + peer.name + ))); + } + validate_peer(cfg.enabled, peer, &deny)?; + } + if cfg.enabled && cfg.peer.is_empty() { + tracing::warn!("peers.enabled is true but no peers are configured"); + } + Ok(()) +} + +fn timeout_below(kind: &str, timeout: u64, interval: u64) -> Result<(), ConfigError> { + if interval == 0 || timeout == 0 || timeout >= interval { + return Err(ConfigError::Invalid(format!( + "{kind}_timeout_secs ({timeout}) must be greater than zero and below {kind}_interval_secs ({interval})" + ))); + } + Ok(()) +} + +fn parse_deny(cidrs: &[String]) -> Result, ConfigError> { + cidrs + .iter() + .map(|cidr| { + cidr.parse::().map_err(|err| { + ConfigError::Invalid(format!("deny_cidrs entry {cidr:?} is not a CIDR ({err})")) + }) + }) + .collect() +} + +fn validate_peer( + section_enabled: bool, + peer: &PeerConfig, + deny: &[IpNet], +) -> Result<(), ConfigError> { + validate_url(section_enabled, peer, deny)?; + if let Some(ca) = &peer.ca_file { + if !ca.is_absolute() { + return Err(ConfigError::Invalid(format!( + "peer {}: ca_file must be an absolute path", + peer.name + ))); + } + } + if !peer.token_file.is_absolute() { + return Err(ConfigError::Invalid(format!( + "peer {}: token_file must be an absolute path", + peer.name + ))); + } + // Only peers this process will call need a readable file. A disabled + // entry can name a credential that is not on disk yet. + if section_enabled && peer.enabled { + match std::fs::metadata(&peer.token_file) { + Ok(meta) if meta.is_file() => {} + Ok(_) => { + return Err(ConfigError::Invalid(format!( + "peer {}: token_file {} is not a file", + peer.name, + peer.token_file.display() + ))) + } + Err(err) => { + return Err(ConfigError::Invalid(format!( + "peer {}: token_file {} is not readable: {err}", + peer.name, + peer.token_file.display() + ))) + } + } + } + Ok(()) +} + +fn validate_url( + section_enabled: bool, + peer: &PeerConfig, + deny: &[IpNet], +) -> Result<(), ConfigError> { + let url = &peer.url; + if url.scheme() != "http" && url.scheme() != "https" { + return Err(ConfigError::Invalid(format!( + "peer {}: url scheme must be http or https", + peer.name + ))); + } + // Userinfo and query can carry a credential. The message stays generic + // so the rejected value is not copied into logs. + if !url.username().is_empty() || url.password().is_some() { + return Err(ConfigError::Invalid(format!( + "peer {}: url must not contain userinfo", + peer.name + ))); + } + if url.query().is_some() { + return Err(ConfigError::Invalid(format!( + "peer {}: url must not contain a query", + peer.name + ))); + } + if url.fragment().is_some() { + return Err(ConfigError::Invalid(format!( + "peer {}: url must not contain a fragment", + peer.name + ))); + } + let host = url.host_str().ok_or_else(|| { + ConfigError::Invalid(format!("peer {}: url is missing a host", peer.name)) + })?; + // A name is not an address yet, so it cannot be matched here. + if let Some(ip) = host_ip(url) { + if deny.iter().any(|net| net.contains(&ip)) { + return Err(ConfigError::Invalid(format!( + "peer {}: host {ip} is in deny_cidrs", + peer.name + ))); + } + } + if url.scheme() == "http" && !is_loopback(url) { + if !peer.allow_plain_http { + return Err(ConfigError::Invalid(format!( + "peer {}: plain http to non-loopback host {host:?} requires allow_plain_http = true", + peer.name + ))); + } + if section_enabled && peer.enabled { + tracing::warn!( + peer = %peer.name, + "plain http to a non-loopback host; the bearer token travels in cleartext" + ); + } + } + Ok(()) +} + +fn host_ip(url: &Url) -> Option { + match url.host()? { + url::Host::Ipv4(ip) => Some(IpAddr::V4(ip)), + url::Host::Ipv6(ip) => Some(IpAddr::V6(ip)), + url::Host::Domain(_) => None, + } +} + +fn is_loopback(url: &Url) -> bool { + match url.host() { + Some(url::Host::Domain(host)) => host.eq_ignore_ascii_case("localhost"), + Some(url::Host::Ipv4(ip)) => ip.is_loopback(), + Some(url::Host::Ipv6(ip)) => ip.is_loopback(), + None => false, + } +} + +#[cfg(test)] +mod tests { + use std::path::PathBuf; + use std::sync::{Arc, Mutex}; + + use super::*; + use crate::peers::types::PeerName; + use tracing_subscriber::layer::SubscriberExt; + + fn peer(name: &str, url: &str) -> PeerConfig { + PeerConfig { + name: PeerName::parse(name).unwrap(), + url: Url::parse(url).unwrap(), + token_file: PathBuf::from(format!("/run/peers/{name}.token")), + ca_file: None, + allow_plain_http: false, + enabled: true, + } + } + + fn disabled_section(peers: Vec) -> PeersConfig { + PeersConfig { + enabled: false, + peer: peers, + ..PeersConfig::default() + } + } + + fn message(err: ConfigError) -> String { + match err { + ConfigError::Invalid(message) => message, + other => panic!("expected Invalid, got {other}"), + } + } + + struct Capture(Arc>>); + + impl tracing_subscriber::Layer for Capture { + fn on_event( + &self, + event: &tracing::Event<'_>, + _ctx: tracing_subscriber::layer::Context<'_, S>, + ) { + let mut msg = String::new(); + event.record(&mut FieldVisit(&mut msg)); + self.0.lock().expect("log lock").push(msg); + } + } + + struct FieldVisit<'a>(&'a mut String); + + impl tracing::field::Visit for FieldVisit<'_> { + fn record_debug(&mut self, field: &tracing::field::Field, value: &dyn std::fmt::Debug) { + use std::fmt::Write; + let _ = write!(self.0, "{}={value:?} ", field.name()); + } + } + + fn logged(f: impl FnOnce()) -> String { + let buf = Arc::new(Mutex::new(Vec::new())); + let sub = tracing_subscriber::registry().with(Capture(buf.clone())); + tracing::subscriber::with_default(sub, f); + let text = buf.lock().expect("log lock").join("\n"); + text + } + + #[test] + fn defaults_and_loopback_http_are_valid() { + validate(&PeersConfig::default()).unwrap(); + let mut beta = peer("beta", "http://127.0.0.1:1984"); + beta.token_file = PathBuf::from("/tmp/does-not-need-to-exist"); + validate(&disabled_section(vec![beta])).unwrap(); + validate(&disabled_section(vec![peer( + "beta", + "http://localhost:1984", + )])) + .unwrap(); + validate(&disabled_section(vec![peer("beta", "http://[::1]:1984")])).unwrap(); + validate(&disabled_section(vec![peer( + "beta", + "https://minipc1:1984/base", + )])) + .unwrap(); + } + + fn timings( + tcp_timeout: u64, + tcp_interval: u64, + api_timeout: u64, + api_interval: u64, + ) -> PeersConfig { + PeersConfig { + tcp_timeout_secs: tcp_timeout, + tcp_interval_secs: tcp_interval, + api_timeout_secs: api_timeout, + api_interval_secs: api_interval, + ..PeersConfig::default() + } + } + + #[test] + fn timeouts_must_be_below_their_interval() { + let err = message(validate(&timings(10, 10, 5, 30)).unwrap_err()); + assert!(err.contains("tcp_timeout_secs")); + assert!(err.contains("below")); + assert!( + message(validate(&timings(3, 10, 30, 30)).unwrap_err()).contains("api_timeout_secs") + ); + assert!( + message(validate(&timings(3, 10, 0, 30)).unwrap_err()).contains("greater than zero") + ); + } + + #[test] + fn names_are_unique_and_capped() { + let err = message( + validate(&disabled_section(vec![ + peer("beta", "https://beta:1984"), + peer("beta", "https://beta:1985"), + ])) + .unwrap_err(), + ); + assert!(err.contains("duplicate")); + assert!(err.contains("beta")); + + let peers = (0..MAX_PEERS + 1) + .map(|i| { + let mut p = peer("beta", "https://beta:1984"); + p.name = PeerName::parse(&format!("p{i}")).unwrap(); + p + }) + .collect(); + let err = message(validate(&disabled_section(peers)).unwrap_err()); + assert!(err.contains("64")); + } + + #[test] + fn url_rules_reject_scheme_userinfo_query_fragment_and_deny_list() { + let cases = [ + ("ftp://beta:1984", "scheme"), + ("http://user:s3cret@127.0.0.1:1984", "userinfo"), + ("https://beta:1984?token=s3cret", "query"), + ("https://beta:1984#s3cret", "fragment"), + ("http://169.254.169.254/latest", "deny_cidrs"), + ("https://0.1.2.3:1984", "deny_cidrs"), + ]; + for (url, needle) in cases { + let err = message(validate(&disabled_section(vec![peer("beta", url)])).unwrap_err()); + assert!(err.contains(needle), "{url} -> {err}"); + assert!(err.contains("beta"), "{url} -> {err}"); + assert!(!err.contains("s3cret"), "{url} leaked into {err}"); + } + } + + #[test] + fn plain_http_off_loopback_requires_the_flag_and_warns_when_set() { + let err = message( + validate(&disabled_section(vec![peer("beta", "http://minipc1:1984")])).unwrap_err(), + ); + assert!(err.contains("beta")); + assert!(err.contains("allow_plain_http")); + assert!(!err.contains("token")); + + let dir = TempDir::new(); + let mut allowed = peer("beta", "http://10.1.2.3:1984"); + allowed.allow_plain_http = true; + allowed.token_file = dir.write_token("pending\n"); + let cfg = PeersConfig { + enabled: true, + peer: vec![allowed], + ..PeersConfig::default() + }; + let logs = logged(|| validate(&cfg).unwrap()); + assert!(logs.contains("cleartext"), "{logs}"); + assert!(logs.contains("beta"), "{logs}"); + assert!(!logs.contains("10.1.2.3"), "{logs}"); + } + + #[test] + fn deny_cidr_must_parse_and_ipv6_literals_match() { + let cfg = PeersConfig { + deny_cidrs: vec!["not-a-cidr".into()], + ..PeersConfig::default() + }; + assert!(message(validate(&cfg).unwrap_err()).contains("not-a-cidr")); + + let mut beta = peer("beta", "http://[fe80::1]:1984"); + beta.allow_plain_http = true; + let cfg = PeersConfig { + deny_cidrs: vec!["fe80::/10".into()], + peer: vec![beta], + ..PeersConfig::default() + }; + let err = message(validate(&cfg).unwrap_err()); + assert!(err.contains("deny_cidrs"), "{err}"); + assert!(err.contains("fe80::1"), "{err}"); + } + + #[test] + fn token_file_must_be_absolute_and_readable_only_when_used() { + let mut relative = peer("beta", "https://beta:1984"); + relative.token_file = PathBuf::from("peer-beta"); + let err = message(validate(&disabled_section(vec![relative])).unwrap_err()); + assert!(err.contains("beta")); + assert!(err.contains("absolute")); + + let mut cfg = PeersConfig { + enabled: true, + peer: vec![peer("beta", "https://beta:1984")], + ..PeersConfig::default() + }; + let err = message(validate(&cfg).unwrap_err()); + assert!(err.contains("peer beta")); + assert!(err.contains("not readable")); + + cfg.peer[0].enabled = false; + validate(&cfg).unwrap(); + + let dir = TempDir::new(); + cfg.peer[0].enabled = true; + cfg.peer[0].token_file = dir.write_token("pending\n"); + validate(&cfg).unwrap(); + } + + #[test] + fn ca_file_must_be_absolute_when_set() { + let mut beta = peer("beta", "https://beta:1984"); + beta.ca_file = Some(PathBuf::from("ca.pem")); + let err = message(validate(&disabled_section(vec![beta])).unwrap_err()); + assert!(err.contains("ca_file")); + assert!(err.contains("beta")); + } + + #[test] + fn enabled_with_no_peers_warns_and_is_not_an_error() { + let cfg = PeersConfig { + enabled: true, + ..PeersConfig::default() + }; + let logs = logged(|| validate(&cfg).unwrap()); + assert!(logs.contains("no peers are configured"), "{logs}"); + } + + #[test] + fn loopback_detection_covers_localhost_and_127() { + assert!(is_loopback(&Url::parse("http://LOCALHOST:1984").unwrap())); + assert!(is_loopback(&Url::parse("http://127.0.0.2:1984").unwrap())); + assert!(!is_loopback(&Url::parse("http://10.0.0.1:1984").unwrap())); + } + + /// Removes the directory on drop, including when an assertion panics. + struct TempDir(PathBuf); + + impl TempDir { + fn new() -> Self { + let nanos = std::time::SystemTime::now() + .duration_since(std::time::UNIX_EPOCH) + .unwrap() + .subsec_nanos(); + let path = std::env::temp_dir() + .join(format!("slinuxm-peer-cfg-{}-{nanos}", std::process::id())); + std::fs::create_dir(&path).unwrap(); + Self(path) + } + + fn write_token(&self, contents: &str) -> PathBuf { + let path = self.0.join("token"); + std::fs::write(&path, contents).unwrap(); + path + } + } + + impl Drop for TempDir { + fn drop(&mut self) { + let _ = std::fs::remove_dir_all(&self.0); + } + } +} diff --git a/src/peers/mod.rs b/src/peers/mod.rs index bee2359..d161ca6 100644 --- a/src/peers/mod.rs +++ b/src/peers/mod.rs @@ -4,6 +4,7 @@ //! to the host. The registry read side is lock-light because REST, MCP and //! metrics render status on every scrape. +pub mod config; pub mod error; pub mod health; pub mod proxy; diff --git a/tests/peers_config.rs b/tests/peers_config.rs index 414cf29..e841803 100644 --- a/tests/peers_config.rs +++ b/tests/peers_config.rs @@ -157,9 +157,16 @@ async fn peerless_default_is_off_and_unchanged() { #[allow(clippy::result_large_err)] // figment::Jail closures return figment::Error fn vm_peer_entries_load_when_enabled_and_ca_file_are_omitted() { Jail::expect_with(|jail| { + let beta_token = jail.directory().join("peer-beta"); + let gamma_token = jail.directory().join("peer-gamma"); + let delta_token = jail.directory().join("peer-delta"); + for path in [&beta_token, &gamma_token, &delta_token] { + write_private_token(path, "pending\n"); + } jail.create_file( "peers.toml", - r#" + &format!( + r#" [server] bind = "0.0.0.0" @@ -175,22 +182,26 @@ fn vm_peer_entries_load_when_enabled_and_ca_file_are_omitted() { [[peers.peer]] name = "beta" url = "http://beta:1984" - token_file = "/run/credentials/skyg-linux-tracker.service/peer-beta" + token_file = "{beta}" allow_plain_http = true [[peers.peer]] name = "gamma" url = "https://gamma:1984" - token_file = "/run/credentials/skyg-linux-tracker.service/peer-gamma" + token_file = "{gamma}" ca_file = "/etc/ssl/private-ca.pem" allow_plain_http = false [[peers.peer]] name = "delta" url = "https://delta:1984" - token_file = "/run/credentials/skyg-linux-tracker.service/peer-delta" + token_file = "{delta}" enabled = false "#, + beta = beta_token.display(), + gamma = gamma_token.display(), + delta = delta_token.display(), + ), )?; let cfg = Config::load(Some(Path::new("peers.toml")), &CliOverrides::default()) .expect("peer entries must deserialize"); @@ -213,10 +224,7 @@ fn vm_peer_entries_load_when_enabled_and_ca_file_are_omitted() { assert!(beta.enabled); assert!(beta.allow_plain_http); assert!(beta.ca_file.is_none()); - assert_eq!( - beta.token_file, - PathBuf::from("/run/credentials/skyg-linux-tracker.service/peer-beta") - ); + assert_eq!(beta.token_file, beta_token); let gamma = peer("gamma"); assert!(gamma.enabled); assert!(!gamma.allow_plain_http); @@ -232,6 +240,108 @@ fn vm_peer_entries_load_when_enabled_and_ca_file_are_omitted() { }); } +#[test] +#[allow(clippy::result_large_err)] // figment::Jail closures return figment::Error +fn load_rejects_invalid_peers_and_accepts_a_placeholder_token() { + Jail::expect_with(|jail| { + jail.create_file("empty-peers.toml", "[peers]\nenabled = true\n")?; + Config::load( + Some(Path::new("empty-peers.toml")), + &CliOverrides::default(), + ) + .expect("enabled with zero peers is a warning, not an error"); + + jail.create_file( + "bad-name.toml", + "\ + [peers]\n\ + [[peers.peer]]\n\ + name = \"Beta\"\n\ + url = \"https://beta:1984\"\n\ + token_file = \"/run/peers/beta\"\n\ + ", + )?; + let err = Config::load(Some(Path::new("bad-name.toml")), &CliOverrides::default()) + .expect_err("peer name regex"); + let text = err.to_string(); + assert!( + text.contains("must match") || text.contains("Beta"), + "{text}" + ); + + jail.create_file( + "timeout.toml", + "[peers]\ntcp_interval_secs = 10\ntcp_timeout_secs = 10\n", + )?; + let err = Config::load(Some(Path::new("timeout.toml")), &CliOverrides::default()) + .expect_err("timeout below interval"); + assert!(err.to_string().contains("tcp_timeout_secs"), "{err}"); + + jail.create_file( + "userinfo.toml", + "\ + [peers]\n\ + [[peers.peer]]\n\ + name = \"beta\"\n\ + url = \"http://user:s3cret@127.0.0.1:1984\"\n\ + token_file = \"/run/peers/beta\"\n\ + ", + )?; + let err = Config::load(Some(Path::new("userinfo.toml")), &CliOverrides::default()) + .expect_err("userinfo"); + let text = err.to_string(); + assert!(text.contains("userinfo"), "{text}"); + assert!(!text.contains("s3cret"), "{text}"); + + let missing = jail.directory().join("not-there"); + jail.create_file( + "missing.toml", + &format!( + "\ + [peers]\n\ + enabled = true\n\ + [[peers.peer]]\n\ + name = \"beta\"\n\ + url = \"https://beta:1984\"\n\ + token_file = \"{}\"\n\ + ", + missing.display() + ), + )?; + let err = Config::load(Some(Path::new("missing.toml")), &CliOverrides::default()) + .expect_err("missing token file"); + let text = err.to_string(); + assert!(text.contains("peer beta"), "{text}"); + assert!(text.contains("not readable"), "{text}"); + + let placeholder = jail.directory().join("placeholder"); + write_private_token(&placeholder, "pending\n"); + jail.create_file( + "ok.toml", + &format!( + "\ + [peers]\n\ + enabled = true\n\ + tcp_interval_secs = 2\n\ + tcp_timeout_secs = 1\n\ + api_interval_secs = 3\n\ + api_timeout_secs = 2\n\ + [[peers.peer]]\n\ + name = \"beta\"\n\ + url = \"http://127.0.0.1:1984\"\n\ + token_file = \"{}\"\n\ + ", + placeholder.display() + ), + )?; + let cfg = Config::load(Some(Path::new("ok.toml")), &CliOverrides::default()) + .expect("placeholder token file must load"); + assert_eq!(cfg.peers.peer[0].name.as_str(), "beta"); + assert!(!format!("{cfg:?}").contains("pending")); + Ok(()) + }); +} + #[tokio::test] async fn ping_without_a_token_is_unauthorized() { let pool = sqlx::sqlite::SqlitePoolOptions::new()