A: cover a directory and a symlink escaping the credentials directory in the loader

This commit is contained in:
ari committed 2026-10-19 22:31:29 -04:00
1 parent a02e4f181b
commit de7a47d040
1 file changed
+41 -50
+41 -50
View File
@@ -96,11 +96,10 @@ fn trim_one_newline(buf: &mut Vec<u8>) {
#[cfg(test)]
mod tests {
use std::os::unix::fs::PermissionsExt;
use std::path::{Path, PathBuf};
use super::*;
use crate::peers::testing::capture::logged;
use crate::peers::testing::{capture::logged, TempDir};
use crate::peers::types::PeerName;
const SECRET: &str = "slinuxm_PEER_TOKEN_SHOULD_NOT_LEAK";
@@ -116,43 +115,6 @@ mod tests {
}
}
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,
@@ -162,7 +124,7 @@ mod tests {
#[test]
fn trims_one_newline_and_rereads_a_replaced_file() {
let dir = TempDir::new();
let dir = TempDir::new("peer-secret");
let path = dir.write("token", b"pending\n", 0o600);
let loaded = load_token_at(&peer(path.clone()), None).unwrap();
assert_eq!(loaded.expose(), "pending");
@@ -180,7 +142,7 @@ mod tests {
#[test]
fn rejects_empty_oversize_and_non_utf8_without_echoing_bytes() {
let dir = TempDir::new();
let dir = TempDir::new("peer-secret");
let empty = dir.write("empty", b"", 0o600);
assert_eq!(
token_err(load_token_at(&peer(empty), None).unwrap_err()),
@@ -211,7 +173,7 @@ mod tests {
#[test]
fn group_readable_files_are_rejected_unless_under_the_credentials_dir() {
let dir = TempDir::new();
let dir = TempDir::new("peer-secret");
let creds = dir.path().join("creds");
let evil = dir.path().join("creds-evil");
std::fs::create_dir_all(&creds).unwrap();
@@ -240,16 +202,45 @@ mod tests {
assert!(!logs.contains("SHOULD_NOT_LEAK"), "{logs}");
}
#[test]
fn a_symlink_cannot_borrow_the_credentials_directory_exemption() {
let dir = TempDir::new("peer-secret");
let creds = dir.path().join("creds");
std::fs::create_dir_all(&creds).unwrap();
let outside = dir.write("outside/token", format!("{SECRET}\n").as_bytes(), 0o644);
let link = creds.join("peer-beta");
std::os::unix::fs::symlink(&outside, &link).unwrap();
// The link lives under the credential directory, its target does not:
// the target's mode decides, so the loose file is refused.
let err = token_err(load_token_at(&peer(link), Some(&creds)).unwrap_err());
assert!(err.contains("group or world readable"), "{err}");
// A private target behind the same link is fine.
std::fs::set_permissions(
&outside,
std::os::unix::fs::PermissionsExt::from_mode(0o600),
)
.unwrap();
let loaded = load_token_at(&peer(creds.join("peer-beta")), Some(&creds)).unwrap();
assert_eq!(loaded.expose(), SECRET);
}
#[test]
fn a_directory_is_not_a_token_file() {
let dir = TempDir::new("peer-secret");
let nested = dir.path().join("as-a-dir");
std::fs::create_dir_all(&nested).unwrap();
assert_eq!(
token_err(load_token_at(&peer(nested), None).unwrap_err()),
"not a file"
);
}
#[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 dir = TempDir::new("peer-secret");
let missing = dir.path().join("not-there");
let err = token_err(load_token_at(&peer(missing), Some(Path::new(""))).unwrap_err());
assert!(err.contains("not readable"), "{err}");
assert!(!err.contains(SECRET));