boxlite 0.9.3

Embeddable virtual machine runtime for secure, isolated code execution
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

//! Rooted path resolution for OCI layer extraction.
//!
//! [`SafeRoot`] resolves relative paths within a root directory, re-anchoring
//! absolute symlink targets (like a chroot). Callers use the resolved
//! [`PathBuf`] with standard `std::fs` operations.
//!
//! Matches containerd `fs.RootPath` / umoci `SecureJoinVFS`: resolve once,
//! then use the OS directly. The struct caches the root fd (Linux/pathrs)
//! to avoid reopening per call.

mod path;

#[cfg(target_os = "linux")]
mod linux;
#[cfg(target_os = "linux")]
use linux as imp;

#[cfg(not(target_os = "linux"))]
mod fallback;
#[cfg(not(target_os = "linux"))]
use fallback as imp;

use boxlite_shared::errors::{BoxliteError, BoxliteResult};
use std::fs;
use std::path::{Path, PathBuf};

pub struct SafeRoot {
    root: PathBuf,
    backend: imp::Backend,
}

impl SafeRoot {
    pub fn open(root: &Path) -> BoxliteResult<Self> {
        fs::create_dir_all(root).map_err(|e| {
            BoxliteError::Storage(format!("Failed to create {}: {}", root.display(), e))
        })?;
        Ok(Self {
            root: root.to_path_buf(),
            backend: imp::Backend::open(root)?,
        })
    }

    /// Resolve `rel` within root. ALL symlinks followed (including final)
    /// and absolute targets re-anchored. Matches containerd `fs.RootPath`.
    pub fn resolve(&self, rel: &Path) -> BoxliteResult<PathBuf> {
        let rel = path::normalize_relative(rel).ok_or_else(|| {
            BoxliteError::Storage(format!("Path escapes root: {}", rel.display()))
        })?;
        if rel.as_os_str().is_empty() {
            return Ok(self.root.clone());
        }
        self.backend.resolve(&rel)
    }

    /// Resolve `rel` within root, returning root itself if `rel` is empty.
    pub fn resolve_or_root(&self, rel: &Path) -> BoxliteResult<PathBuf> {
        if rel.as_os_str().is_empty() {
            Ok(self.root.clone())
        } else {
            self.resolve(rel)
        }
    }

    /// Normalize a path for extraction: strip leading `/`, resolve `.`/`..`.
    /// Returns `None` if `..` underflows past root.
    pub fn normalize(path: &Path) -> Option<PathBuf> {
        path::normalize_relative(path)
    }

    pub fn root_path(&self) -> &Path {
        &self.root
    }
}

#[cfg(test)]
mod tests;