A: A3 secrets loader reads token files with redaction and permission checks
This commit is contained in:
1 parent
bcac6c76e6
commit
7d10153677
4 files changed
+390
-18
No files matched your search
+35
-18
@@ -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
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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};
|
||||
@@ -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));
|
||||
}
|
||||
}
|
||||
@@ -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()
|
||||
|
||||
Reference in new issue
Block a user