Python动态代码执行：深入解析`eval`、`exec`及沙箱安全实践114

作为一名专业的程序员，我们深知代码的灵活性和自动化能力是提高开发效率、构建强大系统的关键。Python语言以其卓越的动态特性，为我们提供了在运行时执行代码字符串的能力。这不仅为构建高度可配置、可扩展的应用程序打开了大门，也带来了不可忽视的安全挑战。本文将深入探讨Python中动态执行字符串的核心工具：`eval()`和`exec()`函数，详细解析它们的用法、应用场景、潜在风险以及如何通过沙箱技术和最佳实践来确保代码的安全性。

一、Python动态执行字符串的魅力与风险

在Python中，“动态执行字符串”是指将一个包含Python代码的字符串，在程序运行过程中解析并执行，而不是在编译时就确定其行为。这种能力在许多场景下都显得尤为有用：
数学表达式计算： 用户输入一个数学公式字符串，程序能实时计算结果。
配置解析： 将一些简单的配置逻辑以代码字符串形式存储，运行时动态加载。
领域特定语言（DSL）： 实现简单的脚本引擎，允许用户用特定语法编写业务逻辑。
插件系统： 动态加载和执行插件代码，扩展应用功能。
交互式Shell： 如Python自身的REPL环境，就是动态执行用户输入的字符串代码。

然而，权力越大，责任越大。动态执行字符串就像一把双刃剑，它的强大灵活性同时也带来了巨大的安全隐患。如果不对输入的字符串进行严格校验和环境隔离，恶意用户可能会通过注入精心构造的代码，获取系统权限、窃取敏感数据甚至破坏系统。因此，理解其工作原理、正确使用并采取必要的安全措施至关重要。

二、核心工具：`eval()` 函数——表达式的执行者

`eval()`函数用于执行一个Python表达式，并返回表达式的计算结果。它只能处理单个表达式，不能处理语句（如`if`、`for`、`while`、函数定义等）。

2.1 `eval()` 的基本用法

`eval(expression, globals=None, locals=None)`
`expression`: 必须是一个字符串，包含一个Python表达式。
`globals`: 可选参数，一个字典，用来指定执行表达式的全局命名空间。
`locals`: 可选参数，一个字典，用来指定执行表达式的局部命名空间。

示例：
# 基本数学计算
result = eval("1 + 2 * 3")
print(f"1 + 2 * 3 = {result}") # 输出: 1 + 2 * 3 = 7
# 访问程序中的变量
x = 10
y = 20
expression_str = "x + y * 2"
result = eval(expression_str)
print(f"{expression_str} = {result}") # 输出: x + y * 2 = 50
# 执行函数调用
print(f"len('hello') = {eval('len(hello)')}") # 输出: len('hello') = 5

2.2 `eval()` 的作用域管理：`globals` 和 `locals`

`globals`和`locals`参数是控制`eval()`执行环境的关键。默认情况下，`eval()`会在调用它的当前作用域中执行。但我们可以通过这两个参数来限制或扩展其可访问的变量和函数。

示例：限制可访问的变量
safe_dict = {'a': 10, 'b': 5}
# 只能访问safe_dict中定义的变量
result = eval("a * b", safe_dict)
print(f"a * b (with safe_dict) = {result}") # 输出: a * b (with safe_dict) = 50
# 尝试访问未定义的变量会报错
try:
result = eval("a + c", safe_dict)
except NameError as e:
print(f"Error: {e}") # 输出: Error: name 'c' is not defined
# 严格限制：只允许访问内置函数，不暴露任何全局变量
empty_globals = {"__builtins__": None} # 禁用所有内置函数
# 或者只允许部分内置函数，如print
# empty_globals = {"__builtins__": {"print": print, "len": len}}
try:
eval("a + b", empty_globals)
except NameError as e:
print(f"Error: {e}") # 输出: Error: name 'a' is not defined (因为a也不在空字典中)
# 只允许特定的内置函数
limited_builtins = {"__builtins__": {"abs": abs}}
print(f"abs(-5) = {eval("abs(-5)", limited_builtins)}") # 输出: abs(-5) = 5
try:
eval("len('test')", limited_builtins)
except NameError as e:
print(f"Error: {e}") # 输出: Error: name 'len' is not defined

三、核心工具：`exec()` 函数——语句的执行者

`exec()`函数用于执行更复杂的Python代码，它可以处理任何Python语句，包括`if`、`for`、`while`循环、函数定义、类定义、模块导入等。与`eval()`不同，`exec()`通常没有返回值（除非代码显式地修改了`globals`或`locals`字典中的变量）。

3.1 `exec()` 的基本用法

`exec(object, globals=None, locals=None)`
`object`: 可以是字符串，也可以是`compile()`函数返回的代码对象。
`globals`: 可选参数，一个字典，用来指定执行代码的全局命名空间。
`locals`: 可选参数，一个字典，用来指定执行代码的局部命名空间。

示例：
code_str = """
def greet(name):
print(f"Hello, {name}!")
greet("World")
for i in range(3):
print(i)
"""
exec(code_str)
# 输出:
# Hello, World!
# 0
# 1
# 2
# 动态定义函数并在之后调用
dynamic_globals = {}
exec("def add(a, b): return a + b", dynamic_globals)
# 从dynamic_globals中获取定义的函数
add_func = dynamic_globals['add']
print(f"add(3, 5) = {add_func(3, 5)}") # 输出: add(3, 5) = 8

3.2 `exec()` 的作用域管理：`globals` 和 `locals`

与`eval()`类似，`exec()`的`globals`和`locals`参数也用于控制其执行环境。这在创建沙箱环境时尤为重要。

示例：创建隔离环境
# 隔离环境，只允许访问内置的print函数
sandbox_globals = {"__builtins__": {"print": print}}
sandbox_locals = {}
malicious_code = """
import os
print("Current directory:", ()) # 尝试导入并使用os模块
"""
try:
exec(malicious_code, sandbox_globals, sandbox_locals)
except NameError as e:
print(f"Error in sandbox: {e}") # 输出: Error in sandbox: name 'os' is not defined
# 定义一个变量，并在沙箱中访问和修改
my_data = {"count": 0}
sandbox_globals_with_data = {"__builtins__": {"print": print}, "data": my_data}
exec("data['count'] += 1; print(f'New count: {data[count]}')", sandbox_globals_with_data)
print(f"Original data after exec: {my_data}")
# 输出:
# New count: 1
# Original data after exec: {'count': 1}

四、`compile()` 函数：预编译的优势

在多次执行同一个代码字符串时，每次都由`eval()`或`exec()`从头解析会带来性能开销。`compile()`函数允许我们将代码字符串预先编译成一个代码对象，然后将这个代码对象传递给`eval()`或`exec()`，从而提高执行效率。

4.1 `compile()` 的基本用法

`compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)`
`source`: 要编译的代码字符串或AST对象。
`filename`: 代码来源的文件名（仅用于错误报告，可以是任意字符串，如`""`）。
`mode`: 字符串，指定编译模式：

`'eval'`: 编译一个表达式，供`eval()`使用。
`'exec'`: 编译一系列语句，供`exec()`使用。
`'single'`: 编译单个交互式语句，供`exec()`使用（常用于REPL）。

示例：
# 编译表达式
expr_code_obj = compile("10 + x * 2", "", "eval")
x = 5
result = eval(expr_code_obj)
print(f"10 + x * 2 = {result}") # 输出: 10 + x * 2 = 20
# 编译语句
stmt_code_obj = compile("""
for i in range(3):
print(f"Loop count: {i}")
""", "", "exec")
exec(stmt_code_obj)
# 输出:
# Loop count: 0
# Loop count: 1
# Loop count: 2

使用`compile()`的另一个好处是，它可以在实际执行前捕获语法错误。如果`source`字符串存在语法问题，`compile()`会直接抛出`SyntaxError`，而不是等到`eval()`或`exec()`执行时才发现。

五、动态执行的风险与安全考量

动态执行字符串的强大功能伴随着严重的安全风险。最主要的威胁是“代码注入攻击”，即恶意用户通过输入包含恶意Python代码的字符串，使得程序执行未经授权的操作。

5.1 代码注入攻击示例

考虑一个允许用户输入数学表达式的应用程序：
user_input = input("请输入一个数学表达式: ")
# 假设用户输入的是："1 + 2"
# 正常执行:
# print(eval(user_input)) # 输出: 3
# 恶意用户输入可能是：
# user_input = "__import__('os').system('rm -rf /')"
# 或者
# user_input = "__import__('subprocess').run(['cat', '/etc/passwd'])"
# 或者
# user_input = "__import__('webbrowser').open('/?data=' + __import__('base64').b64encode(b'secret_data').decode())"
# 如果直接执行 eval(user_input)，将导致灾难性后果。
# 在Windows上，类似('del /s /q C:\') 也同样危险。

恶意用户可以利用`__import__`内置函数导入任何可用的Python模块（如`os`, `sys`, `subprocess`, `shutil`等），从而执行文件操作、系统命令、网络请求、数据窃取等任意操作。即使是看似无害的表达式，也可能通过链式调用间接实现恶意行为。

5.2 性能开销、调试与维护的挑战

性能开销： 动态解析和执行字符串代码通常比直接执行预编译的代码慢。
调试困难： 动态生成的代码在堆栈跟踪中可能显示为来自`""`或`""`，增加了调试的难度。
可读性与维护： 代码逻辑分散在字符串中，降低了代码的可读性，增加了未来维护的复杂性。

六、如何减轻风险：沙箱化与安全实践

为了安全地使用动态执行字符串功能，我们必须采取严格的措施来限制其权限。

6.1 严格输入验证（白名单机制）

在将用户输入传递给`eval()`或`exec()`之前，务必进行严格的输入验证。最佳实践是使用“白名单”策略，即只允许已知和安全的字符、操作符、函数名等通过，而不是试图去“黑名单”过滤所有可能的恶意输入。对于简单的数学表达式，可以手动解析或使用专门的解析库。
import re
def safe_math_eval(expression):
# 严格的白名单：只允许数字、加减乘除、括号和空格
# 注意：这只是一个示例，实际生产环境需要更健壮的解析器
if not (r"[\d+\-*/().\s]+", expression):
raise ValueError("Invalid characters in expression.")

# 进一步，如果需要更安全，可以构建AST并遍历检查
return eval(expression)
try:
print(safe_math_eval("1 + 2 * 3"))
# safe_math_eval("__import__('os').system('echo hello')") # 会被正则表达式拦截
except ValueError as e:
print(f"Safe eval error: {e}")

6.2 沙箱环境：`globals` 和 `locals` 的运用

通过精心构造`globals`和`locals`字典，我们可以创建一个“沙箱”环境，严格限制动态代码能够访问的资源。
禁用`__builtins__`： 默认情况下，`eval()`和`exec()`会访问Python的内置函数。通过将`__builtins__`设置为一个空字典或只包含部分安全内置函数的字典，可以有效阻止对`__import__`、`open()`、`exit()`等危险函数的访问。
限制暴露的变量和函数： 只将动态代码确实需要的变量和函数放入`globals`和`locals`中。


# 最严格的沙箱：几乎禁用所有内置函数
safe_globals = {"__builtins__": {}} # 空字典，禁用所有内置函数
# 如果需要特定的内置函数，可以手动添加
# safe_globals = {"__builtins__": {"abs": abs, "min": min, "max": max}}
# 添加用户可以安全访问的变量或函数
user_data = {'value': 100}
safe_globals['data'] = user_data
safe_globals['add_one'] = lambda x: x + 1
malicious_code_1 = "__import__('os').system('ls')"
malicious_code_2 = "open('/etc/passwd', 'r')"
safe_code_1 = "data['value'] + 50"
safe_code_2 = "add_one(data['value'])"
safe_code_3 = "print('Hello from sandbox!')" # 注意：print需要添加到__builtins__中才能使用
try:
# 尝试执行恶意代码1
eval(malicious_code_1, safe_globals)
except NameError as e:
print(f"Caught expected error 1: {e}") # NameError: name '__import__' is not defined
except Exception as e:
print(f"Caught unexpected error 1: {e}")
try:
# 尝试执行恶意代码2
eval(malicious_code_2, safe_globals)
except NameError as e:
print(f"Caught expected error 2: {e}") # NameError: name 'open' is not defined
except Exception as e:
print(f"Caught unexpected error 2: {e}")
# 尝试执行安全代码
print(f"Safe eval 1: {eval(safe_code_1, safe_globals)}") # 输出: Safe eval 1: 150
print(f"Safe eval 2: {eval(safe_code_2, safe_globals)}") # 输出: Safe eval 2: 101
# 如果要允许print，需要在__builtins__中添加
safe_globals_with_print = {"__builtins__": {"print": print}, "data": user_data}
exec(safe_code_3, safe_globals_with_print) # 输出: Hello from sandbox!

6.3 使用 `ast` 模块进行抽象语法树（AST）解析

对于更复杂的场景，尤其当你需要允许用户输入一定程度的脚本代码时，仅仅依赖`globals`和`locals`可能不够。更安全的做法是使用Python的`ast`（Abstract Syntax Tree）模块来解析代码字符串，构建其抽象语法树。然后遍历AST，检查其中是否存在不安全的节点（如`Import`、`ImportFrom`、`Call`到危险函数等），从而在执行前拒绝恶意代码。

这种方法需要更深入的理解和实现，但它提供了最高级别的安全性控制，因为它在代码执行前就分析了其结构和意图。
import ast
class SecurityVisitor():
def visit_Import(self, node):
raise ValueError("Import statements are not allowed!")

def visit_ImportFrom(self, node):
raise ValueError("Import from statements are not allowed!")
def visit_Call(self, node):
# 检查函数调用是否是白名单内的安全函数
if isinstance(, ):
if not in ['print', 'len', 'sum']: # 允许的安全函数
raise ValueError(f"Function '{}' is not allowed!")
elif isinstance(, ):
# 允许调用列表、字典等对象的安全方法
if not (isinstance(, (, , )) and
in ['append', 'get', 'keys', 'values']):
raise ValueError(f"Method '{}' is not allowed!")

self.generic_visit(node) # 继续遍历子节点
def safe_exec_with_ast(code_string, globals_dict=None, locals_dict=None):
try:
tree = (code_string)
visitor = SecurityVisitor()
(tree) # 遍历AST，检查安全性

# 如果AST检查通过，则安全执行
exec(code_string, globals_dict, locals_dict)
except (SyntaxError, ValueError) as e:
print(f"Security error: {e}")
except Exception as e:
print(f"Execution error: {e}")
# 示例使用
safe_globals_ast = {"__builtins__": {"print": print}, "data_list": [1, 2, 3]}
print("--- AST-based Security Test ---")
safe_exec_with_ast("print(len(data_list))", safe_globals_ast) # 允许: print(3)
safe_exec_with_ast("(4); print(data_list)", safe_globals_ast) # 允许: [1, 2, 3, 4]
# 尝试执行恶意代码
safe_exec_with_ast("import os", safe_globals_ast) # 拦截: Import statements are not allowed!
safe_exec_with_ast("('ls')", safe_globals_ast) # 拦截: Function 'os' is not allowed!
safe_exec_with_ast("open('', 'w')", safe_globals_ast) # 拦截: Function 'open' is not allowed!

七、替代方案：更安全的实现方式

在许多情况下，动态执行字符串的需求可以通过更安全、更易维护的方式实现。
配置解析： 对于简单的配置需求，使用JSON、YAML、INI等标准配置文件格式，配合相应的解析库（`json`, `yaml`, `configparser`），比`eval()`或`exec()`安全得多。
函数或方法映射： 如果需要根据字符串动态调用函数或方法，可以使用字典将字符串与实际的函数对象进行映射。


def operation_add(a, b): return a + b
def operation_sub(a, b): return a - b
operation_map = {
"add": operation_add,
"sub": operation_sub
}
op_name = "add" # 假设这是用户输入
num1, num2 = 10, 5
if op_name in operation_map:
result = operation_map[op_name](num1, num2)
print(f"Operation '{op_name}': {result}") # 输出: Operation 'add': 15
else:
print(f"Invalid operation: {op_name}")
# 对于对象方法，可以使用getattr()
class Calculator:
def add(self, a, b): return a + b
def sub(self, a, b): return a - b
calc = Calculator()
method_name = "add"
if hasattr(calc, method_name) and callable(getattr(calc, method_name)):
method_func = getattr(calc, method_name)
print(f"Calculator method '{method_name}': {method_func(10, 5)}") # 输出: Calculator method 'add': 15


领域特定语言（DSL）解析器： 如果业务逻辑复杂到需要自定义语法，可以考虑编写一个专门的DSL解析器，而不是直接执行Python代码。像`pyparsing`或`PLY`这样的库可以帮助构建这样的解析器。

八、最佳实践与总结

动态执行字符串是Python提供的一项强大功能，但应谨慎使用。
最小化使用： 除非绝对必要，否则尽量避免使用`eval()`和`exec()`。优先考虑更安全、更可维护的替代方案。
永不信任用户输入： 绝不能直接将来自用户或不可信来源的字符串传递给`eval()`或`exec()`，除非你已经实施了严格的安全措施。
实施沙箱： 如果必须使用，务必通过`globals`和`locals`参数构建严格的沙箱环境，禁用`__builtins__`中所有危险函数，并只暴露绝对必要的安全资源。
输入验证： 结合白名单机制对输入进行预处理和校验。
AST分析： 对于高级需求，利用`ast`模块进行抽象语法树分析，从结构层面识别和阻止恶意代码。
充分测试： 对包含动态执行代码的部分进行彻底的安全测试和渗透测试。

掌握Python动态执行字符串的能力，意味着不仅要了解其强大的功能，更要深刻理解其潜在的风险，并负责任地采取全面的安全措施。只有这样，我们才能真正驾驭这把双刃剑，构建出既灵活又健壮的Python应用程序。

2025-11-05

---

上一篇：Python数据提取：从入门到实践，解锁各类数据源的宝藏

下一篇：Python面向对象编程：类定义、方法创建与内部调用精解