自己写简单 Python 脚本辅助 SRC 挖洞:批量检测接口、批量探测敏感目录

本文介绍基于Python编写的轻量级安全测试脚本,用于SRC授权范围内的批量敏感目录探测、接口存活检测及水平越权初筛。强调脚本设计原则:轻量(最小依赖)、可控(速率/并发可调)、可复用(参数化)、最小验证(仅探测不利用)。涵盖多线程/协程提速、请求头伪装、结果去重与误报过滤,并严格遵循SRC合规红线,如禁止高并发压测、禁止批量遍历ID、禁止自动提交工单等。

免责声明:本文所有脚本与思路仅用于 SRC 授权范围内资产的安全测试学习,严禁对未授权目标运行任何探测、扫描脚本。未经授权对网站、服务器进行扫描探测属于违法行为。所有脚本设计遵循最小验证原则,禁止批量遍历用户 ID、批量拉取业务数据、高并发压测线上业务。文中代码均为脱敏教学示例,不包含针对特定厂商的攻击载荷。本文仅代表个人实战经验,不构成攻击指导。

摘要

很多 SRC 白帽挖洞,默认第一反应是 “找一个成熟工具一键搞定”:目录扫描用 dirsearch、ffuf,接口枚举用工具,漏洞验证用 xray、nuclei。工具确实强大,但存在几个痛点:一是大批量资产场景下通用工具配置复杂、结果筛选成本高;二是工具扫描逻辑固定,无法按你的业务思路定制;三是很多 SRC 场景其实只需要轻量的 “参数探测”" 目录枚举 "“接口对比” 逻辑,用通用重型工具反而是杀鸡用牛刀。

自己写简单 Python 脚本,恰好能补齐这些短板。Python 标准库加上requests、asyncio、aiohttp几个库,就能实现:批量探测敏感目录、批量检测接口状态、批量识别未授权 / 越权、批量对比接口响应、结果结构化存储。脚本轻量、逻辑可控、可按自己挖洞思路定制,是 SRC 挖洞工具箱里非常实用的一块。

本文万字实战长文,从零教你编写一套 “挖洞辅助 Python 脚本”,覆盖:脚本设计原则、环境搭建、批量敏感目录探测脚本、批量接口检测脚本、接口未授权 / 越权批量对比脚本、多线程 / 协程提速方案、结果去重与误报过滤、请求头伪装、脚本合规红线、踩坑复盘、代码规范与复用。全程从 SRC 实战需求出发,不堆砌无用框架,写的是能直接落地、按需改动的轻量脚本。全文约 13300 字。

前言

先明确一个观念:自己写挖洞脚本,不是为了替代专业工具,而是补充工具的盲区,贴合自己的挖洞思路。

专业工具覆盖的是 “通用、标准化” 的探测逻辑:目录爆破、常见漏洞 POC。但 SRC 挖洞大量场景是高度定制化的:

  1. 你只想知道某个站点存活的接口清单,以及哪些接口返回业务数据;
  2. 你想批量对比两个账号会话,快速找出水平越权接口;
  3. 你想批量探测一批子域名上是否存在.env、.git、备份文件;
  4. 你想控制每个目标的请求速率、请求头,按你的节奏探测,而不是工具默认的狂暴并发;
  5. 你想把探测结果直接导出成结构化清单,方便后续人工审计。

这些需求,用通用工具反而别扭,自己写一个几十行的 Python 脚本,逻辑清楚、结果可控,几秒钟就能完成一批目标的探测。

更重要的一点:写脚本的过程,就是梳理挖洞思路的过程。 你写 “批量探测敏感目录”,其实是在整理 “哪些敏感文件值得探测、命中后怎么定级”;你写 “批量检测接口”,其实是在整理 “什么样的接口值得进一步测未授权 / 越权”。脚本是挖洞方法论的可执行载体。

先给出本文脚本的定位边界:

  • 只做资产探测、信息收集、接口对比,不做漏洞利用、不做 getshell、不批量拉数据;
  • 所有脚本必须能通过参数限制并发、限制速率;
  • 所有结果都是 “候选”,需要人工核验后才能提交 SRC;
  • 运行脚本前,必须确认目标在 SRC 授权范围内。

一、脚本设计原则:轻量、可控、可复用

写挖洞脚本,和写业务系统代码不同,不需要复杂的架构设计,但要遵守几条实战原则。

1.1 轻量优先,能不用框架就不用框架

除非目标特别大、需要分布式,否则 SRC 挖洞脚本用requests同步请求就够了。协程用asyncio + aiohttp或grequests即可。不要一上来引入 Celery、Redis 队列、数据库,增加复杂度还难以维护。

单个脚本目标:一个 Python 文件,依赖越少越好,复制到任意机器能跑。

1.2 可控优先,速率和并发必须可调

这是 SRC 合规底线。脚本必须支持通过命令行参数或配置文件设置:

  • 并发数(默认小值,如 5~10)
  • 请求速率(每秒请求数)
  • 超时时间
  • 是否跟随重定向
  • 代理

踩坑教训:很多人写完脚本,直接默认高并发跑全量资产,触发 WAF 封禁 IP,挖到漏洞也因测试行为违规被驳回。可控速率是脚本第一要求。

1.3 结果可控,清晰输出、便于筛选

脚本输出不要是一堆乱七八糟的原始响应,要结构化:

  • 命中目标 URL
  • HTTP 状态码
  • 响应标题 / 长度 / 关键词
  • 命中类型(.git、.env、接口返回业务数据等)

建议:结果写到一个 csv 或 txt,同时终端只打印关键命中信息,避免刷屏。

1.4 可复用,参数化、模块化

一个脚本不要写死 URL、写死字典。把目标列表、字典、请求头都做成参数或文件,方便换目标直接复用。

1.5 最小验证,脚本只做探测,不做利用

所有脚本输出的是 “候选”,绝不自动 getshell、绝不自动批量拉取数据、绝不写入、删除业务数据。这是 SRC 脚本的硬边界。

二、环境准备:最小依赖

推荐用 Python 3.8+,Linux 环境最佳。

# 安装依赖
pip3 install requests aiohttp asyncio
# 或者
pip3 install requests grequests

可选:fake-useragent(随机 UA)、tldextract(域名解析)等,按需安装。

基础请求函数模板,后续所有脚本复用:

import requests

def http_get(url, headers=None, timeout=8, allow_redirects=False, proxies=None):
    """通用GET请求,统一超时与UA"""
    default_headers = {
        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
        "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
        "Accept-Language": "zh-CN,zh;q=0.8,en-US;q=0.6,en;q=0.4",
    }
    if headers:
        default_headers.update(headers)
    try:
        resp = requests.get(
            url,
            headers=default_headers,
            timeout=timeout,
            allow_redirects=allow_redirects,
            proxies=proxies,
        )
        return resp
    except requests.exceptions.RequestException as e:
        return None

三、脚本 1:批量探测敏感目录 / 敏感文件(信息泄露 + 目录浏览)

这是最实用、最常用的挖洞脚本。目标:批量检测一批 URL 上是否存在.env、.git、备份文件、目录浏览等敏感路径。

3.1 场景分析

  • 输入:一批目标 URL(子域名、Web 站点)
  • 字典:精简的高命中率敏感路径字典(不是几万行大字典)
  • 输出:每个目标命中的敏感路径、状态码、页面特征

3.2 代码实现

import requests
import csv
import sys
import time

# 精简敏感路径字典,覆盖常见信息泄露与目录浏览
SENSITIVE_PATHS = [
    "/.git/HEAD",
    "/.svn/entries",
    "/.env",
    "/.DS_Store",
    "/backup.sql",
    "/db.sql",
    "/backup.zip",
    "/site.zip",
    "/backup.tar.gz",
    "/web.config.bak",
    "/index.php.bak",
    "/phpinfo.php",
    "/robots.txt",
    "/crossdomain.xml",
    "/composer.json",
    "/package.json",
    "/swagger-ui.html",
    "/v2/api-docs",
    "/.htaccess",
]

# 目录浏览判定关键词:页面出现 Index of / 说明开启目录列出
INDEX_OF_MARKERS = ["Index of /", "Index of", "Parent Directory"]

def http_get(url, timeout=8):
    try:
        resp = requests.get(url, timeout=timeout, allow_redirects=False,
                            headers={"User-Agent": "Mozilla/5.0"})
        return resp
    except requests.exceptions.RequestException:
        return None

def check_path(base_url, path):
    """探测单个路径,返回 (url, status, marker)"""
    url = base_url.rstrip("/") + path
    resp = http_get(url)
    if resp is None:
        return (url, None, "")
    status = resp.status_code
    text = resp.text[:2000] if resp.text else ""
    marker = ""
    # 目录浏览判定
    for m in INDEX_OF_MARKERS:
        if m in text:
            marker = "DIR_LIST"
            break
    # .git HEAD 命中:通常返回 "ref: refs/heads/main"
    if path.endswith("/.git/HEAD") and "ref:" in text:
        marker = "GIT_EXPOSED"
    # .env 命中:包含常见环境变量
    if path.endswith(".env") and any(k in text for k in ["DB_", "PASSWORD", "API_KEY", "SECRET", "APP_KEY"]):
        marker = "ENV_EXPOSED"
    return (url, status, marker)

def batch_scan(base_urls, paths, delay=0.2):
    results = []
    for base in base_urls:
        for path in paths:
            url, status, marker = check_path(base, path)
            if status is not None and status != 404 and status != 403:
                row = {"url": url, "status": status, "marker": marker}
                results.append(row)
                if marker:
                    print(f"[命中] {url} [{status}] [{marker}]")
            time.sleep(delay)  # 速率控制,SRC合规
    return results

def main():
    # 用法: python3 scan_sensitive.py target_list.txt
    if len(sys.argv) < 2:
        print("用法: python3 scan_sensitive.py <目标URL列表txt>")
        sys.exit(1)
    with open(sys.argv[1], "r", encoding="utf-8") as f:
        targets = [l.strip() for l in f if l.strip()]
    results = batch_scan(targets, SENSITIVE_PATHS, delay=0.2)
    # 导出结果
    with open("sensitive_result.csv", "w", newline="", encoding="utf-8") as f:
        writer = csv.DictWriter(f, fieldnames=["url", "status", "marker"])
        writer.writeheader()
        writer.writerows(results)
    print(f"扫描完成,共 {len(results)} 条命中,结果已保存到 sensitive_result.csv")

if __name__ == "__main__":
    main()

3.3 脚本要点讲解

  1. 字典精简:只放高命中率敏感路径,不放攻击 payload,减少误报、降低 WAF 风险;
  2. 状态码过滤:默认过滤 404、403,保留 200 等有效命中;
  3. 特征判定:根据返回内容打标DIR_LIST(目录浏览)、GIT_EXPOSED、ENV_EXPOSED,方便人工快速分类定级;
  4. 速率控制:delay=0.2,每秒约 5 个请求,SRC 合规;
  5. 结果导出:csv 结构化,方便后续审计。

3.4 踩坑与优化

  • 很多站点默认首页返回 200(假页面),需要根据响应长度 / 特征二次过滤,例如所有 URL 返回相同长度的 200,多半是 CDN 假页面,要人工核验;
  • .env、.git这类文件,很多站点返回 200 但内容为空或 404 页面,需要结合内容特征判断;
  • 目录浏览经常被 WAF 拦截返回 403,不要误判为 “无漏洞”,要人工复查;
  • 对超大目标列表,建议把目标拆分成小批次跑,避免一次跑太多被限流。

四、脚本 2:批量检测接口存活与业务特征(接口枚举)

挖接口,是 SRC 业务逻辑挖洞的起点。自己写脚本批量检测接口,核心目标:

  1. 快速判断哪些接口存活(200);
  2. 区分接口返回类型(JSON 数据 / 报错 / 登录跳转 / 未授权);
  3. 找出 “返回业务数据” 的接口,作为后续未授权 / 越权测试候选。

4.1 场景

已知一个站点根路径,需要枚举常见业务接口,判断哪些是真实业务接口。
输入:目标 URL + 接口路径字典
输出:每个接口的存活状态、返回类型、是否返回业务数据。

4.2 代码实现

import requests
import csv
import sys
import json

API_PATHS = [
    "/api/v1/user/info",
    "/api/v1/user/list",
    "/api/v1/order/list",
    "/api/v1/order/detail",
    "/api/user/getInfo",
    "/api/admin/user/list",
    "/api/common/config",
    "/api/file/list",
    "/api/auth/check",
    "/actuator",
    "/actuator/health",
    "/swagger-ui.html",
    "/v2/api-docs",
]

def classify_response(resp):
    """根据响应特征分类返回类型"""
    if resp is None:
        return "NO_RESPONSE"
    status = resp.status_code
    content_type = resp.headers.get("Content-Type", "")
    text = resp.text or ""
    if "application/json" in content_type or text.strip().startswith("{"):
        # 尝试解析JSON,判断是否业务数据
        try:
            data = json.loads(text)
            return "JSON_BUSINESS"
        except:
            return "JSON"
    if status == 200:
        return "HTML_200"
    if status in (301, 302):
        return "REDIRECT"
    if status in (401,):
        return "UNAUTHORIZED"
    if status == 403:
        return "FORBIDDEN"
    if status in (404,):
        return "NOT_FOUND"
    return f"HTTP_{status}"

def main():
    if len(sys.argv) < 3:
        print("用法: python3 scan_api.py <目标URL列表txt> <接口路径字典txt>")
        sys.exit(1)
    with open(sys.argv[1], "r", encoding="utf-8") as f:
        bases = [l.strip() for l in f if l.strip()]
    with open(sys.argv[2], "r", encoding="utf-8") as f:
        paths = [l.strip() for l in f if l.strip()]

    results = []
    for base in bases:
        for path in paths:
            url = base.rstrip("/") + path
            resp = http_get(url, timeout=8)
            ctype = classify_response(resp)
            row = {"url": url,
                   "status": resp.status_code if resp else "",
                   "type": ctype,
                   "length": len(resp.text) if resp and resp.text else 0}
            results.append(row)
            # 只打印可能存活的业务接口
            if ctype in ("JSON_BUSINESS", "JSON", "HTML_200"):
                print(f"[{ctype}] {url} [{row['status']}] len={row['length']}")

    with open("api_result.csv", "w", newline="", encoding="utf-8") as f:
        writer = csv.DictWriter(f, fieldnames=["url", "status", "type", "length"])
        writer.writeheader()
        writer.writerows(results)
    print(f"接口检测完成,共 {len(results)} 条,结果已保存到 api_result.csv")

if __name__ == "__main__":
    main()

4.3 脚本价值

  1. 批量接口枚举:一次性把站点的常见接口路径跑一遍,标记存活;
  2. 业务特征分类:JSON_BUSINESS代表返回业务数据,是未授权 / 越权测试重点候选;
  3. 结果结构化:csv 保存每个接口的类型、长度,便于人工筛选高价值接口。

4.4 踩坑与优化

  • 接口路径字典要按业务定制,不同业务(SaaS、电商、社交)接口结构差异大,不要只依赖通用字典;
  • 很多接口需要 POST、JSON body,GET 可能返回 404,需要补充 POST 请求模式;
  • 接口返回 JSON 但内容是 “code”:404 或 “请登录”,需要二次判定是否为有效业务接口,不要只看 HTTP 状态码;
  • 注意接口路径不要包含admin等高价值关键字就盲目认定,要结合响应内容判断。

五、脚本 3:批量对比双账号会话,初筛水平越权接口(进阶核心)

这是把 “自己写脚本挖洞” 价值发挥到最大的脚本。SRC 越权挖洞的核心是双账号对比:账号 A 创建资源,用账号 B 的会话访问,判断是否越权。手工一个个接口点太慢,写脚本批量初筛,能快速定位高价值越权候选。

5.1 场景

  • 已注册账号 A、账号 B(同权限普通账号)
  • 拿到账号 A、B 的 Cookie/Token
  • 批量测试一批接口:用账号 B 的 Cookie,带上账号 A 的资源 ID,判断是否返回账号 A 的数据

合规红线:脚本只做初筛,只取少量 ID 做验证,绝不批量遍历大量用户 ID,绝不批量拉取数据。

5.2 代码思路

import requests
import csv

# 测试用例:接口URL + 参数中资源ID的位置
# 这里演示最简单场景:接口接受 id 参数
TEST_CASES = [
    {"url": "/api/v1/order/detail", "params": {"id": "<A_RESOURCE_ID>"}},
    {"url": "/api/v1/user/getInfo", "params": {"uid": "<A_UID>"}},
    {"url": "/api/file/download", "params": {"fileId": "<A_FILE_ID>"}},
]

def make_request(url, params, cookie, base_url):
    full_url = base_url.rstrip("/") + url
    resp = requests.get(full_url, params=params, cookies=cookie, timeout=8,
                        headers={"User-Agent": "Mozilla/5.0"})
    return resp

def compare_session(base_url, cookie_a, cookie_b, a_resources):
    """a_resources: {接口索引: {A账号资源ID}}"""
    results = []
    for i, tc in enumerate(TEST_CASES):
        url = tc["url"]
        # 用A的Cookie请求A自己的资源,确认A能访问(基准)
        resp_a = make_request(url, tc["params"], cookie_a, base_url)
        # 用B的Cookie请求A的资源,判断是否越权
        resp_b = make_request(url, tc["params"], cookie_b, base_url)

        # 判定:B的响应是否返回了业务数据(A的资源内容)
        suspect = False
        if resp_b.status_code == 200 and resp_b.text and "code" in resp_b.text:
            # 简单特征:B拿到200且返回业务JSON,疑似越权(需人工核验)
            suspect = True
        results.append({
            "url": url,
            "resp_a_status": resp_a.status_code if resp_a else "",
            "resp_b_status": resp_b.status_code if resp_b else "",
            "resp_b_len": len(resp_b.text) if resp_b and resp_b.text else 0,
            "suspect": suspect,
        })
    return results

# 说明:完整脚本需读取A、B账号Cookie、资源ID,此处为演示框架

5.3 脚本价值与重要提醒

这个脚本的核心价值:把 “双账号对比” 从手工变成自动化初筛,快速找出 “B 账号能访问 A 账号资源” 的接口候选,然后人工重点核验。

极其重要的合规红线(再次强调):

  1. 禁止脚本循环遍历大量 ID、批量拉取用户数据,这是 SRC 最高频违规点;
  2. 脚本只对有限的、自己可控的测试资源(自己注册账号创建的资源)做对比;
  3. 初筛出的嫌疑接口,必须人工逐个核验,确认确实是越权,而不是误报;
  4. 测试产生的脏数据要清理,修改类接口测试后要恢复。

这个脚本方向本身是对的,但也是最容易 “踩爆雷” 的脚本。如果写成 “遍历 1 万个 ID 批量拉手机号”,就直接从 “挖洞辅助” 变成了 “非法数据获取”,务必守住边界。

六、提速方案:多线程 / 协程并发探测(带速率控制)

批量探测时,同步请求速度慢。可以用concurrent.futures线程池或asyncio协程提速,同时严格限制并发数。

6.1 线程池方式(简单,适合 requests)

from concurrent.futures import ThreadPoolExecutor
import requests

def worker(base, path):
    url = base.rstrip("/") + path
    try:
        resp = requests.get(url, timeout=8, headers={"User-Agent": "Mozilla/5.0"})
        return (url, resp.status_code, len(resp.text or ""))
    except:
        return (url, None, 0)

def batch_with_threads(bases, paths, max_workers=10):
    tasks = []
    for base in bases:
        for path in paths:
            tasks.append((base, path))
    results = []
    with ThreadPoolExecutor(max_workers=max_workers) as pool:
        for res in pool.map(lambda t: worker(t[0], t[1]), tasks):
            results.append(res)
    return results

关键:max_workers=10,不要开到 100+,否则等同压测,触发 WAF 封禁。

6.2 协程方式(asyncio + aiohttp,更高并发但更复杂)

import asyncio
import aiohttp

async def fetch(session, url, sem):
    async with sem:
        try:
            async with session.get(url, timeout=8) as resp:
                text = await resp.text()
                return (url, resp.status, len(text))
        except:
            return (url, None, 0)

async def main(bases, paths, concurrency=20):
    sem = asyncio.Semaphore(concurrency)  # 信号量控制并发
    async with aiohttp.ClientSession() as session:
        tasks = []
        for base in bases:
            for path in paths:
                url = base.rstrip("/") + path
                tasks.append(fetch(session, url, sem))
        results = await asyncio.gather(*tasks)
    return results

并发通过Semaphore严格控制在concurrency以内,默认给 20,不贪快。

提速的核心原则:提速靠并发,安全靠限流。 并发再高,也必须用信号量 / 线程数 /rate 限住,这是 SRC 合规底线。

七、请求头伪装与反检测(适度,不做对抗)

SRC 场景,请求头伪装的目标不是对抗 WAF 绕过(那属于另一层面),而是让探测请求更像正常浏览器访问,减少误伤、减少被 CDN 风控误判。

基础伪装要点:

  1. 随机或固定合理的 User-Agent(不要用 Python-requests 默认 UA);
  2. 带上 Accept、Accept-Language、Referer 等常见头;
  3. 部分站点要求带 Cookie 才能访问,脚本支持传入 Cookie;
  4. 遇到需要登录的接口,先登录拿到会话,脚本携带会话 Cookie。

适度即可,不要写 “绕过 WAF” 的反检测对抗脚本,那超出了 SRC 正常测试范畴,且容易违规。SRC 要求的是正常、低速率、最小验证的探测,不是隐蔽攻击。

八、结果去重、误报过滤、结构化整理

批量脚本跑完,会产生大量结果,直接看会疯掉。需要去重和误报过滤。

8.1 去重

同一个 URL / 域名可能在多轮扫描中重复出现,脚本统一去重:

def dedup(results, key="url"):
    seen = set()
    uniq = []
    for r in results:
        k = r[key]
        if k not in seen:
            seen.add(k)
            uniq.append(r)
    return uniq

8.2 误报过滤规则

  1. 过滤 CDN 假页面:同一响应长度、内容完全相同的 200 页面,多半是 CDN/WAF 假页面;
  2. 过滤 404 页面返回 200:很多站点 404 也返回 200,需要结合内容判断;
  3. 过滤 “请登录”“Forbidden” 提示页:可能是正常鉴权,不是漏洞;
  4. 目录浏览要人工确认是真正列文件,不是普通页面。

脚本能做的是初筛 + 标注,最终误报过滤和漏洞确认,必须人工完成。脚本辅助的价值是把海量请求缩到几十个可疑候选。

8.3 结果整理

统一导出 csv/markdown,字段清晰:URL、状态码、类型、特征标记、长度、备注。

import csv
with open("final_result.csv", "w", newline="", encoding="utf-8") as f:
    writer = csv.DictWriter(f, fieldnames=["url", "status", "type", "marker", "len", "note"])
    writer.writeheader()
    writer.writerows(dedup_results)

九、脚本合规红线(SRC 挖洞脚本必须遵守,重中之重)

写挖洞脚本、跑挖洞脚本,最容易出问题的不是技术,而是合规。列出脚本必须遵守的红线,一旦违反,轻则工单驳回,重则账号封禁、法律风险。

  1. 只扫 SRC 授权资产:脚本目标列表,必须来自厂商 SRC 公示 Scope,禁止脚本随机爬全网资产;
  2. 禁止批量遍历用户 ID / 资源 ID:越权对比脚本,只对有限、自己可控的资源做验证,禁止循环遍历上万 ID 批量拉取用户隐私;
  3. 禁止批量拉取业务数据:探测到敏感文件,只确认可访问,禁止脚本自动下载备份、拖库、拉取数据库内容;
  4. 禁止高并发压测:所有脚本必须限并发、限速率,禁止 7×24 小时狂暴发包压测线上业务;
  5. 禁止自动化 getshell / 持久化:脚本只做探测和初筛,绝不做漏洞利用、写后门、创建账号;
  6. 禁止自动提交、自动撞洞:脚本结果只是候选,必须人工核验、人工判断是否提交,禁止脚本自动批量提交工单(会造成大量误报工单,严重损害账号信誉);
  7. 测试脏数据要清理:修改类接口测试后恢复原始数据;
  8. 漏洞未修复前禁止对外泄露:脚本结果、漏洞点位不要公开发布。

一句话总结脚本红线:脚本只负责 “发现可疑点”,人工负责 “确认漏洞” 和 “提交报告”。 脚本绝不自作主张去做利用和破坏。

十、完整工作流串联:脚本 + 人工的标准挖洞流水线

自己写脚本,最终要融入一套可复用的 SRC 挖洞流水线:

  1. 资产清单准备:确认 SRC Scope,整理目标 URL 列表(脚本输入);
  2. 批量敏感目录探测:脚本 1 跑一遍,输出敏感路径命中候选;
  3. 批量接口枚举:脚本 2 跑一遍,输出存活业务接口候选;
  4. 高价值接口双账号对比:脚本 3 针对存活接口初筛越权候选;
  5. 人工核验:逐个访问候选 URL,确认漏洞真实存在,收集请求包 + 响应包证据;
  6. 取证与报告:Burp 流量包 + 截图,撰写 SRC 报告;
  7. 提交工单:人工审核无误后提交。

整个流程中,脚本承担 “脏活累活”(批量探测、批量对比),人工承担 “决策”(确认漏洞、定级、取证、提交)。脚本提升的是效率,不是替代人工判断。

十一、踩坑复盘(真实 SRC 脚本挖洞高频翻车点)

坑 1:脚本默认高并发,跑崩了还触发封禁

白帽写目录扫描脚本,默认线程 50+,跑几十个站点,大量 404 请求,触发 WAF 封禁 IP,后续所有扫描失败。挖到的漏洞,评审核查访问日志,判定测试行为违规,工单驳回。

教训:脚本第一参数必须是并发限制,默认给最小值。

坑 2:越权对比脚本,批量遍历 ID 拉用户数据

白帽写越权初筛脚本,直接循环 1~10000 遍历 orderId,批量拉取用户订单、手机号,提交报告附大量隐私截图。

后果:SRC 判定违规,报告驳回,严重限制账号。越权初筛只对有限、可控资源验证。

坑 3:脚本自动提交工单,刷出大量误报

部分白帽想 “自动化挖洞 + 自动提交”,脚本批量跑完后直接自动生成工单提交。结果大量误报、假漏洞工单,评审大量驳回,账号信誉分暴跌,甚至被限制提交。

教训:脚本结果必须人工核验后手动提交,禁止脚本自动批量提交。

坑 4:请求头默认 Python-requests UA,被 CDN 识别

脚本使用默认 UA,大量请求被 CDN 识别为扫描,返回假页面,影响结果准确性。

教训:脚本统一设置合理 UA、Accept 头。

坑 5:404 返回 200,误报大量 “漏洞”

很多站点 404 页面返回 200 状态码,脚本把 404 当成命中,产生大量误报。

教训:结合响应内容特征过滤,不要只看状态码。

坑 6:脚本写死字典、写死 URL,无法复用

脚本针对一个目标写死,换目标全部重写。

教训:目标、字典、Cookie、并发全部参数化,做成文件输入,提高复用性。

十二、代码规范与复用建议

自己写挖洞脚本,建议形成自己的 “脚本工具箱”,统一规范:

  1. 统一入口:每个脚本支持--help,说明用法、参数;
  2. 统一配置:目标、字典、Cookie、代理、并发集中在一个 config.py 或参数文件;
  3. 统一请求封装:所有脚本复用同一个 http 请求模块,统一 UA、超时、代理;
  4. 统一结果输出:统一 csv/markdown 格式,带状态码、类型、特征、长度、备注;
  5. 代码可读:加注释,关键逻辑说明清楚,方便复用和二次开发;
  6. 版本管理:用 git 管理自己的脚本库,持续积累。

推荐脚本库结构:

src_scripts/
├── config.py            # 统一配置(并发、UA、代理)
├── http_client.py       # 统一请求封装
├── scan_sensitive.py    # 敏感目录/文件探测
├── scan_api.py          # 接口枚举检测
├── compare_priv.py      # 双账号越权初筛
├── wordlists/
│   ├── sensitive.txt    # 敏感路径字典
│   └── api_paths.txt    # 接口字典
└── results/             # 扫描结果输出

十三、脚本挖洞的边界与局限

自己写脚本挖洞,不是万能的,有明确的边界:

  1. 脚本只能做信息收集、初筛、批量对比,无法替代人工深度业务理解;
  2. 业务逻辑越权、复杂流程漏洞,脚本很难覆盖,需要人工梳理;
  3. 脚本无法理解业务语义,误报需要人工大量过滤;
  4. 写脚本本身需要时间,简单小目标直接用工具可能更快;
  5. 脚本自动化批量探测,一旦失控(高并发、批量遍历)风险极高。

定位:脚本是辅助工具,提升批量探测效率,让白帽把时间花在 “理解业务、确认漏洞、写报告” 这些机器做不了的高价值环节。不要幻想 “写个脚本自动挖漏洞自动拿赏金”,那既不现实,也极易违规。

十四、结语

自己写简单 Python 脚本辅助 SRC 挖洞,是白帽从 “只会点工具” 进阶到 “理解挖洞方法论” 的重要一步。脚本的价值,不在于替代专业工具,而在于贴合自己的挖洞思路,把批量、重复、定制化的探测逻辑自动化,让脚本处理脏活累活,人工专注漏洞确认与报告提交。

本文从零搭建了一套实用的挖洞脚本体系:批量敏感目录探测、批量接口枚举、双账号越权初筛,覆盖了 SRC 挖洞最核心的批量探测场景。每段代码都强调可控速率、结构化输出、最小验证三个原则,这是 SRC 合规挖洞的底线。

同时必须反复强调合规红线:脚本只做 “发现可疑点”,人工负责 “确认漏洞”;禁止批量遍历用户 ID、禁止批量拉取数据、禁止高并发压测、禁止脚本自动利用和自动提交。一旦脚本越界,从 “挖洞辅助工具” 变成 “违规工具”,轻则工单驳回,重则账号封禁、触犯法律。

写脚本的过程,也是梳理自己挖洞方法论的过程。持续积累自己的脚本工具箱,把每一次成功探测、每一次踩坑都沉淀成可复用的代码,长期来看,能明显提升 SRC 挖洞效率和产出稳定性,让批量探测这件 “脏活累活” 变得可控、高效、合规。


最后

关于网络安全技术储备

网络安全是当今信息时代中非常重要的一环。无论是找工作还是感兴趣(黑客),都是未来职业选择中上上之选,为了保护自己的网络安全,学习网络安全知识是必不可少的。

如果你是准备学习网络安全(黑客)或者正在学习,下面这些你应该能用得上:

①网络安全学习路线
②20份渗透测试电子书
③安全攻防357页笔记
④50份安全攻防面试指南
⑤安全红队渗透工具包
⑥网络安全必备书籍
⑦100个漏洞实战案例
⑧安全大厂内部视频资源
⑨历年CTF夺旗赛题解析

一、网络安全(黑客)学习路线

网络安全(黑客)学习路线,形成网络安全领域所有的知识点汇总,它的用处就在于,你可以按照上面的知识点去找对应的学习资源,保证自己学得较为全面。

在这里插入图片描述

二、网络安全教程视频

我们在看视频学习的时候,不能光动眼动脑不动手,比较科学的学习方法是在理解之后运用它们,这时候练手项目就很适合了。

三、网络安全CTF实战案例

光学理论是没用的,要学会跟着一起敲,要动手实操,才能将自己的所学运用到实际当中去,这里带来的是CTF&SRC资料&HW资料,毕竟实战是检验真理的唯一标准嘛~

img

四、网络安全面试题

最后,我们所有的作为都是为就业服务的,所以关键的临门一脚就是咱们的面试题内容,所以面试题板块是咱们不可或缺的部分,这里我给大家准备的就是我在面试期间准备的资料。

在这里插入图片描述

网安其实不难,难的是坚持和相信自己,我的经验是既然已经选定网安你就要相信它,相信它能成为你日后进阶的高效渠道,这样自己才会更有信念去学习,才能在碰到困难的时候坚持下去。

机会属于有准备的人,这是一个实力的时代。人和人之间的差距不在于智商,而在于如何利用业余时间,只要你想学习,什么时候开始都不晚,不要担心这担心那,你只需努力,剩下的交给时间!

这份完整版的网络安全学习资料已经上传优快云,朋友们如果需要可以微信扫描下方优快云官方认证二维码免费领取【保证100%免费】

img

评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值