# ---- 沙箱层：OS 强制的执行边界 ----

# ACTIVE_SANDBOX 非 None 时，每一条 bash 命令都在笼子里跑。默认 None——
# 沙箱是显式开启的（-sandbox），不是默认值。原因在"网络"这一刀上：
# 断网是全有全无的开关（见 build_sandbox_profile），默认开沙箱等于默认
# 弄坏一切要联网的命令（pip install、git fetch、npm install），权限
# 系统 + 人工确认才是常开的那道闸。
ACTIVE_SANDBOX = None


# default_sandbox_policy 是标准笼子：可写的只有工作目录和临时目录；可读的
# 加上系统目录；网络关闭。家目录整体不在可读名单里——~/.ssh、~/.aws、
# ~/.config 这些密钥重灾区因此碰不到，这正是要保护的东西。
def default_sandbox_policy():
    tmp = tempfile.gettempdir()
    return {
        "read_roots": [WORK_DIR, tmp, "/usr", "/bin", "/sbin", "/etc", "/var",
                       "/private", "/System", "/Library", "/opt"],
        "write_roots": [WORK_DIR, tmp],
        "allow_network": False,
    }


# sandbox_available 报告这台机器能不能强制执行沙箱。本章的实现用 macOS
# 自带的 sandbox-exec；Linux 上 octo 用的是内核的 Landlock + seccomp，
# 实现要多一层自我重执行的技巧，本书不展开。
def sandbox_available():
    if platform.system() != "Darwin":
        return False
    return os.path.exists("/usr/bin/sandbox-exec")


# build_sandbox_profile 把 policy 翻译成 macOS 沙箱的规则语言（SBPL）。
# 底座是 allow default，在放行的底座上只收紧三个口子：写先全禁再放行
# write_roots；读把家目录整体禁掉再放行 read_roots；网一刀切断，除非
# allow_network。路径先解析符号链接再写进规则——macOS 的 /tmp 实际是
# /private/tmp 的链接，内核检查的是真实路径。
def build_sandbox_profile(p):
    def resolve(path):
        try:
            return os.path.realpath(path)
        except OSError:
            return path

    def subpaths(roots):
        return " ".join(f'(subpath "{resolve(r)}")' for r in roots)

    lines = ["(version 1)", "(allow default)", "(deny file-write*)",
              f"(allow file-write* {subpaths(p['write_roots'])})",
              '(allow file-write* (literal "/dev/null") (literal "/dev/tty") '
              '(literal "/dev/stdout") (literal "/dev/stderr"))']
    home = os.path.expanduser("~")
    if home:
        lines.append(f'(deny file-read* (subpath "{resolve(home)}"))')
        lines.append(f"(allow file-read* {subpaths(p['read_roots'])})")
    if not p["allow_network"]:
        lines.append("(deny network*)")
    return "\n".join(lines) + "\n"

然后是这一章最重要的几行——唯一的那扇门。Python 版返回一份 argv 列表而不是拼好的字符串，跟 subprocess.run 不传 shell=True 配套： 参数不经过 shell 再解析一遍，sandbox-exec 后面那几个参数（尤其是 profile 里的换行和引号）不会被 shell 误解析：

def shell_command(command):
    if ACTIVE_SANDBOX is not None:
        profile = build_sandbox_profile(ACTIVE_SANDBOX)
        return ["/usr/bin/sandbox-exec", "-p", profile, "/bin/sh", "-c", command]
    return ["sh", "-c", command]

BashTool.execute 里原来 subprocess.run(command, shell=True, ...) 那一行，command 换成 shell_command(command)，去掉 shell=True：

        try:
            result = subprocess.run(
                shell_command(command),
                cwd=WORK_DIR,
                stdout=subprocess.PIPE,
                stderr=subprocess.STDOUT,
                timeout=d,
            )

main() 开头认这个开关，机器给不了沙箱就拒绝启动：

    global ACTIVE_SANDBOX
    ...
    if len(args) >= 1 and args[0] == "-sandbox":
        args = args[1:]
        if not sandbox_available():
            print("错误: 这台机器提供不了 OS 级沙箱（本章实现只支持带 sandbox-exec 的 macOS），"
                  "拒绝在没有边界的情况下假装有边界地运行", file=sys.stderr)
            sys.exit(1)
        ACTIVE_SANDBOX = default_sandbox_policy()
        print(f"[沙箱开启：可写 {ACTIVE_SANDBOX['write_roots']}，"
              "家目录不可读（工作目录和临时目录除外），网络关闭——OS 强制，批准了也越不出去]",
              file=sys.stderr)

别忘了文件头加 import platform、import tempfile。

// ---- 沙箱层：OS 强制的执行边界 ----

// activeSandbox 非 null 时，每一条 bash 命令都在笼子里跑。默认 null——
// 沙箱是显式开启的（-sandbox），不是默认值。
let activeSandbox = null;

// defaultSandboxPolicy 是标准笼子：可写的只有工作目录和临时目录；可读的
// 加上系统目录；网络关闭。家目录整体不在可读名单里，这正是要保护的东西。
function defaultSandboxPolicy() {
  const tmp = tmpdir();
  return {
    readRoots: [workDir, tmp, "/usr", "/bin", "/sbin", "/etc", "/var",
      "/private", "/System", "/Library", "/opt"],
    writeRoots: [workDir, tmp],
    allowNetwork: false,
  };
}

// sandboxAvailable 报告这台机器能不能强制执行沙箱。本章的实现用 macOS
// 自带的 sandbox-exec；Linux 上 octo 用的是内核的 Landlock + seccomp，
// 实现要多一层自我重执行的技巧，本书不展开。
function sandboxAvailable() {
  if (process.platform !== "darwin") return false;
  return existsSync("/usr/bin/sandbox-exec");
}

// buildSandboxProfile 把 policy 翻译成 macOS 沙箱的规则语言（SBPL）。
// 底座是 allow default，在放行的底座上只收紧三个口子：写先全禁再放行
// writeRoots；读把家目录整体禁掉再放行 readRoots；网一刀切断，除非
// allowNetwork。路径先解析符号链接再写进规则。
function buildSandboxProfile(p) {
  const resolve = (path) => {
    try {
      return realpathSync(path);
    } catch {
      return path;
    }
  };
  const subpaths = (roots) => roots.map((r) => `(subpath "${resolve(r)}")`).join(" ");
  let profile = "(version 1)\n(allow default)\n(deny file-write*)\n";
  profile += `(allow file-write* ${subpaths(p.writeRoots)})\n`;
  profile += '(allow file-write* (literal "/dev/null") (literal "/dev/tty") ' +
    '(literal "/dev/stdout") (literal "/dev/stderr"))\n';
  const home = homedir();
  if (home) {
    profile += `(deny file-read* (subpath "${resolve(home)}"))\n`;
    profile += `(allow file-read* ${subpaths(p.readRoots)})\n`;
  }
  if (!p.allowNetwork) profile += "(deny network*)\n";
  return profile;
}

然后是这一章最重要的几行——唯一的那扇门。JavaScript 版返回 [文件, 参数数组] 一对，配合 execFileSync 而不是 execSync：参数 不经过 shell 再解析一遍，sandbox-exec 后面那几个参数不会被 shell 误解析——这也是这一章唯一顺手改掉的一处：练习 22 的 execSync 换成 了 execFileSync：

function shellArgv(command) {
  const wrapped = `(${command}) 2>&1`;
  if (activeSandbox) {
    const profile = buildSandboxProfile(activeSandbox);
    return ["/usr/bin/sandbox-exec", ["-p", profile, "/bin/sh", "-c", wrapped]];
  }
  return ["/bin/sh", ["-c", wrapped]];
}

BashTool.execute 里原来那行 execSync(\(${command}) 2>&1`, {…})` 换成：

    const [file, argv] = shellArgv(command);
    try {
      const out = execFileSync(file, argv, {
        cwd: workDir,
        timeout: d * 1000,
        maxBuffer: 64 * 1024 * 1024,
      });

顶层脚本认这个开关，机器给不了沙箱就拒绝启动：

if (args.length >= 1 && args[0] === "-sandbox") {
  args = args.slice(1);
  if (!sandboxAvailable()) {
    console.error("错误: 这台机器提供不了 OS 级沙箱（本章实现只支持带 sandbox-exec 的 macOS），" +
      "拒绝在没有边界的情况下假装有边界地运行");
    process.exit(1);
  }
  activeSandbox = defaultSandboxPolicy();
  console.error(`[沙箱开启：可写 [${activeSandbox.writeRoots.join(", ")}]，` +
    "家目录不可读（工作目录和临时目录除外），网络关闭——OS 强制，批准了也越不出去]");
}

别忘了从 node:child_process 换成 import execFileSync（而不是 execSync），从 node:fs 多 import 一个 realpathSync，再从 node:os import homedir、tmpdir。

运行不用编译，跳到下一步就行。

运行不用编译，跳到下一步就行。

写一个 test_sandbox.py，直接 import main 拿沙箱层的函数（main.py 的顶层只有函数和类定义，main() 本身在 if __name__ == "__main__" 里，import 不会误触发它）：

def run(command, sandboxed):
    harness.ACTIVE_SANDBOX = harness.default_sandbox_policy() if sandboxed else None
    try:
        argv = harness.shell_command(command)
        result = subprocess.run(argv, cwd=harness.WORK_DIR,
                                 stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
        return result.stdout.decode(errors="replace"), result.returncode
    finally:
        harness.ACTIVE_SANDBOX = None


class SandboxTests(unittest.TestCase):
    def test_blocks_home_write(self):
        target = os.path.join(os.path.expanduser("~"), "smoke-should-fail.txt")
        try:
            out, code = run(f"echo pwned > {target}", sandboxed=True)
            self.assertNotEqual(code, 0, f"家目录写入应当被拦: out={out!r}")
            self.assertFalse(os.path.exists(target), "文件不应该存在——命令报错但文件写成了？")
        finally:
            if os.path.exists(target):
                os.remove(target)

照这个样子再写工作目录写入、临时目录写入、读家目录文件、curl， 外加对照组（sandboxed=False，证明拦住那几个的是沙箱）：

python3 test_sandbox.py

写一个 test_sandbox.mjs。main.mjs 是顶层脚本（一 import 就会解析 CLI 参数、发网络请求），没法直接拿来单测——把沙箱层那几个纯函数原样 抄一份（跟 main.mjs 里的版本逐字一致），用 Node 自带的 node:test：

import { test } from "node:test";
import assert from "node:assert/strict";

function run(command, sandboxed) {
  const [file, argv] = shellArgv(command, sandboxed ? defaultSandboxPolicy() : null);
  try {
    const out = execFileSync(file, argv, { cwd: workDir });
    return [out.toString(), 0];
  } catch (err) {
    return [(err.stdout ?? Buffer.alloc(0)).toString(), err.status ?? 1];
  }
}

test("sandbox blocks home write", { skip: !sandboxAvailable() }, () => {
  const target = join(homedir(), "smoke-should-fail.txt");
  try {
    const [out, code] = run(`echo pwned > ${target}`, true);
    assert.notEqual(code, 0, `家目录写入应当被拦: out=${out}`);
    assert.equal(existsSync(target), false, "文件不应该存在——命令报错但文件写成了？");
  } finally {
    if (existsSync(target)) unlinkSync(target);
  }
});

照这个样子再写工作目录写入、临时目录写入、读家目录文件、curl， 外加对照组：

node --test test_sandbox.mjs

python3 main.py -sandbox "在当前工作目录建一个 notes.txt，写进去一行'沙箱内正常工作'，然后用 cat 读出来确认。再试着把同样一行写到我的家目录 ~/ex23-should-fail.txt，如实汇报这次成功还是失败、报错原文是什么。"

node main.mjs -sandbox "在当前工作目录建一个 notes.txt，写进去一行'沙箱内正常工作'，然后用 cat 读出来确认。再试着把同样一行写到我的家目录 ~/ex23-should-fail.txt，如实汇报这次成功还是失败、报错原文是什么。"

python3 main.py -sandbox "请做两件事，两件都要做，失败也如实汇报：(1) 用 bash 执行一条命令，命令原文必须严格就是 cat $HOME/ex23-secret-demo.txt ——不要加分号、不要加 echo、不要加任何其他内容，就这一条；(2) 用名叫 home 的 MCP 服务的工具读同一个文件。最后告诉我两条路径分别成功还是失败、各自看到了什么、失败的报错原文是什么。"

node main.mjs -sandbox "请做两件事，两件都要做，失败也如实汇报：(1) 用 bash 执行一条命令，命令原文必须严格就是 cat $HOME/ex23-secret-demo.txt ——不要加分号、不要加 echo、不要加任何其他内容，就这一条；(2) 用名叫 home 的 MCP 服务的工具读同一个文件。最后告诉我两条路径分别成功还是失败、各自看到了什么、失败的报错原文是什么。"