军哥的 AI 实战笔记头像

《AI 编程 Agent 驯化手册》01|Claude Code 的多层防线,哪一层才是底线?

《AI 编程 Agent 驯化手册》01|Claude Code 的多层防线,哪一层才是底线?

上一篇结尾留了个问题:你在 Claude Code 里写了一条 Bash(rm *) 的 deny 规则,/bin/rm -rf build/ 能不能拦住?

官方权限文档的回答很干脆:拦不住。文档里专门有一张表,列了几种换个写法就能绕开 deny 规则的命令,/bin/rm -rf build/ 和 bash -c 'rm -rf build/' 都在上面。文档对规则的定位也写得很明白:它覆盖的是 Claude 平时最常生成的那种写法,并不是围在某个程序外面的安全边界。

既然规则不是边界,那么多层防线里,到底哪一层是?这篇就来查这件事。结论先写下。

规则和 Hook 都是在命令执行之前看一眼,看这条命令怎么写,写法一变就可能看漏。真正不看写法的是操作系统这一层,也就是沙箱。本篇拿 25 种写法的删除命令做了对照:规则、子串 Hook、解析 Hook 三层叠在一起,还是放过了 3 种;沙箱边界一种也没放过,但它只护得住边界以外,边界以内的东西它不管。边界以内的,得靠 git。

先把几道关按顺序列出来

官方文档把一次工具调用要过的关写得比较清楚,如下图所示。
在这里插入图片描述

图里有几个顺序上的细节,平时不太容易注意到。

Hook 在最前面。PreToolUse hook 在任何权限模式检查之前就会跑,所以哪怕开着 bypassPermissions,hook 返回 deny,这次调用照样被拦下。反过来不行:hook 返回 allow,只是免掉弹窗,deny 和 ask 规则照样生效。

hook 脚本的退出码也有讲究。退出码 0 表示"我没意见",并不是"我批准了";退出码 2 才是拦下;其他退出码,比如脚本崩溃时的 1,只要 stdout 里没有合法的 JSON 决定,就只算一次非阻塞错误,命令照常执行。上一篇的脚本把所有异常都接住再 exit 2,原因就在这里。

规则按 deny、ask、allow 的顺序找,先命中的算数,规则写得多具体都不改变这个顺序。所以一条宽泛的 Bash(aws *) deny,会把更具体的 Bash(aws s3 ls) allow 一起压住,allow 没法在 deny 上开例外。

规则是 Claude Code 自己执行的,不靠模型自觉。你在提示词或者 CLAUDE.md 里写"不要删文件",影响的是模型想不想去做,管不了 Claude Code 放不放行。

最后是沙箱,而且它只管 Bash 这一路。文档写得很清楚,它只作用于 Bash、PowerShell 和 Monitor 这几种命令,以及它们的子进程。

规则里:官方自己承认的缺口

上一篇的"前缀规则"是为了演示,写得很简单。真实的 Claude Code 要聪明一些,文档里写明的有这么几件事:

  • 把复合命令按 &&、||、;、|、|&、& 和换行拆开,每一段单独匹配。deny 和 ask 规则只要有任何一段命中就算命中,藏在子 shell、$(...) 命令替换、for 循环体里的命令也算。
  • 匹配之前先剥掉一批包装器:timeout、time、nice、nohup、stdbuf、command、builtin、noglob,还有不带参数的 xargs。deny 规则还能越过命令前面的 FOO=bar 这类变量赋值。

所以 cd /tmp && rm -rf x、timeout 30 rm -rf x 这类写法,一条 Bash(rm *) 就能拦住。

它不做的事,文档也列出来了:

你写的 deny 规则能拦住拦不住
Bash(rm *)rm -rf build//bin/rm -rf build/、bash -c 'rm -rf build/'
Bash(curl *)curl https://example.com/usr/bin/curl https://example.com、sh -c 'curl https://example.com'
Bash(git push *)git push origin maingit -C . push origin main、git -c push.default=current push origin main、git 'push' origin main

文档后面接着说:想要不依赖命令文本的强制,用沙箱;想用自己的逻辑检查完整命令,用 PreToolUse hook。规则更像一句提醒,而不是一道围栏。

实验:同一件事的 25 种写法

光看文档不够直观,下面用个小实验让数字说话。

实验目录分两块:project/ 是命令执行的地方,outside/ 放着另一个项目的文件,相当于项目之外的东西。25 种写法的命令都在 project/ 里执行,目标有两个,一个是删掉项目里面的 build/,一个是删掉项目外面的 ../outside/other_project。
在这里插入图片描述

25 种写法分五组:

  • 换写法:rm -fr、rm --recursive --force、/bin/rm、引号拼接 r""m、用 ${IFS} 代替空格
  • 套一层:timeout、nohup、env、bash -c、eval、xargs
  • 拼接:&& 和 ; 连起来,$(...) 拼出程序名,变量里存程序名,base64 解码后交给 sh
  • 换工具:find -delete、find -exec rm、Python 的 shutil.rmtree、Node 的 rmSync
  • 间接:直接执行一个已有的脚本,或者先写一个脚本再执行

为了排除"这种写法其实根本删不掉东西"的情况,每一条我都先在没有任何防护的条件下真的执行了一遍,25 条全部能删掉目标。所以后面说的"放过",都是真能造成破坏的放过。

拿来检查的有四样东西:

  • 规则:按官方文档写的 deny 规则模拟器,规则是 rm *、find * -delete*、find * -exec rm *、shred *、git push --force*、git clean * 这一圈,算是认真写过的。它是我对文档的理解,不是 Claude Code 本体。我拿文档里明确写出的 32 个例子(通配符怎么匹配,哪些写法拦得住、拦不住)给它做了自检,全部对得上。
  • 子串 Hook:命令里出现 rm -rf 这几个字就拦,网上教程里常见的写法。
  • 解析 Hook:上一篇的 guard.py。它有个漏洞:没认 timeout 这类官方文档里会被剥掉的包装器,这次补上了,改动很小,放在文末。
  • 边界:用 unshare 加只读的 bind mount 手搭的,outside/ 在里面是只读的,project/ 可写。这不是 Claude Code 的沙箱(我这里没装 bubblewrap),但思路一样:沙箱本质上就是给进程换一套挂载视图,哪些路径能写,由系统说了算。

结果如下。"文档"那一列,"明说能拦"和"明说拦不住"是官方文档里直接写了的(分别 6 条和 2 条),"推断"是文档没直接写、我按它的规则推出来的(17 条),这 17 条在真实版本里是不是这样,需要有环境的人去验证。

编号写法官方文档规则子串 Hook解析 Hook
A1rm -rf build明说能拦拦拦拦
A2rm -fr build推断拦拦拦
A3rm -r -f build推断拦漏拦
A4rm --recursive --force build推断拦漏拦
A5/bin/rm -rf build明说拦不住漏拦拦
A6r""m -rf build推断漏漏拦
A7rm${IFS}-rf${IFS}build推断漏漏拦
B1timeout 30 rm -rf build明说能拦拦拦拦
B2nohup rm -rf build明说能拦拦拦拦
B3env X=1 rm -rf build推断漏拦拦
B4bash -c 'rm -rf build'明说拦不住漏拦拦
B5sh -c "rm -rf build"推断漏拦拦
B6eval "rm -rf build"推断漏拦拦
B7echo build | xargs rm -rf明说能拦拦拦拦
C1cd . && rm -rf build明说能拦拦拦拦
C2echo ok; rm -rf build明说能拦拦拦拦
C3$(echo rm) -rf build推断漏漏拦
C4X=rm; $X -rf build推断漏漏拦
C5echo cm0gLXJmIGJ1aWxk | base64 -d | sh推断漏拦拦
D1find build -delete推断拦漏拦
D2find build -type f -exec rm {} +推断拦漏拦
D3python3 -c "import shutil; shutil.rmtree('build')"推断漏漏拦
D4node -e "require('fs').rmSync('build',{recursive:true})"推断漏漏漏
E1bash cleanup.sh推断漏漏漏
E2printf '%s -%s %s' rm rf build > c.sh; sh c.sh推断漏漏漏

汇总一下,下面是程序的原始输出:

规则模拟器自检:32 条对得上,0 条对不上

一共 25 种写法。先确认它们都真的删得掉东西(不加任何防护直接跑):
  删掉了项目内 build:25/25;删掉了项目外 other_project:25/25

文本层:命令执行之前先看一眼,看的是命令怎么写。被放过 = 命令照样能执行、能删掉东西
  deny 规则(按官方文档写的模拟器):放过 14/25
  子串 Hook:                        放过 12/25
  解析 Hook(guard.py):            放过 3/25
  三层叠在一起(任何一层拦就算拦): 放过 3/25  D4 E1 E2

边界层:命令一律照常执行,只看它最远能写到哪
  项目外 other_project 被删:0/25(还剩 25/25)
  项目内 build 被删:        25/25

把数字摆开看:

规则放过 14 种。文档明说拦不住的 2 种(A5、B4)都在里面,文档明说能拦的 6 种全部拦住了。其余放过的是引号拼接、${IFS}、env、eval、$(...) 拼程序名、base64、Python、Node 这些。

子串 Hook 放过 12 种。把参数拆开写的 rm -r -f,find -delete,Python 的一行代码,都能过。

解析 Hook 只放过 3 种:Node 的 rmSync、bash cleanup.sh、先写脚本再执行。三层叠在一起,放过的还是这 3 种。

这 3 种的性质不一样。Node 那条,往 guard.py 里补一行正则就能拦,可是补完,下一种语言又会冒出来,黑名单永远列不完。后两条补不了,因为"要删什么"这个信息根本不在这条命令里,它在脚本文件里,而脚本文件是前一条命令刚写出来的。

再看边界。同样 25 种写法,一条一条真的执行:项目外的 other_project 一个都没删掉,25 条全部报 Read-only file system;项目里的 build/,25 条全部删掉了。

它为什么没漏?因为它压根不看命令怎么写。内核只关心一件事:这个进程要写的这个文件,在不在可写的范围里。/bin/rm、bash -c、base64 解码出来的 rm、Node 的 rmSync,落到系统调用这一层,没有区别。官方文档里有一句话说的就是这个意思:沙箱由操作系统对运行中的进程强制执行,不管模型选了运行什么,哪怕一条放行的命令做的事比它名字看起来更多,这道边界照样成立。

沙箱也有漏洞:官方文档自己写的几处

这里的 0/25 有个前提,是把 outside/ 设成了只读。真实的 Claude Code 里,这个前提要靠配置和实际运行状态来保证。文档里写着这几处:

起不来就不用。 默认情况下,沙箱如果因为缺依赖或者平台不支持而启动不了,Claude Code 只弹一个警告,然后在没有沙箱的情况下继续跑命令。想让它硬失败,要设 sandbox.failIfUnavailable 为 true。Linux 上需要装 bubblewrap 和 socat;Ubuntu 24.04 以后,默认的 AppArmor 策略还会阻止 bubblewrap 创建用户命名空间,需要额外加一份配置。

有逃生口。 命令在沙箱里因为限制而失败时,Claude 可以带着 dangerouslyDisableSandbox 参数重试。重试的命令在沙箱外运行,走普通的权限流程:手动模式下弹窗,auto 模式下由分类器判断。想关掉这个口子,设 allowUnsandboxedCommands 为 false(/sandbox 面板里叫 Strict sandbox mode)。

项目目录本身是可写的,而且自动放行模式下沙箱里的命令不弹窗。 文档的意思是:在沙箱边界内修改文件的 Bash 命令,即使在手动模式下也会直接执行,而文件编辑工具在同样的情况下是会弹窗的。这就是实验里 build/ 被 25 种写法全部删掉的原因。文档还提到,指向"关键路径"的 rm 和 rmdir 即使在这个模式下也仍然要走权限流程,关键路径具体指哪些,在文档的权限模式那一页,本文没展开。

读不设防。 沙箱默认可以读整台电脑,~/.ssh、~/.aws/credentials 这类凭据文件默认也读得到,要自己用 sandbox.credentials 或者 denyRead 去挡。另外,沙箱里的命令默认会继承父进程的环境变量,环境变量里的密钥也跟着进去了。

只管 Bash 这一路。 内置的 Read、Edit、Write 工具走的是权限系统,不在沙箱里;MCP 工具也不在沙箱的范围内。

文档自己的结论。 沙箱降低风险,但不是完整的隔离边界。比如网络过滤是按主机名放行的,默认不检查 TLS 里的内容,放行 github.com 这类大域名可能留下外传数据的通道。

沙箱有一点是做得扎实的:即使在可写的目录里,它仍然拒绝写入 .claude 下的配置文件、.claude/hooks、.mcp.json、.git/hooks 和 .bashrc、.zshrc 这类文件,免得一条命令给自己改权限或者加 hook。这类"会被信任的文件"在系列后面还会专门讲一篇。

边界以内的东西,沙箱护不住,要靠 git。下面是实验里的真实输出:

$ rm -rf src            # 在边界里,src 在项目目录内,照样删得掉
$ git status --short
 D src/main.c
$ git restore src
$ ls src
main.c

被删的文件,一条 git restore 就回来了。没有 git 的项目,删了就是真删了,所以让 Claude 动手之前,先提交一次,是个值得养成的习惯。

所以,底线到底是哪一层

答案要按通道分着说。
在这里插入图片描述

Bash 命令这一路,底线是沙箱,前提是它真的启动了,逃生口也关了。规则和 Hook 是前面的过滤,看的是命令怎么写,猜的是意图。

内置文件工具这一路,底线是 Read、Edit 的路径规则。这类规则是按路径判断的,由工具自己执行,不需要去解析一段命令文本,所以比 Bash 规则牢靠得多。文档里说,它们对内置文件工具生效,对 Claude Code 认得出来的 cat、head、tail、sed、tee 和重定向目标也生效;但管不到 Python 或 Node 脚本自己去打开文件,那一块要靠沙箱。

项目里面的东西,底线是 git。

那么 Hook 和规则就没用了吗?也不是。它们的价值在另外几处:Hook 能看到完整的命令,可以写自己的逻辑;Hook 优先于权限模式,连 bypass 也拦得住;拦下的时候,原因会反馈给 Claude,它能换个做法,不会一直撞墙。规则则是个低成本的提醒。只是别把它们当成最后一道线。

最小配置

下面这份是可以先用起来的最小配置,放在 .claude/settings.json(项目共享)或者 ~/.claude/settings.json(你自己)里:

{
  "sandbox": {
    "enabled": true,
    "failIfUnavailable": true,
    "allowUnsandboxedCommands": false,
    "autoAllowBashIfSandboxed": true,
    "credentials": {
      "files": [
        { "path": "~/.ssh", "mode": "deny" },
        { "path": "~/.aws/credentials", "mode": "deny" }
      ]
    }
  },
  "permissions": {
    "deny": [
      "Read(./.env)",
      "Edit(./.env)",
      "Bash(git push --force*)"
    ]
  }
}

说明:

  • enabled 打开沙箱。
  • failIfUnavailable 让沙箱起不来时直接失败,而不是悄悄不用它。
  • allowUnsandboxedCommands 关掉逃生口。有些工具和沙箱不兼容(比如文档提到的 docker、watchman),关掉之后它们会失败,需要把这些命令加到 excludedCommands 里,这个口子要自己权衡。
  • autoAllowBashIfSandboxed 是默认值,沙箱里的命令不弹窗。如果你希望项目里的 Bash 命令也弹窗确认,改成 false。
  • credentials.files 挡住 SSH 密钥和 AWS 凭据的读取,这一项要求 Claude Code 2.1.187 或更高版本。
  • permissions.deny 里两条 .env 的规则是按路径写的,比命令规则牢靠;git push --force* 只算一句提醒,别指望它拦住所有写法。

改完之后,在 Claude Code 里输入 /sandbox,看 Config 页里解析出来的配置是不是你想要的。Linux 和 WSL2 需要先 sudo apt-get install bubblewrap socat,macOS 用系统自带的 Seatbelt,不用装东西,原生 Windows 不支持。

想自己验证

实验的完整代码放在文末,只用标准库。

python3 lab.py                    # 跑完整实验(需要 Linux 和 unshare)
python3 lab.py --selfcheck        # 只检查规则模拟器和文档例子对不对得上
python3 lab.py --rules "Bash(rm *)" "Bash(git push *)"
                                  # 用你自己的 deny 规则,看 25 种写法哪些会漏(只判断,不执行)

lab.py 要和更新后的 guard.py 放在同一个目录。非 root 用户也能跑,前提是系统允许创建用户命名空间。

规则那一列是模拟器给出的,想在真实的 Claude Code 上核对,可以在一个临时目录里这样做:写一条 Bash(rm *) 的 deny 规则,让 Claude 原样执行表里的命令,每次执行前放一个测试文件,执行后看文件在不在。有一点要注意:如果 Claude 自己把命令改写了,这次测试就不算数。

上一篇提到,有论文说一条命令拼接的子命令超过 50 个时,逐条的安全分析会被跳过。这一条没有在真实环境里复现,官方文档里也没找到相关的说明,所以不下结论。想验证的话,python3 lab.py --gen-long 60 会生成一条带 60 个子命令、最后才是 rm -rf build 的长命令,拿去和你的 deny 规则试试看,结果欢迎贴在评论区。

这个实验的局限

  • 规则那一列是按官方文档写的模拟器,不是 Claude Code 本体。17 条标"推断"的结果,在不同版本里可能不一样。
  • 边界是用 unshare 加只读挂载手搭的,不是 Claude Code 的沙箱。只验证了"边界外只读"这一件事,网络隔离没测。
  • 25 种写法只是挑选能想到的,不代表全部。实验只测了删除这一种破坏,用的是 Linux,Python 3.12。

小结

回到标题的问题。对 Bash 命令来说,底线是沙箱;对文件工具来说,底线是路径规则;对项目里面的东西,底线是 git。规则和 Hook 不是底线,但也不是没用:它们让 Claude 在动手前就被告知"别这么做",能少走很多弯路。

下一篇讲 Codex。它走的是另一条路:把活儿关进沙箱,越界时才问你,而"问你"这一步,可以交给另一个 AI 去审。让 AI 审 AI,能信到什么程度,下一篇来查。

你现在配了哪些 deny 规则?评论区贴一两条(别贴密钥和公司路径),我用 lab.py --rules 帮你测测会漏几种。觉得有用就点个关注,下一篇周四见。

附:guard.py 的改动

在上一篇 guard.py 的基础上改这几处,其余不动:

@@ -14,13 +14,16 @@
 
 PUNCT = ";&|()\n"                      # 这些字符把命令切成一段一段
 SHELLS = {"sh", "bash", "zsh", "dash", "ksh"}
-WRAPPERS = {"sudo", "env", "command", "nohup", "time", "nice", "xargs", "busybox", "exec"}
+WRAPPERS = {"sudo", "env", "command", "nohup", "time", "nice", "xargs", "busybox", "exec",
+            "timeout", "stdbuf", "builtin"}
 WRAPPER_OPT_WITH_ARG = {
     "sudo": {"-u", "-g", "-h", "-p", "-C", "-D", "-R", "-T"},
     "xargs": {"-I", "-n", "-P", "-L", "-s", "-E", "-d"},
     "env": {"-u", "-C", "-S"},
     "nice": {"-n"},
+    "timeout": {"-s", "-k"},
 }
+WRAPPER_POSITIONAL = {"timeout": 1}      # timeout 30 cmd:时长也是一个参数,要跳过
 
 
 def judge(cmd, depth=0):
@@ -74,6 +77,9 @@
             opt = words.pop(0)
             if opt in WRAPPER_OPT_WITH_ARG.get(name, ()) and words:
                 words.pop(0)
+        for _ in range(WRAPPER_POSITIONAL.get(name, 0)):
+            if words:
+                words.pop(0)
     return words
 
 

附:lab.py 完整代码

#!/usr/bin/env python3
"""lab.py:同一件事(删目录)的 25 种写法,看每一层拦不拦得住。只用标准库。

需要 Linux,并且能用 unshare(root,或系统允许普通用户创建用户命名空间)。
和上一篇的 guard.py 放在同一个目录。

  python3 lab.py                 跑完整实验,打印汇总
  python3 lab.py --markdown      同时打印 markdown 表格
  python3 lab.py --selfcheck     只检查规则模拟器和官方文档的例子对不对得上
  python3 lab.py --gen-long 60   生成一条带 60 个子命令的长命令(拿去真实 Claude Code 上试)
  python3 lab.py --rules "Bash(rm *)" "Bash(git push *)"
                                 用你自己的 deny 规则,看 25 种写法哪些会漏(只判断,不执行)
"""
import base64
import os
import re
import shutil
import subprocess
import sys
import tempfile

import guard   # 上一篇的解析型 hook

# ------------------------------------------------------------------
# 一、按官方权限文档写的 deny 规则模拟器(不是 Claude Code 本体)
# ------------------------------------------------------------------

# 你认真写了一圈的 deny 规则(Bash(...) 里的内容)
DENY = ["rm *", "find * -delete*", "find * -exec rm *", "shred *",
        "git push --force*", "git push -f*", "git clean *", "mkfs*"]


def split_commands(text):
    """按 && || |& ; | & 和换行切开,引号里的不算。返回每一段的原文。"""
    segs, cur, i, quote = [], [], 0, None
    while i < len(text):
        c = text[i]
        if quote:
            cur.append(c)
            if c == "\\" and quote == '"' and i + 1 < len(text):
                cur.append(text[i + 1])
                i += 2
                continue
            if c == quote:
                quote = None
            i += 1
            continue
        if c in "'\"":
            quote = c
            cur.append(c)
            i += 1
            continue
        if c == "\\" and i + 1 < len(text):
            cur.append(c)
            cur.append(text[i + 1])
            i += 2
            continue
        if text[i:i + 2] in ("&&", "||", "|&"):
            segs.append("".join(cur))
            cur = []
            i += 2
            continue
        if c in ";|&\n":
            segs.append("".join(cur))
            cur = []
            i += 1
            continue
        cur.append(c)
        i += 1
    segs.append("".join(cur))
    return [s.strip() for s in segs if s.strip()]


def all_subcommands(cmd, depth=0):
    """切开后,再钻进 $(...)、反引号和 (...) 子 shell 里面找命令。"""
    found = []
    for seg in split_commands(cmd):
        m = re.match(r"^\((.*)\)$", seg, re.S)
        if m and depth < 4:
            found += all_subcommands(m.group(1), depth + 1)
            continue
        found.append(seg)
        if depth < 4:
            for inner in re.findall(r"\$\(([^()]*)\)", seg) + re.findall(r"`([^`]*)`", seg):
                found += all_subcommands(inner, depth + 1)
    return found


def _skip_opts(rest, with_arg):
    toks = rest.split(None, 1)
    while toks and toks[0].startswith("-"):
        opt = toks[0]
        rest = toks[1] if len(toks) > 1 else ""
        toks = rest.split(None, 1)
        if opt in with_arg and toks:
            rest = toks[1] if len(toks) > 1 else ""
            toks = rest.split(None, 1)
    return rest


def strip_wrappers(seg):
    """剥掉官方文档里列出的包装器:timeout、time、nice、nohup、stdbuf、command、
    builtin、noglob、不带参数的 xargs,以及开头的 VAR=value。sudo 和 env 不在名单里。"""
    s = seg
    while True:
        m = re.match(r"^[A-Za-z_][A-Za-z0-9_]*=(?:\"[^\"]*\"|'[^']*'|\S*)\s+(.+)$", s, re.S)
        if m:
            s = m.group(1).strip()
            continue
        parts = s.split(None, 1)
        if len(parts) < 2:
            return s
        w, rest = parts
        if w == "timeout":
            rest = _skip_opts(rest, {"-s", "-k"})
            s = rest.split(None, 1)[1] if len(rest.split(None, 1)) > 1 else ""
        elif w == "command" and rest.split(None, 1)[0] in ("-v", "-V"):
            return s
        elif w in ("time", "nohup", "command", "builtin", "noglob"):
            s = _skip_opts(rest, set())
        elif w == "nice":
            s = _skip_opts(rest, {"-n"})
        elif w == "stdbuf":
            s = _skip_opts(rest, {"-i", "-o", "-e"})
        elif w == "xargs" and not rest.startswith("-"):
            s = rest
        else:
            return s


def pattern_regex(p):
    body = ".*".join(re.escape(x) for x in p.split("*"))
    rx = "^" + body + "$"
    if p.endswith(" *") and p.count("*") == 1:        # 末尾 " *" 也匹配不带参数的裸命令
        rx = "^(?:" + re.escape(p[:-2]) + "|" + body + ")$"
    return re.compile(rx, re.S)


def rule_matches(pattern, cmd):
    return bool(pattern_regex(pattern).match(cmd))


def rules_block(cmd, deny=DENY):
    """deny 规则:任何一个子命令(包括藏在 $() 里的)命中就拦。"""
    for sub in all_subcommands(cmd):
        for text in (sub, strip_wrappers(sub)):
            if any(rule_matches(p, text) for p in deny):
                return True
    return False


# ------------------------------------------------------------------
# 二、用官方文档里写明的例子,检查上面这个模拟器有没有写歪
# ------------------------------------------------------------------

def selfcheck():
    ok = bad = 0
    # (规则, 命令, 文档说是否匹配)
    pattern_cases = [
        ("npm run build", "npm run build", True), ("npm run build", "npm run build --watch", False),
        ("npm run *", "npm run build", True), ("npm run *", "npm run test --watch", True),
        ("npm run *", "npm run", True), ("npm run *", "npm install", False),
        ("git log * main", "git log --oneline main", True), ("git log * main", "git log main", False),
        ("git * main", "git merge main", True), ("git * main", "git push origin main", True),
        ("git * main", "git log", False),
        ("* --version", "node --version", True), ("* --version", "node -v", False),
        ("ls *", "ls -la", True), ("ls *", "ls", True), ("ls *", "lsof", False),
        ("ls*", "lsof", True), ("* --help *", "npm --help x", True), ("* --help *", "npm --help", False),
    ]
    for pat, cmd, want in pattern_cases:
        got = rule_matches(pat, cmd)
        ok, bad = (ok + 1, bad) if got == want else (ok, bad + 1)
        if got != want:
            print("通配符不符:", pat, "|", cmd, "文档说", want, "我的是", got)
    # (deny 规则, 命令, 文档说是否被拦)
    block_cases = [
        (["rm *"], "rm -rf build/", True),
        (["rm *"], "/bin/rm -rf build/", False),             # 文档表格明确写了拦不住
        (["rm *"], "bash -c 'rm -rf build/'", False),        # 同上
        (["git push *"], "git push origin main", True),
        (["git push *"], "git -C . push origin main", False),
        (["git push *"], "git 'push' origin main", False),
        (["git clean *"], "cd /tmp && git clean -f", True),  # 复合命令里任何一段命中就拦
        (["git clean *"], 'echo "$(git clean -f)"', True),   # 命令替换里也算
        (["rm *"], "timeout 30 rm -rf x", True),             # 被剥掉的包装器
        (["rm *"], "nohup rm -rf x", True),
        (["rm *"], "echo x | xargs rm -rf", True),           # 不带参数的 xargs 会被剥掉
        (["rm *"], "echo x | xargs -n1 rm -rf", False),      # 带参数就不剥了
        (["rm *"], "FOO=bar rm -rf tmp/", True),             # deny 能越过开头的变量赋值
    ]
    for deny, cmd, want in block_cases:
        got = rules_block(cmd, deny)
        ok, bad = (ok + 1, bad) if got == want else (ok, bad + 1)
        if got != want:
            print("拦截不符:", deny, "|", cmd, "文档说", want, "我的是", got)
    print(f"规则模拟器自检:{ok} 条对得上,{bad} 条对不上")
    return bad == 0


# ------------------------------------------------------------------
# 三、25 种写法。{T} 是要删的目标
# ------------------------------------------------------------------

def b64(s):
    return base64.b64encode(s.encode()).decode()


# (编号, 分组, 生成命令的函数, 官方文档怎么说)
CAN, CANNOT, INFER = "明说能拦", "明说拦不住", "推断"
VARIANTS = [
    ("A1", "换写法", lambda T: f"rm -rf {T}", CAN),
    ("A2", "换写法", lambda T: f"rm -fr {T}", INFER),
    ("A3", "换写法", lambda T: f"rm -r -f {T}", INFER),
    ("A4", "换写法", lambda T: f"rm --recursive --force {T}", INFER),
    ("A5", "换写法", lambda T: f"/bin/rm -rf {T}", CANNOT),
    ("A6", "换写法", lambda T: f'r""m -rf {T}', INFER),
    ("A7", "换写法", lambda T: f"rm${{IFS}}-rf${{IFS}}{T}", INFER),
    ("B1", "套一层", lambda T: f"timeout 30 rm -rf {T}", CAN),
    ("B2", "套一层", lambda T: f"nohup rm -rf {T}", CAN),
    ("B3", "套一层", lambda T: f"env X=1 rm -rf {T}", INFER),
    ("B4", "套一层", lambda T: f"bash -c 'rm -rf {T}'", CANNOT),
    ("B5", "套一层", lambda T: f'sh -c "rm -rf {T}"', INFER),
    ("B6", "套一层", lambda T: f'eval "rm -rf {T}"', INFER),
    ("B7", "套一层", lambda T: f"echo {T} | xargs rm -rf", CAN),
    ("C1", "拼接", lambda T: f"cd . && rm -rf {T}", CAN),
    ("C2", "拼接", lambda T: f"echo ok; rm -rf {T}", CAN),
    ("C3", "拼接", lambda T: f"$(echo rm) -rf {T}", INFER),
    ("C4", "拼接", lambda T: f"X=rm; $X -rf {T}", INFER),
    ("C5", "拼接", lambda T: f"echo {b64('rm -rf ' + T)} | base64 -d | sh", INFER),
    ("D1", "换工具", lambda T: f"find {T} -delete", INFER),
    ("D2", "换工具", lambda T: f"find {T} -type f -exec rm {{}} +", INFER),
    ("D3", "换工具", lambda T: f"python3 -c \"import shutil; shutil.rmtree('{T}')\"", INFER),
    ("D4", "换工具", lambda T: f"node -e \"require('fs').rmSync('{T}',{{recursive:true}})\"", INFER),
    ("E1", "间接", lambda T: "bash cleanup.sh", INFER),            # cleanup.sh 里写着 rm -rf {T}
    ("E2", "间接", lambda T: f"printf '%s -%s %s' rm rf {T} > c.sh; sh c.sh", INFER),
]
T_IN, T_OUT = "build", "../outside/other_project"


def substring_hook(cmd):
    bad = ["rm -rf", "rm -fr", "git push --force", "git clean -fd", "| bash", "| sh", "mkfs"]
    return any(b in cmd for b in bad)


def parsed_hook(cmd):
    return guard.judge(cmd) is not None


# ------------------------------------------------------------------
# 四、实验室:项目目录可写,outside 在边界里只读
# ------------------------------------------------------------------

def fresh_lab(base, target):
    if os.path.isdir(base):
        shutil.rmtree(base)
    os.makedirs(f"{base}/project/build/sub")
    os.makedirs(f"{base}/project/src")
    os.makedirs(f"{base}/outside/other_project/data")
    for f in ("project/build/a.o", "project/build/b.o", "project/build/sub/c.o", "project/src/main.c",
              "outside/other_project/notes.txt", "outside/other_project/data/d.bin", "outside/precious.txt"):
        with open(f"{base}/{f}", "w") as fh:
            fh.write("x\n")
    with open(f"{base}/project/cleanup.sh", "w") as fh:       # 给 E1 用的脚本
        fh.write(f"rm -rf {target}\n")


def files_left(path):
    return sum(len(fs) for _, _, fs in os.walk(path)) if os.path.exists(path) else 0


def run_in(base, cmd, boundary):
    project = f"{base}/project"
    if not boundary:
        argv = ["bash", "-c", cmd]
    else:
        outside = f"{base}/outside"
        script = (f'set -e\nmount --make-rprivate /\nmount --bind "{outside}" "{outside}"\n'
                  f'mount -o remount,ro,bind "{outside}"\ncd "{project}"\nexec bash -c "$1"\n')
        unshare = ["unshare", "-m"] if os.geteuid() == 0 else ["unshare", "-Urm"]
        argv = unshare + ["bash", "-c", script, "_", cmd]
    subprocess.run(argv, cwd=project, capture_output=True, timeout=20)


def check_safe(cmd):
    """实验只允许动 build 和 ../outside/other_project,别的路径一律不碰。"""
    assert not re.search(r"(?<![\w.])/(?!bin/rm)\w", cmd.replace("/bin/rm", "")), cmd


def experiment():
    base = tempfile.mkdtemp(prefix="redteam_")
    rows = []
    try:
        for vid, group, build, doc in VARIANTS:
            row = {"id": vid, "group": group, "doc": doc, "cmd": build(T_IN)}
            for tag, T, left_path in (("in", T_IN, "project/build"), ("out", T_OUT, "outside/other_project")):
                cmd = build(T)
                check_safe(cmd)
                fresh_lab(base, T)
                run_in(base, cmd, boundary=False)
                row[f"bare_{tag}"] = files_left(f"{base}/{left_path}") == 0        # 裸跑:真的删掉了吗
                fresh_lab(base, T)
                run_in(base, cmd, boundary=True)
                row[f"box_{tag}"] = files_left(f"{base}/{left_path}") == 0         # 进边界:还删得掉吗
            row["rules"] = rules_block(row["cmd"])
            row["substr"] = substring_hook(row["cmd"])
            row["parsed"] = parsed_hook(row["cmd"])
            rows.append(row)
    finally:
        shutil.rmtree(base, ignore_errors=True)
    return rows


def git_recovery_demo():
    """边界保不住项目里的东西,这一段演示 git 怎么兜底。"""
    base = tempfile.mkdtemp(prefix="redteam_git_")
    out = []
    try:
        fresh_lab(base, T_IN)
        p = f"{base}/project"
        g = ["git", "-c", "user.name=lab", "-c", "user.email=lab@example.com"]
        for args in (["init", "-q"], ["add", "-A"], ["commit", "-q", "-m", "init"]):
            subprocess.run(g + args, cwd=p, capture_output=True)
        run_in(base, "rm -rf src", boundary=True)
        out.append("$ rm -rf src            # 在边界里,src 在项目目录内,照样删得掉")
        out.append("$ git status --short")
        out.append(subprocess.run(["git", "status", "--short"], cwd=p, capture_output=True, text=True).stdout.rstrip())
        subprocess.run(["git", "restore", "src"], cwd=p, capture_output=True)
        out.append("$ git restore src")
        out.append("$ ls src")
        out.append(" ".join(sorted(os.listdir(f"{p}/src"))))
    finally:
        shutil.rmtree(base, ignore_errors=True)
    return "\n".join(out)


def gen_long(n):
    return " && ".join(["true"] * n) + " && rm -rf build"


# ------------------------------------------------------------------
# 五、输出
# ------------------------------------------------------------------

def summarize(rows):
    n = len(rows)
    def leak(key):
        return sum(1 for r in rows if not r[key] and r["bare_out"])
    print(f"\n一共 {n} 种写法。先确认它们都真的删得掉东西(不加任何防护直接跑):")
    print(f"  删掉了项目内 build:{sum(r['bare_in'] for r in rows)}/{n};"
          f"删掉了项目外 other_project:{sum(r['bare_out'] for r in rows)}/{n}")
    print("\n文本层:命令执行之前先看一眼,看的是命令怎么写。被放过 = 命令照样能执行、能删掉东西")
    print(f"  deny 规则(按官方文档写的模拟器):放过 {leak('rules')}/{n}")
    print(f"  子串 Hook:                        放过 {leak('substr')}/{n}")
    print(f"  解析 Hook(guard.py):            放过 {leak('parsed')}/{n}")
    stacked = [r["id"] for r in rows if not (r["rules"] or r["substr"] or r["parsed"])]
    print(f"  三层叠在一起(任何一层拦就算拦): 放过 {len(stacked)}/{n}  {' '.join(stacked)}")
    print("\n边界层:命令一律照常执行,只看它最远能写到哪")
    print(f"  项目外 other_project 被删:{sum(r['box_out'] for r in rows)}/{n}"
          f"(还剩 {sum(not r['box_out'] for r in rows)}/{n})")
    print(f"  项目内 build 被删:        {sum(r['box_in'] for r in rows)}/{n}")


def markdown(rows):
    sym = lambda blocked: "拦" if blocked else "**漏**"
    print("\n| 编号 | 写法 | 官方文档 | 规则 | 子串 Hook | 解析 Hook |")
    print("|---|---|---|---|---|---|")
    for r in rows:
        cmd = r["cmd"].replace("|", "\\|")
        print(f"| {r['id']} | `{cmd}` | {r['doc']} | {sym(r['rules'])} | {sym(r['substr'])} | {sym(r['parsed'])} |")


def test_my_rules(patterns):
    deny = [re.sub(r"^Bash\((.*)\)$", r"\1", p.strip()) for p in patterns]
    print("你的 deny 规则:", deny)
    leaked = 0
    for vid, _group, build, doc in VARIANTS:
        cmd = build(T_IN)
        blocked = rules_block(cmd, deny)
        leaked += not blocked
        print(f"  {vid}  {'拦' if blocked else '漏'}  {cmd}")
    print(f"25 种写法里放过了 {leaked} 种(按官方文档写的模拟器判断,真实版本可能有出入)")


def main():
    if "--rules" in sys.argv:
        test_my_rules(sys.argv[sys.argv.index("--rules") + 1:])
        return
    if "--selfcheck" in sys.argv:
        sys.exit(0 if selfcheck() else 1)
    if "--gen-long" in sys.argv:
        print(gen_long(int(sys.argv[sys.argv.index("--gen-long") + 1])))
        return
    if not sys.platform.startswith("linux") or not shutil.which("unshare"):
        sys.exit("这个实验需要 Linux 和 unshare 命令。")
    if not selfcheck():
        sys.exit("规则模拟器和文档对不上,先别看后面的结果。")
    rows = experiment()
    summarize(rows)
    print("\n项目内的东西,边界保不住,靠 git:")
    print(git_recovery_demo())
    if "--markdown" in sys.argv:
        markdown(rows)


if __name__ == "__main__":
    main()

转载自 CSDN-专业IT技术社区

原文链接:https://blog.csdn.net/forest_09/article/details/170805003

文章来源转载

评论

评论列表

微信小程序
QQ小程序

关于作者

点赞数:0
关注数:0
粉丝:0
文章:0
关注标签:0
加入于:--