use std::ffi::OsStr;
use std::path::{Component, Path, PathBuf};
fn normalize_lexical(path: &Path) -> PathBuf {
let mut out = PathBuf::new();
for comp in path.components() {
match comp {
Component::CurDir => {}
Component::ParentDir => {
let _ = out.pop();
}
other => out.push(other.as_os_str()),
}
}
out
}
fn glob_static_prefix(pattern: &str) -> &str {
let meta_idx = pattern.find(['*', '?', '[']).unwrap_or(pattern.len());
let prefix = &pattern[..meta_idx];
match prefix.rfind('/') {
Some(i) if i > 0 => &pattern[..i],
Some(_) => "/", None => ".",
}
}
#[derive(Debug, Clone)]
pub struct Sandbox {
root: PathBuf,
}
impl Sandbox {
pub fn new(root: impl AsRef<Path>) -> Result<Self, String> {
let root = root.as_ref();
let canonical = root.canonicalize().map_err(|e| {
format!(
"Failed to canonicalize sandbox root '{}': {}",
root.display(),
e
)
})?;
if !canonical.is_dir() {
return Err(format!(
"Sandbox root '{}' is not a directory",
root.display()
));
}
Ok(Self { root: canonical })
}
pub fn root(&self) -> &Path {
&self.root
}
pub fn resolve_contained(&self, raw: &str) -> Result<PathBuf, String> {
if raw.trim().is_empty() {
return Err(self.violation_message(raw));
}
let candidate = Path::new(raw);
let joined = if candidate.is_absolute() {
candidate.to_path_buf()
} else {
self.root.join(candidate)
};
let normalized = normalize_lexical(&joined);
if !normalized.starts_with(&self.root) {
return Err(self.violation_message(raw));
}
let mut ancestor = normalized.as_path();
let mut tail: Vec<&OsStr> = Vec::new();
while !ancestor.exists() {
match (ancestor.file_name(), ancestor.parent()) {
(Some(name), Some(parent)) if parent != ancestor => {
tail.push(name);
ancestor = parent;
}
_ => break,
}
}
let canonical_ancestor = ancestor
.canonicalize()
.map_err(|_| self.violation_message(raw))?;
let mut resolved = canonical_ancestor;
for name in tail.iter().rev() {
resolved.push(name);
}
if !resolved.starts_with(&self.root) {
return Err(self.violation_message(raw));
}
Ok(resolved)
}
pub fn contains(&self, raw: &str) -> bool {
self.resolve_contained(raw).is_ok()
}
pub fn check_glob_pattern(&self, pattern: &str) -> Result<(), String> {
let base = glob_static_prefix(pattern);
self.resolve_contained(base).map(|_| ())
}
pub fn violation_message(&self, raw: &str) -> String {
format!(
"Error: Sandbox violation: path '{}' is outside the sandbox root '{}'. \
Access is restricted to the workspace directory.",
raw,
self.root.display()
)
}
}
#[cfg(all(test, target_os = "linux"))]
mod tests {
use super::*;
#[test]
fn normalize_lexical_resolves_dotdot() {
let p = normalize_lexical(Path::new("/a/b/../c/./d"));
assert_eq!(p, PathBuf::from("/a/c/d"));
}
#[test]
fn normalize_lexical_clamps_at_root() {
let p = normalize_lexical(Path::new("/a/../../etc/passwd"));
assert_eq!(p, PathBuf::from("/etc/passwd"));
}
#[test]
fn new_requires_existing_dir() {
assert!(Sandbox::new("/definitely/not/a/real/dir").is_err());
}
#[test]
fn contains_absolute_inside() {
let tmp = tempfile::tempdir().unwrap();
let sb = Sandbox::new(tmp.path()).unwrap();
let inside = sb.root().join("file.txt");
assert!(sb.contains(inside.to_str().unwrap()));
}
#[test]
fn contains_absolute_outside() {
let tmp = tempfile::tempdir().unwrap();
let sb = Sandbox::new(tmp.path()).unwrap();
assert!(!sb.contains("/etc/passwd"));
let other = tempfile::tempdir().unwrap();
assert!(!sb.contains(other.path().join("x.txt").to_str().unwrap()));
}
#[test]
fn contains_relative_paths() {
let tmp = tempfile::tempdir().unwrap();
let sb = Sandbox::new(tmp.path()).unwrap();
assert!(sb.contains("file.txt"));
assert!(sb.contains("./sub/dir/file.txt"));
assert!(sb.contains("sub/../other.txt"));
}
#[test]
fn rejects_dotdot_traversal() {
let tmp = tempfile::tempdir().unwrap();
let sb = Sandbox::new(tmp.path()).unwrap();
assert!(!sb.contains("../escape.txt"));
assert!(!sb.contains("sub/../../escape.txt"));
let traversal = format!("{}/../outside.txt", sb.root().display());
assert!(!sb.contains(&traversal));
}
#[test]
fn allows_nonexistent_paths_inside_root() {
let tmp = tempfile::tempdir().unwrap();
let sb = Sandbox::new(tmp.path()).unwrap();
assert!(sb.contains("does/not/exist/yet.txt"));
let resolved = sb.resolve_contained("new/nested/file.rs").unwrap();
assert!(resolved.starts_with(sb.root()));
assert!(resolved.ends_with("new/nested/file.rs"));
}
#[test]
fn rejects_nonexistent_paths_outside_root() {
let tmp = tempfile::tempdir().unwrap();
let sb = Sandbox::new(tmp.path()).unwrap();
assert!(!sb.contains("/tmp/sandbox-evil-dir-xyz/new.txt"));
}
#[test]
fn rejects_symlink_escape() {
#[cfg(unix)]
{
let tmp = tempfile::tempdir().unwrap();
let outside = tempfile::tempdir().unwrap();
let sb = Sandbox::new(tmp.path()).unwrap();
let link = tmp.path().join("evil_link");
std::os::unix::fs::symlink(outside.path(), &link).unwrap();
assert!(!sb.contains("evil_link/secret.txt"));
assert!(!sb.contains(link.to_str().unwrap()));
}
}
#[test]
fn violation_message_mentions_path_and_root() {
let tmp = tempfile::tempdir().unwrap();
let sb = Sandbox::new(tmp.path()).unwrap();
let msg = sb.violation_message("/etc/passwd");
assert!(msg.contains("/etc/passwd"));
assert!(msg.contains(&sb.root().display().to_string()));
assert!(msg.starts_with("Error: Sandbox violation"));
}
#[test]
fn rejects_empty_path() {
let tmp = tempfile::tempdir().unwrap();
let sb = Sandbox::new(tmp.path()).unwrap();
assert!(!sb.contains(""));
assert!(!sb.contains(" "));
}
}