- add request-scoped capability_request/capability_reply/capability_error frames to the worker transport (ADR-0018); no C ABI change - worker routes its capability handler through stdin/stdout, the host serves requests inside the existing invoke deadline and binds identity from the spawned worker, never from frame text - both native and worker plugins now execute a granted fs.read through ProjectFs with audit; unsupported capabilities return capability.unavailable - add a real C capability plugin and CLI test for granted read and denial - document the bridge and that strict OS isolation (H3-B) is still refused
250 lines
6.4 KiB
Rust
250 lines
6.4 KiB
Rust
//! Isolated plugin worker transport (ADR-0010).
|
|
#![cfg(unix)]
|
|
|
|
use std::path::{Path, PathBuf};
|
|
use std::process::{Command, Output};
|
|
use std::sync::atomic::{AtomicU32, Ordering};
|
|
|
|
use marqdo_plugin_abi::{sha256_file, HostTarget};
|
|
|
|
static COUNTER: AtomicU32 = AtomicU32::new(0);
|
|
|
|
struct TempDir(PathBuf);
|
|
|
|
impl TempDir {
|
|
fn new(tag: &str) -> Self {
|
|
let id = COUNTER.fetch_add(1, Ordering::Relaxed);
|
|
let path = std::env::temp_dir().join(format!(
|
|
"marqdo-worker-test-{}-{id}-{tag}",
|
|
std::process::id()
|
|
));
|
|
std::fs::create_dir_all(&path).unwrap();
|
|
Self(path)
|
|
}
|
|
|
|
fn path(&self) -> &Path {
|
|
&self.0
|
|
}
|
|
}
|
|
|
|
impl Drop for TempDir {
|
|
fn drop(&mut self) {
|
|
let _ = std::fs::remove_dir_all(&self.0);
|
|
}
|
|
}
|
|
|
|
fn repo() -> PathBuf {
|
|
Path::new(env!("CARGO_MANIFEST_DIR"))
|
|
.parent()
|
|
.unwrap()
|
|
.parent()
|
|
.unwrap()
|
|
.to_path_buf()
|
|
}
|
|
|
|
fn have_cc() -> bool {
|
|
Command::new("cc")
|
|
.arg("--version")
|
|
.output()
|
|
.map(|output| output.status.success())
|
|
.unwrap_or(false)
|
|
}
|
|
|
|
fn compile(dir: &Path, extra: &[&str]) -> PathBuf {
|
|
let output = dir.join("solver.so");
|
|
let status = Command::new("cc")
|
|
.args(["-std=c11", "-O2", "-shared", "-fPIC"])
|
|
.arg("-I")
|
|
.arg(repo().join("include"))
|
|
.args(extra)
|
|
.arg(repo().join("examples/plugin-demo/solver.c"))
|
|
.arg("-o")
|
|
.arg(&output)
|
|
.status()
|
|
.expect("cc");
|
|
assert!(status.success(), "cc failed");
|
|
output
|
|
}
|
|
|
|
fn write_manifest(dir: &Path, sha: &str) {
|
|
std::fs::write(
|
|
dir.join("plugin.yaml"),
|
|
format!(
|
|
r#"plugin:
|
|
name: demo.solver
|
|
version: 0.1.0
|
|
abi: "^1.0"
|
|
kind: worker
|
|
exports:
|
|
- name: solver.add
|
|
signature: "($a: Int, $b: Int) -> Int"
|
|
requires:
|
|
- math.compute
|
|
artifacts:
|
|
- target: {}
|
|
file: solver.so
|
|
sha256: "{}"
|
|
"#,
|
|
HostTarget::current().triple(),
|
|
sha
|
|
),
|
|
)
|
|
.unwrap();
|
|
std::fs::write(
|
|
dir.join("doc.mq.md"),
|
|
"## main\n\n**结果 = solver.add(a=20, b=22)**\n\n> 打印(结果)\n",
|
|
)
|
|
.unwrap();
|
|
}
|
|
|
|
fn run(dir: &Path) -> Output {
|
|
Command::new(env!("CARGO_BIN_EXE_marqdo"))
|
|
.args([
|
|
"run",
|
|
dir.join("doc.mq.md").to_str().unwrap(),
|
|
"--plugin",
|
|
dir.to_str().unwrap(),
|
|
"--allow-plugin",
|
|
"demo.solver",
|
|
])
|
|
.output()
|
|
.unwrap()
|
|
}
|
|
|
|
#[test]
|
|
fn worker_transport_runs_without_in_process_trust() {
|
|
if !have_cc() {
|
|
eprintln!("skipping: cc is unavailable");
|
|
return;
|
|
}
|
|
let dir = TempDir::new("ok");
|
|
let artifact = compile(dir.path(), &[]);
|
|
write_manifest(dir.path(), &sha256_file(&artifact).unwrap());
|
|
let output = run(dir.path());
|
|
assert_eq!(
|
|
output.status.code(),
|
|
Some(0),
|
|
"{}",
|
|
String::from_utf8_lossy(&output.stderr)
|
|
);
|
|
assert_eq!(String::from_utf8_lossy(&output.stdout), "42\n");
|
|
}
|
|
|
|
#[test]
|
|
fn worker_crash_is_isolated_from_the_host() {
|
|
if !have_cc() {
|
|
eprintln!("skipping: cc is unavailable");
|
|
return;
|
|
}
|
|
let dir = TempDir::new("crash");
|
|
let artifact = compile(dir.path(), &["-DMQ_SOLVER_CRASH"]);
|
|
write_manifest(dir.path(), &sha256_file(&artifact).unwrap());
|
|
let output = run(dir.path());
|
|
assert_eq!(output.status.code(), Some(1));
|
|
let stderr = String::from_utf8_lossy(&output.stderr);
|
|
assert!(
|
|
stderr.contains("plugin.crashed") || stderr.contains("plugin.failure"),
|
|
"{stderr}"
|
|
);
|
|
// The host process survived and still runs a native Marqdo program.
|
|
let survivor = Command::new(env!("CARGO_BIN_EXE_marqdo"))
|
|
.args(["run", "examples/hello.mq.md"])
|
|
.current_dir(repo())
|
|
.output()
|
|
.unwrap();
|
|
assert_eq!(survivor.status.code(), Some(0));
|
|
}
|
|
|
|
fn compile_capability(dir: &Path) -> PathBuf {
|
|
let output = dir.join("capability.so");
|
|
let status = Command::new("cc")
|
|
.args(["-std=c11", "-O2", "-shared", "-fPIC"])
|
|
.arg("-I")
|
|
.arg(repo().join("include"))
|
|
.arg(repo().join("tests/abi/capability_plugin.c"))
|
|
.arg("-o")
|
|
.arg(&output)
|
|
.status()
|
|
.expect("cc");
|
|
assert!(status.success(), "cc failed");
|
|
output
|
|
}
|
|
|
|
fn write_capability_manifest(dir: &Path, sha: &str) {
|
|
std::fs::write(
|
|
dir.join("plugin.yaml"),
|
|
format!(
|
|
r#"plugin:
|
|
name: demo.capability
|
|
version: 0.1.0
|
|
abi: "^1.0"
|
|
kind: worker
|
|
exports:
|
|
- name: capability.read
|
|
signature: "() -> Text"
|
|
requires:
|
|
- fs.read
|
|
artifacts:
|
|
- target: {}
|
|
file: capability.so
|
|
sha256: "{}"
|
|
"#,
|
|
HostTarget::current().triple(),
|
|
sha
|
|
),
|
|
)
|
|
.unwrap();
|
|
std::fs::write(
|
|
dir.join("doc.mq.md"),
|
|
"## main\n\n**结果 = capability.read()**\n\n> 打印(结果)\n",
|
|
)
|
|
.unwrap();
|
|
std::fs::create_dir_all(dir.join("data")).unwrap();
|
|
std::fs::write(dir.join("data/allowed.txt"), "hello-worker").unwrap();
|
|
}
|
|
|
|
fn run_capability(dir: &Path, allow_read: bool) -> Output {
|
|
let mut command = Command::new(env!("CARGO_BIN_EXE_marqdo"));
|
|
command.args([
|
|
"run",
|
|
dir.join("doc.mq.md").to_str().unwrap(),
|
|
"--plugin",
|
|
dir.to_str().unwrap(),
|
|
"--allow-plugin",
|
|
"demo.capability",
|
|
]);
|
|
if allow_read {
|
|
command.args(["--allow-read", "data/**"]);
|
|
}
|
|
command.output().unwrap()
|
|
}
|
|
|
|
#[test]
|
|
fn worker_capability_bridge_reads_granted_file_and_denies_without_grant() {
|
|
if !have_cc() {
|
|
eprintln!("skipping: cc is unavailable");
|
|
return;
|
|
}
|
|
let dir = TempDir::new("capability");
|
|
let artifact = compile_capability(dir.path());
|
|
write_capability_manifest(dir.path(), &sha256_file(&artifact).unwrap());
|
|
|
|
let output = run_capability(dir.path(), true);
|
|
assert_eq!(
|
|
output.status.code(),
|
|
Some(0),
|
|
"{}",
|
|
String::from_utf8_lossy(&output.stderr)
|
|
);
|
|
assert_eq!(String::from_utf8_lossy(&output.stdout), "hello-worker\n");
|
|
|
|
let denied = run_capability(dir.path(), false);
|
|
assert_eq!(denied.status.code(), Some(1));
|
|
let stderr = String::from_utf8_lossy(&denied.stderr);
|
|
assert!(
|
|
stderr.contains("permission.denied") || stderr.contains("fs.read"),
|
|
"{stderr}"
|
|
);
|
|
assert!(!String::from_utf8_lossy(&denied.stdout).contains("hello-worker"));
|
|
}
|