A: A3 secrets loader reads token files with redaction and permission checks

This commit is contained in:
ari committed 2026-10-19 22:31:29 -04:00
1 parent bcac6c76e6
commit 7d10153677
4 files changed
+390 -18

No files matched your search

+35 -18
View File
@@ -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
}
}
+2
View File
@@ -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};
+287
View File
@@ -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<Secret, PeerError> {
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<Secret, PeerError> {
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<u8>) {
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<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());
}
}
#[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));
}
}
+66
View File
@@ -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()