A: A2 validate peer names, URLs, token files and timeouts

This commit is contained in:
ari committed 2026-10-19 22:31:29 -04:00
1 parent 40d18c2253
commit bcac6c76e6
5 files changed
+582 -8

No files matched your search

+1
View File
@@ -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"] }
+1
View File
@@ -314,6 +314,7 @@ impl Config {
"otel.metrics_interval_secs must be greater than zero".into(),
));
}
crate::peers::config::validate(&self.peers)?;
Ok(())
}
+461
View File
@@ -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<Vec<IpNet>, ConfigError> {
cidrs
.iter()
.map(|cidr| {
cidr.parse::<IpNet>().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<IpAddr> {
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<PeerConfig>) -> 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<Mutex<Vec<String>>>);
impl<S: tracing::Subscriber> tracing_subscriber::Layer<S> 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);
}
}
}
+1
View File
@@ -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;
+118 -8
View File
@@ -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()