From 7d10153677787247c7273a79a23401ebf8df1001 Mon Sep 17 00:00:00 2001 From: ari Date: Mon, 19 Oct 2026 20:18:22 -0400 Subject: [PATCH] A: A3 secrets loader reads token files with redaction and permission checks --- src/peers/config.rs | 53 +++++--- src/peers/mod.rs | 2 + src/peers/secrets.rs | 287 ++++++++++++++++++++++++++++++++++++++++++ tests/peers_config.rs | 66 ++++++++++ 4 files changed, 390 insertions(+), 18 deletions(-) create mode 100644 src/peers/secrets.rs diff --git a/src/peers/config.rs b/src/peers/config.rs index 0741bbe..786424f 100644 --- a/src/peers/config.rs +++ b/src/peers/config.rs @@ -79,30 +79,30 @@ fn validate_peer( 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. + // Only peers this process will call need a usable token. A disabled + // entry can name a credential that is not on disk yet. The value is + // dropped here; later checks read the file again so rotation needs no + // restart and the config never retains it. 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() - ))) - } + if let Err(err) = crate::peers::secrets::load_token(peer) { + return Err(token_file_error(peer, err)); } } Ok(()) } +fn token_file_error(peer: &PeerConfig, err: crate::peers::PeerError) -> ConfigError { + let reason = match err { + crate::peers::PeerError::TokenFile(reason) => reason, + _ => "could not be read".into(), + }; + ConfigError::Invalid(format!( + "peer {}: token_file {}: {reason}", + peer.name, + peer.token_file.display() + )) +} + fn validate_url( section_enabled: bool, peer: &PeerConfig, @@ -414,6 +414,21 @@ mod tests { assert!(err.contains("beta")); } + #[test] + fn enabled_peer_rejects_an_empty_token_file() { + let dir = TempDir::new(); + let mut beta = peer("beta", "http://127.0.0.1:1984"); + beta.token_file = dir.write_token(""); + let cfg = PeersConfig { + enabled: true, + peer: vec![beta], + ..PeersConfig::default() + }; + let err = message(validate(&cfg).unwrap_err()); + assert!(err.contains("peer beta"), "{err}"); + assert!(err.contains("empty"), "{err}"); + } + #[test] fn enabled_with_no_peers_warns_and_is_not_an_error() { let cfg = PeersConfig { @@ -449,6 +464,8 @@ mod tests { fn write_token(&self, contents: &str) -> PathBuf { let path = self.0.join("token"); std::fs::write(&path, contents).unwrap(); + use std::os::unix::fs::PermissionsExt; + std::fs::set_permissions(&path, std::fs::Permissions::from_mode(0o600)).unwrap(); path } } diff --git a/src/peers/mod.rs b/src/peers/mod.rs index d161ca6..1851c6e 100644 --- a/src/peers/mod.rs +++ b/src/peers/mod.rs @@ -9,10 +9,12 @@ pub mod error; pub mod health; pub mod proxy; pub mod registry; +pub mod secrets; pub mod testing; pub mod transport; pub mod types; pub use error::{PeerConfigError, PeerError}; pub use registry::{PeerRegistry, ProxyOpts}; +pub use secrets::load_token; pub use types::{PeerConfig, PeerName, PeerStatus, PeersConfig, Secret}; diff --git a/src/peers/secrets.rs b/src/peers/secrets.rs new file mode 100644 index 0000000..282c8de --- /dev/null +++ b/src/peers/secrets.rs @@ -0,0 +1,287 @@ +//! Peer bearer tokens live in files this process does not own. +//! +//! Each read returns a new [`Secret`]. Callers that check a peer again must +//! call [`load_token`] again: a replaced file is picked up without a restart, +//! and nothing here keeps the bytes. + +use std::io::Read; +use std::path::Path; + +use crate::peers::error::PeerError; +use crate::peers::types::{PeerConfig, Secret}; + +/// Bearer tokens are short. A larger file is refused before the rest is read. +pub const MAX_TOKEN_BYTES: usize = 4 * 1024; + +/// Read `peer.token_file`, trimming one trailing newline. +/// +/// Group- and world-readable files are rejected unless the path is inside +/// `$CREDENTIALS_DIRECTORY` (systemd's credential dir is not mode 0600; the +/// directory itself is the protection). +pub fn load_token(peer: &PeerConfig) -> Result { + let dir = std::env::var_os("CREDENTIALS_DIRECTORY").map(std::path::PathBuf::from); + load_token_at(peer, dir.as_deref()) +} + +/// Same as [`load_token`] with an explicit credentials directory. +/// +/// `None` and an empty path both apply the permission check. Tests pass the +/// directory directly so they do not touch the process environment. +pub fn load_token_at( + peer: &PeerConfig, + credentials_dir: Option<&Path>, +) -> Result { + let path = &peer.token_file; + let file = std::fs::File::open(path) + .map_err(|err| PeerError::TokenFile(format!("not readable: {err}")))?; + let meta = file + .metadata() + .map_err(|err| PeerError::TokenFile(format!("not readable: {err}")))?; + if !meta.is_file() { + return Err(PeerError::TokenFile("not a file".into())); + } + if !under_credentials(path, credentials_dir) { + reject_group_or_world_readable(&meta)?; + } + if meta.len() > MAX_TOKEN_BYTES as u64 { + return Err(oversize()); + } + let mut buf = Vec::new(); + file.take(MAX_TOKEN_BYTES as u64 + 1) + .read_to_end(&mut buf) + .map_err(|err| PeerError::TokenFile(format!("not readable: {err}")))?; + if buf.len() > MAX_TOKEN_BYTES { + return Err(oversize()); + } + trim_one_newline(&mut buf); + if buf.is_empty() { + return Err(PeerError::TokenFile("empty".into())); + } + let text = String::from_utf8(buf).map_err(|_| PeerError::TokenFile("not utf-8".into()))?; + Ok(Secret::new(text)) +} + +fn oversize() -> PeerError { + PeerError::TokenFile(format!("larger than {MAX_TOKEN_BYTES} bytes")) +} + +fn reject_group_or_world_readable(meta: &std::fs::Metadata) -> Result<(), PeerError> { + use std::os::unix::fs::PermissionsExt; + // Other users who can read the file can call the peer as this consolidator. + if meta.permissions().mode() & 0o044 != 0 { + return Err(PeerError::TokenFile("group or world readable".into())); + } + Ok(()) +} + +/// Fail closed: if either path cannot be canonicalized, the mode check stays. +fn under_credentials(path: &Path, credentials_dir: Option<&Path>) -> bool { + let Some(dir) = credentials_dir.filter(|dir| !dir.as_os_str().is_empty()) else { + return false; + }; + let (Ok(path), Ok(dir)) = (std::fs::canonicalize(path), std::fs::canonicalize(dir)) else { + return false; + }; + path.starts_with(dir) +} + +fn trim_one_newline(buf: &mut Vec) { + if buf.last() == Some(&b'\n') { + buf.pop(); + if buf.last() == Some(&b'\r') { + buf.pop(); + } + } +} + +#[cfg(test)] +mod tests { + use std::os::unix::fs::PermissionsExt; + use std::path::{Path, PathBuf}; + use std::sync::{Arc, Mutex}; + + use super::*; + use crate::peers::types::PeerName; + use tracing_subscriber::layer::SubscriberExt; + + const SECRET: &str = "slinuxm_PEER_TOKEN_SHOULD_NOT_LEAK"; + + fn peer(path: PathBuf) -> PeerConfig { + PeerConfig { + name: PeerName::parse("beta").unwrap(), + url: url::Url::parse("http://127.0.0.1:1984").unwrap(), + token_file: path, + ca_file: None, + allow_plain_http: false, + enabled: true, + } + } + + 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-secret-{}-{nanos}", + std::process::id() + )); + std::fs::create_dir(&path).unwrap(); + Self(path) + } + + fn path(&self) -> &Path { + &self.0 + } + + fn write(&self, name: &str, contents: &[u8], mode: u32) -> PathBuf { + let path = self.0.join(name); + if let Some(parent) = path.parent() { + std::fs::create_dir_all(parent).unwrap(); + } + std::fs::write(&path, contents).unwrap(); + std::fs::set_permissions(&path, std::fs::Permissions::from_mode(mode)).unwrap(); + path + } + } + + impl Drop for TempDir { + fn drop(&mut self) { + let _ = std::fs::remove_dir_all(&self.0); + } + } + + fn token_err(err: PeerError) -> String { + match err { + PeerError::TokenFile(reason) => reason, + other => panic!("expected TokenFile, 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()); + } + } + + #[test] + fn trims_one_newline_and_rereads_a_replaced_file() { + let dir = TempDir::new(); + let path = dir.write("token", b"pending\n", 0o600); + let loaded = load_token_at(&peer(path.clone()), None).unwrap(); + assert_eq!(loaded.expose(), "pending"); + assert!(!format!("{loaded:?}").contains("pending")); + assert!(!format!("{loaded}").contains("pending")); + + std::fs::write(&path, b"pending\n\n").unwrap(); + assert_eq!( + load_token_at(&peer(path.clone()), None).unwrap().expose(), + "pending\n" + ); + std::fs::write(&path, b"next\r\n").unwrap(); + assert_eq!(load_token(&peer(path)).unwrap().expose(), "next"); + } + + #[test] + fn rejects_empty_oversize_and_non_utf8_without_echoing_bytes() { + let dir = TempDir::new(); + let empty = dir.write("empty", b"", 0o600); + assert_eq!( + token_err(load_token_at(&peer(empty), None).unwrap_err()), + "empty" + ); + let newline = dir.write("nl", b"\n", 0o600); + assert_eq!( + token_err(load_token_at(&peer(newline), None).unwrap_err()), + "empty" + ); + + let exact = dir.write("exact", &vec![b'a'; MAX_TOKEN_BYTES], 0o600); + let loaded = load_token_at(&peer(exact), None).unwrap(); + assert_eq!(loaded.expose().len(), MAX_TOKEN_BYTES); + assert!(!format!("{loaded:?}").contains("aaa")); + + let big = dir.write("big", &vec![b'Z'; MAX_TOKEN_BYTES + 1], 0o600); + let err = load_token_at(&peer(big), None).unwrap_err(); + let text = format!("{err:?}"); + assert!(text.contains("larger than")); + assert!(!text.contains(&"Z".repeat(20))); + + let binary = dir.write("bin", &[0xff, 0xfe], 0o600); + let err = token_err(load_token_at(&peer(binary), None).unwrap_err()); + assert_eq!(err, "not utf-8"); + assert!(!err.contains('\u{ff}')); + } + + #[test] + fn group_readable_files_are_rejected_unless_under_the_credentials_dir() { + let dir = TempDir::new(); + let creds = dir.path().join("creds"); + let evil = dir.path().join("creds-evil"); + std::fs::create_dir_all(&creds).unwrap(); + std::fs::create_dir_all(&evil).unwrap(); + let inside = dir.write("creds/token", format!("{SECRET}\n").as_bytes(), 0o644); + let outside = dir.write("creds-evil/token", format!("{SECRET}\n").as_bytes(), 0o640); + + let err = token_err(load_token_at(&peer(outside.clone()), Some(&creds)).unwrap_err()); + assert!(err.contains("group or world readable"), "{err}"); + assert!(!err.contains("SHOULD_NOT_LEAK"), "{err}"); + + let loaded = load_token_at(&peer(inside), Some(creds.as_path())).unwrap(); + assert_eq!(loaded.expose(), SECRET); + assert!(!format!("{loaded:?}").contains("SHOULD_NOT_LEAK")); + + let private = dir.write("private", format!("{SECRET}\n").as_bytes(), 0o600); + assert_eq!( + load_token_at(&peer(private), None).unwrap().expose(), + SECRET + ); + + let logs = { + let buf = Arc::new(Mutex::new(Vec::new())); + let sub = tracing_subscriber::registry().with(Capture(buf.clone())); + let private = dir.write("logged", format!("{SECRET}\n").as_bytes(), 0o600); + tracing::subscriber::with_default(sub, || { + load_token_at(&peer(private), None).unwrap(); + }); + let text = buf.lock().expect("log lock").join("\n"); + text + }; + assert!(!logs.contains("SHOULD_NOT_LEAK"), "{logs}"); + } + + #[test] + fn missing_file_names_no_secret() { + let missing = std::env::temp_dir().join(format!( + "slinuxm-missing-token-{}-{}", + std::process::id(), + std::time::SystemTime::now() + .duration_since(std::time::UNIX_EPOCH) + .unwrap() + .subsec_nanos() + )); + let err = token_err(load_token_at(&peer(missing), Some(Path::new(""))).unwrap_err()); + assert!(err.contains("not readable"), "{err}"); + assert!(!err.contains(SECRET)); + } +} diff --git a/tests/peers_config.rs b/tests/peers_config.rs index e841803..7539faf 100644 --- a/tests/peers_config.rs +++ b/tests/peers_config.rs @@ -342,6 +342,72 @@ fn load_rejects_invalid_peers_and_accepts_a_placeholder_token() { }); } +#[test] +#[allow(clippy::result_large_err)] // figment::Jail closures return figment::Error +fn config_load_uses_the_token_loader_and_rereads_a_rotated_file() { + Jail::expect_with(|jail| { + let creds = jail.directory().join("credentials"); + jail.create_dir("credentials")?; + jail.set_env("CREDENTIALS_DIRECTORY", creds.display()); + let token = creds.join("peer-beta"); + std::fs::write(&token, "pending\n").unwrap(); + std::fs::set_permissions(&token, std::fs::Permissions::from_mode(0o644)).unwrap(); + jail.create_file( + "creds.toml", + &format!( + "\ + [peers]\n\ + enabled = true\n\ + [[peers.peer]]\n\ + name = \"beta\"\n\ + url = \"http://127.0.0.1:1984\"\n\ + token_file = \"{}\"\n\ + ", + token.display() + ), + )?; + // systemd's credential directory protects the file, not its mode. + let cfg = Config::load(Some(Path::new("creds.toml")), &CliOverrides::default()) + .expect("credential-directory token must load"); + assert_eq!(cfg.peers.peer[0].name.as_str(), "beta"); + + let outside = jail.directory().join("outside"); + jail.create_dir("outside")?; + let loose = outside.join("peer-beta"); + std::fs::write(&loose, "pending\n").unwrap(); + std::fs::set_permissions(&loose, std::fs::Permissions::from_mode(0o644)).unwrap(); + jail.create_file( + "loose.toml", + &format!( + "\ + [peers]\n\ + enabled = true\n\ + [[peers.peer]]\n\ + name = \"beta\"\n\ + url = \"http://127.0.0.1:1984\"\n\ + token_file = \"{}\"\n\ + ", + loose.display() + ), + )?; + let err = Config::load(Some(Path::new("loose.toml")), &CliOverrides::default()) + .expect_err("group/world readable token outside the credential dir"); + let text = err.to_string(); + assert!(text.contains("peer beta"), "{text}"); + assert!(text.contains("group or world readable"), "{text}"); + assert!(!text.contains("pending"), "{text}"); + + // The loader keeps no copy: a replacement file is read on the next call. + std::fs::write(&token, "rotated\n").unwrap(); + let cfg = Config::load(Some(Path::new("creds.toml")), &CliOverrides::default()) + .expect("rotated token must load"); + let secret = skyg_linux_tracker::peers::load_token(&cfg.peers.peer[0]).unwrap(); + assert_eq!(secret.expose(), "rotated"); + assert!(!format!("{secret:?}").contains("rotated")); + Ok(()) + }); +} + #[tokio::test] async fn ping_without_a_token_is_unauthorized() { let pool = sqlx::sqlite::SqlitePoolOptions::new()