mirror of
https://github.com/andrewyng/openworker.git
synced 2026-11-20 20:37:44 +00:00
559 lines
20 KiB
Rust
559 lines
20 KiB
Rust
//! Unsandboxed Linux MCP execution with a separate, narrowly owned subreaper.
|
|
//! Lifecycle guarantees are not a security boundary against hostile host code.
|
|
use anyhow::{bail, Context, Result};
|
|
use serde::{Deserialize, Serialize};
|
|
use serde_json::{json, Value};
|
|
use std::{path::Path, time::Duration};
|
|
use tokio::io::{AsyncBufReadExt, AsyncReadExt, AsyncWriteExt, BufReader};
|
|
|
|
#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq)]
|
|
pub struct Identity {
|
|
pub pid: u32,
|
|
pub boot_id: String,
|
|
pub start_ticks: u64,
|
|
pub token: String,
|
|
}
|
|
|
|
#[cfg(target_os = "macos")]
|
|
#[path = "direct_macos.rs"]
|
|
mod macos;
|
|
#[cfg(windows)]
|
|
#[path = "direct_windows.rs"]
|
|
mod windows;
|
|
|
|
#[cfg(target_os = "linux")]
|
|
mod linux {
|
|
use super::*;
|
|
use std::os::fd::{AsRawFd, FromRawFd, OwnedFd};
|
|
pub fn pidfd(pid: u32) -> Result<OwnedFd> {
|
|
if pid == 0 || pid > i32::MAX as u32 {
|
|
bail!("Invalid process identity");
|
|
}
|
|
let fd = unsafe { libc::syscall(libc::SYS_pidfd_open, pid as libc::pid_t, 0u32) };
|
|
if fd < 0 {
|
|
return Err(std::io::Error::last_os_error().into());
|
|
}
|
|
Ok(unsafe { OwnedFd::from_raw_fd(fd as i32) })
|
|
}
|
|
pub fn identity(pid: u32, token: &str) -> Result<Identity> {
|
|
let stat = std::fs::read_to_string(format!("/proc/{pid}/stat"))?;
|
|
let fields = stat.rsplit_once(')').context("Invalid process stat")?.1;
|
|
let start_ticks = fields
|
|
.split_whitespace()
|
|
.nth(19)
|
|
.context("Missing process start time")?
|
|
.parse()?;
|
|
Ok(Identity {
|
|
pid,
|
|
boot_id: std::fs::read_to_string("/proc/sys/kernel/random/boot_id")?
|
|
.trim()
|
|
.into(),
|
|
start_ticks,
|
|
token: token.into(),
|
|
})
|
|
}
|
|
fn exited(fd: &OwnedFd) -> Result<bool> {
|
|
let mut p = libc::pollfd {
|
|
fd: fd.as_raw_fd(),
|
|
events: libc::POLLIN,
|
|
revents: 0,
|
|
};
|
|
loop {
|
|
if unsafe { libc::poll(&mut p, 1, 0) } >= 0 {
|
|
break;
|
|
}
|
|
let error = std::io::Error::last_os_error();
|
|
if error.kind() != std::io::ErrorKind::Interrupted {
|
|
return Err(error.into());
|
|
}
|
|
}
|
|
Ok(p.revents & (libc::POLLIN | libc::POLLHUP) != 0)
|
|
}
|
|
// Linux clears an exiting process's cmdline. It may exit after the earlier
|
|
// liveness/identity reads, so recheck the SAME pidfd before calling this an
|
|
// ownership failure. A live mismatch must still never receive a signal.
|
|
async fn token_owner(
|
|
cmdline: &[u8],
|
|
token: &str,
|
|
mut exited: impl FnMut() -> Result<bool>,
|
|
) -> Result<bool> {
|
|
if cmdline.split(|b| *b == 0).any(|s| s == token.as_bytes()) {
|
|
return Ok(true);
|
|
}
|
|
if exited()? {
|
|
return Ok(false);
|
|
}
|
|
// Command-line inspection can race with exit even when it returns
|
|
// nonempty bytes. pidfd readiness follows thread-group exit. Never
|
|
// signal a mismatch: accept only confirmed exit of this same pidfd.
|
|
tokio::time::timeout(Duration::from_secs(1), async {
|
|
while !exited()? {
|
|
tokio::time::sleep(Duration::from_millis(5)).await;
|
|
}
|
|
Ok(false)
|
|
})
|
|
.await
|
|
.context("Supervisor ownership token mismatch and exit unconfirmed; refusing signal")?
|
|
}
|
|
pub async fn cleanup(expected: &Identity) -> Result<()> {
|
|
if expected.pid <= 1 || expected.token.is_empty() || expected.token.len() > 80 {
|
|
bail!("Invalid supervisor ownership identity");
|
|
}
|
|
let fd = match pidfd(expected.pid) {
|
|
Ok(fd) => fd,
|
|
Err(e)
|
|
if e.downcast_ref::<std::io::Error>()
|
|
.is_some_and(|e| e.raw_os_error() == Some(libc::ESRCH)) =>
|
|
{
|
|
return Ok(())
|
|
}
|
|
Err(e) => return Err(e),
|
|
};
|
|
if exited(&fd)? {
|
|
return Ok(());
|
|
}
|
|
let actual = match identity(expected.pid, &expected.token) {
|
|
Ok(i) => i,
|
|
Err(_) if exited(&fd)? => return Ok(()),
|
|
Err(e) => return Err(e),
|
|
};
|
|
if &actual != expected {
|
|
return Ok(());
|
|
} // original process is gone; never signal a reused PID
|
|
let cmdline = match std::fs::read(format!("/proc/{}/cmdline", expected.pid)) {
|
|
Ok(data) => data,
|
|
Err(_) if exited(&fd)? => return Ok(()),
|
|
Err(e) => return Err(e.into()),
|
|
};
|
|
if !token_owner(&cmdline, &expected.token, || exited(&fd)).await? {
|
|
return Ok(());
|
|
}
|
|
let sent = unsafe {
|
|
libc::syscall(
|
|
libc::SYS_pidfd_send_signal,
|
|
fd.as_raw_fd(),
|
|
libc::SIGTERM,
|
|
std::ptr::null::<libc::siginfo_t>(),
|
|
0u32,
|
|
)
|
|
};
|
|
if sent < 0 {
|
|
let error = std::io::Error::last_os_error();
|
|
if !exited(&fd)? {
|
|
return Err(error.into());
|
|
}
|
|
}
|
|
tokio::time::timeout(Duration::from_secs(10), async {
|
|
while !exited(&fd)? {
|
|
tokio::time::sleep(Duration::from_millis(20)).await;
|
|
}
|
|
Ok::<_, anyhow::Error>(())
|
|
})
|
|
.await
|
|
.context("Direct process cleanup still pending; no restart/continuation permitted")??;
|
|
Ok(())
|
|
}
|
|
|
|
#[cfg(test)]
|
|
#[tokio::test]
|
|
async fn token_check_distinguishes_exit_race_from_live_ownership_failure() {
|
|
assert!(!token_owner(b"", "expected", || Ok(true)).await.unwrap());
|
|
assert!(token_owner(b"", "expected", || Ok(false)).await.is_err());
|
|
assert!(token_owner(b"other\0wrong\0", "expected", || Ok(false))
|
|
.await
|
|
.is_err());
|
|
assert!(token_owner(b"program\0expected\0", "expected", || panic!(
|
|
"matching token does not need fallback"
|
|
))
|
|
.await
|
|
.unwrap());
|
|
assert!(
|
|
token_owner(b"", "expected", || bail!("cannot establish exit"))
|
|
.await
|
|
.is_err()
|
|
);
|
|
for cmdline in [b"".as_slice(), b"program\0mismatch\0".as_slice()] {
|
|
let mut checks = 0;
|
|
assert!(!token_owner(cmdline, "expected", || {
|
|
checks += 1;
|
|
Ok(checks >= 3)
|
|
})
|
|
.await
|
|
.unwrap());
|
|
assert_eq!(checks, 3); // mismatch precedes confirmed group exit
|
|
}
|
|
}
|
|
|
|
static STOP: std::sync::atomic::AtomicBool = std::sync::atomic::AtomicBool::new(false);
|
|
extern "C" fn stop(_: libc::c_int) {
|
|
STOP.store(true, std::sync::atomic::Ordering::SeqCst);
|
|
}
|
|
fn stopping() -> bool {
|
|
STOP.load(std::sync::atomic::Ordering::SeqCst)
|
|
}
|
|
|
|
/// Called in a dedicated process BEFORE constructing a Tokio runtime. Only
|
|
/// this thread reaps children, preventing PID reuse between enumeration and kill.
|
|
pub fn supervise(owner: u32, workspace: &Path, command: &[String]) -> Result<i32> {
|
|
use std::io::{Read, Write};
|
|
use std::process::{Command, Stdio};
|
|
use std::sync::mpsc;
|
|
if command.is_empty() || !Path::new(&command[0]).is_absolute() {
|
|
bail!("Absolute tool executable required");
|
|
}
|
|
unsafe {
|
|
let mut action: libc::sigaction = std::mem::zeroed();
|
|
action.sa_sigaction = stop as *const () as usize;
|
|
libc::sigemptyset(&mut action.sa_mask);
|
|
for signal in [libc::SIGTERM, libc::SIGINT, libc::SIGHUP] {
|
|
if libc::sigaction(signal, &action, std::ptr::null_mut()) != 0 {
|
|
return Err(std::io::Error::last_os_error().into());
|
|
}
|
|
}
|
|
if libc::prctl(libc::PR_SET_CHILD_SUBREAPER, 1, 0, 0, 0) != 0
|
|
|| libc::prctl(libc::PR_SET_PDEATHSIG, libc::SIGTERM, 0, 0, 0) != 0
|
|
{
|
|
return Err(std::io::Error::last_os_error().into());
|
|
}
|
|
if libc::getppid() as u32 != owner || stopping() {
|
|
return Ok(0);
|
|
}
|
|
}
|
|
std::io::stdout().write_all(b"READY\n")?;
|
|
std::io::stdout().flush()?;
|
|
let mut start = [0u8; 6];
|
|
if std::io::stdin().read_exact(&mut start).is_err() {
|
|
return Ok(0);
|
|
}
|
|
if &start != b"START\n" || stopping() {
|
|
return Ok(0);
|
|
}
|
|
// START arrives only after durable identity recording. No server/code ran before it.
|
|
let mut child = Command::new(&command[0])
|
|
.args(&command[1..])
|
|
.current_dir(workspace)
|
|
.env_clear()
|
|
.env("PATH", "/usr/local/bin:/usr/bin:/bin")
|
|
.env("HOME", workspace)
|
|
.env("LANG", "C.UTF-8")
|
|
.stdin(Stdio::piped())
|
|
.stdout(Stdio::piped())
|
|
.stderr(Stdio::null())
|
|
.spawn()?;
|
|
let pid = child.id() as libc::pid_t;
|
|
let input = child.stdin.take().context("Missing child stdin")?;
|
|
let output = child.stdout.take().context("Missing child stdout")?;
|
|
let (tx, rx) = mpsc::channel();
|
|
let end = tx.clone();
|
|
std::thread::spawn(move || {
|
|
let _ = std::io::copy(&mut std::io::stdin(), &mut { input });
|
|
let _ = end.send(());
|
|
});
|
|
std::thread::spawn(move || {
|
|
let _ = std::io::copy(&mut { output }, &mut std::io::stdout());
|
|
let _ = tx.send(());
|
|
});
|
|
loop {
|
|
if stopping() || rx.recv_timeout(Duration::from_millis(20)).is_ok() {
|
|
break;
|
|
}
|
|
let mut status = 0;
|
|
let result = unsafe { libc::waitpid(pid, &mut status, libc::WNOHANG) };
|
|
if result == pid {
|
|
break;
|
|
}
|
|
if result < 0 && std::io::Error::last_os_error().raw_os_error() != Some(libc::EINTR) {
|
|
break;
|
|
}
|
|
}
|
|
// Do not exit until every owned descendant is reaped. Killing immediate
|
|
// children reparents their descendants here, even across setsid/double forks.
|
|
// If cleanup is obstructed, stay alive: the runtime reports pending cleanup.
|
|
loop {
|
|
// A procfs problem must not make the supervisor exit and falsely
|
|
// imply that cleanup succeeded. Keep ownership; host reports timeout.
|
|
if let Ok(tasks) = std::fs::read_dir("/proc/self/task") {
|
|
for task in tasks.flatten() {
|
|
if let Ok(ids) = std::fs::read_to_string(task.path().join("children")) {
|
|
for id in ids
|
|
.split_whitespace()
|
|
.filter_map(|s| s.parse::<libc::pid_t>().ok())
|
|
{
|
|
if id > 0 {
|
|
unsafe {
|
|
libc::kill(id, libc::SIGKILL);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
loop {
|
|
let result = unsafe { libc::waitpid(-1, std::ptr::null_mut(), libc::WNOHANG) };
|
|
if result > 0 {
|
|
continue;
|
|
}
|
|
if result < 0
|
|
&& std::io::Error::last_os_error().raw_os_error() == Some(libc::ECHILD)
|
|
{
|
|
return Ok(0);
|
|
}
|
|
break;
|
|
}
|
|
std::thread::sleep(Duration::from_millis(20));
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn preflight() -> Result<()> {
|
|
#[cfg(target_os = "macos")]
|
|
{
|
|
macos::identity(std::process::id(), "")?;
|
|
Ok(())
|
|
}
|
|
#[cfg(windows)]
|
|
{
|
|
let _ = crate::platform::windows::process(std::process::id())?;
|
|
Ok(())
|
|
}
|
|
#[cfg(target_os = "linux")]
|
|
{
|
|
linux::pidfd(std::process::id())?;
|
|
linux::identity(std::process::id(), "")?;
|
|
std::fs::read_to_string("/proc/thread-self/children")
|
|
.context("Linux procfs child enumeration is required for direct cleanup")?;
|
|
Ok(())
|
|
}
|
|
#[cfg(not(any(target_os = "linux", target_os = "macos", windows)))]
|
|
{
|
|
bail!("Host execution is supported on Linux and Windows")
|
|
}
|
|
}
|
|
pub fn identity(pid: u32, token: &str) -> Result<Identity> {
|
|
#[cfg(target_os = "macos")]
|
|
{
|
|
macos::identity(pid, token)
|
|
}
|
|
#[cfg(windows)]
|
|
{
|
|
windows::identity(pid, token)
|
|
}
|
|
#[cfg(target_os = "linux")]
|
|
{
|
|
linux::identity(pid, token)
|
|
}
|
|
#[cfg(not(any(target_os = "linux", target_os = "macos", windows)))]
|
|
{
|
|
let _ = (pid, token);
|
|
bail!("Linux process identity unavailable")
|
|
}
|
|
}
|
|
pub async fn cleanup(id: &Identity) -> Result<()> {
|
|
#[cfg(target_os = "macos")]
|
|
{
|
|
macos::cleanup(id).await
|
|
}
|
|
#[cfg(windows)]
|
|
{
|
|
windows::cleanup(id).await
|
|
}
|
|
#[cfg(target_os = "linux")]
|
|
{
|
|
linux::cleanup(id).await
|
|
}
|
|
#[cfg(not(any(target_os = "linux", target_os = "macos", windows)))]
|
|
{
|
|
let _ = id;
|
|
bail!("Linux cleanup unavailable")
|
|
}
|
|
}
|
|
pub fn supervise(owner: u32, workspace: &Path, command: &[String], token: &str) -> Result<i32> {
|
|
#[cfg(target_os = "macos")]
|
|
{
|
|
macos::supervise(owner, workspace, command, token)
|
|
}
|
|
#[cfg(windows)]
|
|
{
|
|
windows::supervise(owner, workspace, command, token)
|
|
}
|
|
#[cfg(not(any(windows, target_os = "macos")))]
|
|
let _ = token;
|
|
#[cfg(target_os = "linux")]
|
|
{
|
|
linux::supervise(owner, workspace, command)
|
|
}
|
|
#[cfg(not(any(target_os = "linux", target_os = "macos", windows)))]
|
|
{
|
|
let _ = (owner, workspace, command);
|
|
bail!("Supervisor is Linux-only")
|
|
}
|
|
}
|
|
pub fn doctor() -> Value {
|
|
let check = preflight();
|
|
json!({"ready":check.is_ok(),"sandbox":"off","enforcement":"none","host_os":std::env::consts::OS,
|
|
"warning":"UNSANDBOXED: tools have host-account file and network access. Approval mode is separate.",
|
|
"error":check.err().map(|e|e.to_string()),"docker_required":false})
|
|
}
|
|
|
|
pub struct Mcp {
|
|
child: tokio::process::Child,
|
|
input: Option<tokio::process::ChildStdin>,
|
|
output: BufReader<tokio::process::ChildStdout>,
|
|
pub identity: Identity,
|
|
sequence: u64,
|
|
failed: bool,
|
|
}
|
|
impl Mcp {
|
|
/// Spawn a paused supervisor. Caller MUST persist identity before start().
|
|
pub async fn launch(runner: &Path, workspace: &Path, command: &[String]) -> Result<Self> {
|
|
preflight()?;
|
|
let token = crate::id("supervisor");
|
|
let mut launch = std::process::Command::new(runner);
|
|
#[cfg(windows)]
|
|
{
|
|
use std::os::windows::process::CommandExt;
|
|
launch.creation_flags(windows_sys::Win32::System::Threading::CREATE_NO_WINDOW);
|
|
}
|
|
crate::platform::clean_environment(&mut launch, workspace);
|
|
#[cfg(target_os = "macos")]
|
|
launch.env(
|
|
"OPENWORKER_OWNER_START",
|
|
macos::identity(std::process::id(), "")?
|
|
.start_ticks
|
|
.to_string(),
|
|
);
|
|
#[cfg(windows)]
|
|
launch.env(
|
|
"OPENWORKER_OWNER_START",
|
|
crate::platform::windows::process(std::process::id())?
|
|
.creation_time()?
|
|
.to_string(),
|
|
);
|
|
let mut child = tokio::process::Command::from(launch)
|
|
.args([
|
|
"direct-supervisor",
|
|
"--owner",
|
|
&std::process::id().to_string(),
|
|
"--token",
|
|
&token,
|
|
"--workspace",
|
|
])
|
|
.arg(workspace)
|
|
.arg("--")
|
|
.args(command)
|
|
.current_dir(workspace)
|
|
.stdin(std::process::Stdio::piped())
|
|
.stdout(std::process::Stdio::piped())
|
|
.stderr(std::process::Stdio::null())
|
|
.kill_on_drop(false)
|
|
.spawn()?;
|
|
let id = identity(child.id().context("Missing supervisor PID")?, &token)?;
|
|
let input = child.stdin.take();
|
|
let mut output = BufReader::new(child.stdout.take().context("Missing supervisor stdout")?);
|
|
let mut ready = [0u8; 6];
|
|
tokio::time::timeout(Duration::from_secs(5), output.read_exact(&mut ready))
|
|
.await
|
|
.context("Supervisor readiness timed out")??;
|
|
if &ready != b"READY\n" {
|
|
bail!("Invalid supervisor readiness");
|
|
}
|
|
Ok(Self {
|
|
child,
|
|
input,
|
|
output,
|
|
identity: id,
|
|
sequence: 0,
|
|
failed: false,
|
|
})
|
|
}
|
|
pub async fn start(&mut self) -> Result<()> {
|
|
self.input
|
|
.as_mut()
|
|
.context("Supervisor closed")?
|
|
.write_all(b"START\n")
|
|
.await?;
|
|
let init=self.request("initialize",json!({"protocolVersion":"2025-11-25","capabilities":{},"clientInfo":{"name":"openworker-native","version":"0.1.0"}})).await?;
|
|
if !["2025-11-25", "2025-06-18", "2025-03-26", "2024-11-05"]
|
|
.contains(&init["protocolVersion"].as_str().unwrap_or(""))
|
|
{
|
|
bail!("Unsupported MCP protocol version");
|
|
}
|
|
self.send(json!({"jsonrpc":"2.0","method":"notifications/initialized","params":{}}))
|
|
.await
|
|
}
|
|
async fn send(&mut self, v: Value) -> Result<()> {
|
|
let data = format!("{v}\n");
|
|
if data.len() > crate::MAX_FRAME {
|
|
bail!("MCP request exceeds frame limit");
|
|
}
|
|
self.input
|
|
.as_mut()
|
|
.context("MCP stdin closed")?
|
|
.write_all(data.as_bytes())
|
|
.await?;
|
|
Ok(())
|
|
}
|
|
async fn line(&mut self) -> Result<Value> {
|
|
let mut data = vec![];
|
|
let n = (&mut self.output)
|
|
.take((crate::MAX_FRAME + 1) as u64)
|
|
.read_until(b'\n', &mut data)
|
|
.await?;
|
|
if n == 0 {
|
|
bail!("Direct MCP disconnected");
|
|
}
|
|
if n > crate::MAX_FRAME || data.last() != Some(&b'\n') {
|
|
bail!("Invalid/oversized MCP frame");
|
|
}
|
|
Ok(serde_json::from_slice(&data)?)
|
|
}
|
|
pub async fn request(&mut self, method: &str, params: Value) -> Result<Value> {
|
|
self.request_timeout(method, params, Duration::from_secs(75))
|
|
.await
|
|
}
|
|
pub async fn request_timeout(
|
|
&mut self,
|
|
method: &str,
|
|
params: Value,
|
|
timeout: Duration,
|
|
) -> Result<Value> {
|
|
if self.failed {
|
|
bail!("Direct MCP connection is no longer usable");
|
|
}
|
|
self.sequence += 1;
|
|
let id = self.sequence;
|
|
let result=tokio::time::timeout(timeout,async {
|
|
self.send(json!({"jsonrpc":"2.0","id":id,"method":method,"params":params})).await?;
|
|
loop {
|
|
let v=self.line().await?;
|
|
if v.get("method").is_some() {
|
|
if v.get("id").is_some() {self.send(json!({"jsonrpc":"2.0","id":v["id"],"error":{"code":-32601,"message":"Server-initiated requests are not permitted"}})).await?;}
|
|
continue;
|
|
}
|
|
if v["id"]!=id {bail!("MCP response correlation mismatch");}
|
|
if v.get("error").is_some() {bail!("MCP returned an error for {method}");}
|
|
let result=v.get("result").context("MCP result missing")?;
|
|
if serde_json::to_vec(result)?.len()>256000 {bail!("MCP result exceeds limit; execution may have occurred. Do not retry.");}
|
|
return Ok(result.clone());
|
|
}
|
|
}).await.context("Direct MCP request timed out").and_then(|r|r);
|
|
if result.is_err() {
|
|
self.failed = true;
|
|
self.close().await?;
|
|
}
|
|
result
|
|
}
|
|
pub async fn close(&mut self) -> Result<()> {
|
|
self.failed = true;
|
|
self.input.take();
|
|
cleanup(&self.identity).await?;
|
|
let status = tokio::time::timeout(Duration::from_secs(2), self.child.wait())
|
|
.await
|
|
.context("Supervisor reap pending")??;
|
|
if !status.success() {
|
|
bail!("Supervisor exited unexpectedly; descendant cleanup cannot be confirmed");
|
|
}
|
|
Ok(())
|
|
}
|
|
}
|