上一篇文章，我们用爬虫实现了XSS漏洞的自动化探测，帮大家搞定了src入门必挖的通用型漏洞，很多粉丝跑通脚本后，都挖到了自己的第一个src漏洞，后台私信全是催更的，问的最多的就是：有没有办法自动化挖越权漏洞？
太懂这种需求了。做过src挖洞的人都知道，越权漏洞绝对是src的重灾区、高分大户：在各大平台的漏洞公告里，越权漏洞常年占比超30%，随便一个有效越权都是中高危起步，几十积分直接到手，是挖洞人冲榜、拿认证的核心漏洞类型。
但越权漏洞最折磨人的地方也很明显：
- 现成扫描器基本扫不出来：越权是业务逻辑漏洞，没有固定的payload和特征，扫描器只会扫通用漏洞，根本理解不了网站的业务权限逻辑，扫一晚上也出不来一个有效结果；
- 手动测试效率极低：要开好几个浏览器，登N个测试账号，一个个接口改参数、换Cookie，几百个业务接口测下来，几天时间就没了，还很容易漏掉关键接口；
- 新手根本无从下手：分不清平行越权和垂直越权，不知道该选什么接口做测试用例，改了参数也不知道怎么判断漏洞是否存在，测了半个月一个洞都挖不到，越测越没信心。
我刚入门挖src的时候，在越权上踩了无数坑：曾经为了测一个电商网站的用户中心，开了5个测试账号，手动测了200多个接口，熬了两个通宵，结果漏掉了最关键的订单查询越权，看着别人提交的高危漏洞公告，悔得肠子都青了。
后来我把越权测试的核心逻辑拆解开来，用爬虫实现了自动化检测，才彻底解放了双手：原来手动测3天的网站，现在脚本10分钟就能跑完，还能不漏掉任何一个权限接口，挖洞效率直接翻了百倍。
今天这篇文章，我就带你从零开发一套越权漏洞自动化检测爬虫，保姆级逐行讲解，新手复制粘贴就能在靶场跑通，直接拥有自己的业务漏洞批量挖洞神器。
合规红线再次焊死：本文所有实战均在本地搭建的开源靶场中完成，仅用于网络安全技术学习交流。严禁在未经目标方书面授权的情况下，对任何公网网站、系统、服务器进行探测、测试、攻击行为，《网络安全法》《数据安全法》《刑法》第285/286条的合规红线，务必时刻牢记。
核心原理精讲：搞懂越权本质，自动化就成功了一半
先给所有新手把底层逻辑讲透，越权漏洞从来不是什么高深的技术，本质就是一句话：网站的后端接口没有做严格的权限校验，只靠前端页面做了权限限制，导致用户可以访问/操作不属于自己权限范围内的数据和功能。
我们挖洞最常接触的，就是两类核心越权漏洞，也是我们爬虫重点检测的目标，用一张表给你讲得明明白白：
| 漏洞类型 | 核心定义 | 典型业务场景 | src常见评级 |
|---|---|---|---|
| 平行越权（水平越权） | 同权限等级的用户，可访问/操作其他同角色用户的专属数据 | A用户查看B用户的订单、身份证信息、收货地址，修改他人账号密码 | 中危~高危，评级由泄露数据的敏感程度决定 |
| 垂直越权 | 低权限用户，可访问/操作高权限用户的专属功能与数据 | 普通用户访问管理员后台、添加管理员账号、修改全站配置、查看全平台用户数据 | 高危~严重，基本都是src高分漏洞 |
爬虫自动化检测越权的4步核心逻辑
为什么工具扫不出来的越权，我们自己写的爬虫能精准识别？核心就是我们把手动测试的完整逻辑，拆解成了爬虫可执行的步骤，完全贴合业务权限逻辑，误报率极低：
- 多身份会话保持：用爬虫模拟不同权限的用户（普通用户A、普通用户B、管理员），分别完成登录，保留各自的会话Cookie，相当于同时开了多个浏览器，登了不同账号；
- 全站权限接口爬取：自动爬取网站所有需要登录才能访问的接口、页面、带参数的查询接口，过滤掉静态资源、公开页面等无效内容，只保留核心测试目标；
- 交叉权限测试 ：
- 平行越权检测：用普通用户A的会话，去请求普通用户B的专属数据接口，模拟"用A的账号看B的隐私"；
- 垂直越权检测：用普通用户的会话，去请求管理员专属的后台接口，模拟"用普通账号进管理员后台"；
- 精准漏洞验证：不单纯看状态码，而是通过响应内容的关键词、返回数据、页面差异，判断是否成功越权，彻底过滤误报，输出精准的漏洞结果。
保姆级实战开发：从零打造越权自动化检测爬虫
前置环境准备
和我们前序教程的环境完全兼容，不用额外安装复杂工具，新手零门槛：
- 本地搭建好的Pikachu/DVWA靶场（前序教程领取的靶场包直接就能用，本次用Pikachu的越权模块做实战）；
- 已安装Python环境，以及requests、BeautifulSoup4库；
- 基础命令行操作能力，复制粘贴即可运行。
步骤1：多身份会话模拟，自动登录保持权限
越权测试的第一步，就是同时保持多个不同权限用户的登录会话，不用我们手动复制Cookie，爬虫自动完成登录，保存会话状态，后续所有请求都用对应会话发送，完美模拟不同用户的访问行为。
python
import requests
from bs4 import BeautifulSoup
from urllib.parse import urlparse, urljoin
import time
# ====================== 配置区，新手仅需修改这里 ======================
# 靶场根地址，禁止替换为未授权的公网网站
base_url = "http://localhost/pikachu/"
# 多身份账号配置，对应靶场默认账号，可根据自己的靶场修改
user_config = {
"user_a": {"username": "lili", "password": "123456", "role": "normal"}, # 普通用户A
"user_b": {"username": "lucy", "password": "123456", "role": "normal"}, # 普通用户B
"admin": {"username": "admin", "password": "admin123", "role": "admin"} # 管理员用户
}
# 请求延迟，避免打崩靶场/被WAF拦截
request_delay = 0.2
# 权限拦截关键词，用于反向验证漏洞
forbidden_keywords = ["无权限", "请登录", "非法请求", "权限不足", "登录后访问"]
# ======================================================================
# 请求头，模拟浏览器访问
headers = {
"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36",
"Content-Type": "application/x-www-form-urlencoded"
}
# 核心函数1：自动登录，创建并返回用户会话
def create_user_session(login_path, username, password):
session = requests.Session()
login_url = urljoin(base_url, login_path)
# 先访问登录页，获取基础Cookie
session.get(login_url, headers=headers, timeout=10)
# 构造登录表单数据
login_data = {
"username": username,
"password": password,
"submit": "Login"
}
# 发送登录请求
session.post(login_url, data=login_data, headers=headers, timeout=10)
time.sleep(request_delay)
return session
# 初始化所有用户的会话
print("[+] 正在初始化多用户会话，自动登录中...")
# Pikachu越权模块登录地址，不同靶场修改对应登录路径即可
login_path = "vul/overpermission/op1/op1_login.php"
session_a = create_user_session(login_path, user_config["user_a"]["username"], user_config["user_a"]["password"])
session_b = create_user_session(login_path, user_config["user_b"]["username"], user_config["user_b"]["password"])
session_admin = create_user_session(login_path, user_config["admin"]["username"], user_config["admin"]["password"])
print("[+] 多用户会话初始化完成，已保持所有用户登录状态\n")步骤2：全站权限接口爬取，过滤无效内容
这一步是减少无效测试、提升效率的关键。我们让爬虫自动爬取网站所有页面，提取所有接口链接，过滤掉静态资源、公开页面，只保留需要登录才能访问的业务接口，也就是我们的核心测试目标。
python
# 核心函数2：判断页面是否需要登录才能访问
def is_need_login(url, session):
try:
response = session.get(url, headers=headers, timeout=10)
# 如果页面包含登录相关关键词，说明需要登录
for keyword in ["登录", "login", "用户名", "密码"]:
if keyword in response.text and len(response.text) < 2000:
return True
return False
except:
return False
# 核心函数3：爬取全站所有有效接口链接，去重并过滤无效内容
def crawl_all_urls(start_url, session, max_depth=2):
crawled_urls = set() # 已爬取的链接，去重
test_urls = set() # 最终需要测试的接口链接
urls_to_crawl = [(start_url, 0)] # 待爬取的链接和当前深度
# 静态资源后缀，直接过滤
static_suffix = [".js", ".css", ".png", ".jpg", ".jpeg", ".gif", ".ico", ".svg", ".woff", ".ttf"]
while urls_to_crawl:
current_url, depth = urls_to_crawl.pop(0)
# 超过最大深度、已经爬过的链接，直接跳过
if depth > max_depth or current_url in crawled_urls:
continue
try:
response = session.get(current_url, headers=headers, timeout=10)
crawled_urls.add(current_url)
soup = BeautifulSoup(response.text, "html.parser")
# 提取页面中所有的a标签链接
for a_tag in soup.find_all("a"):
href = a_tag.get("href")
if not href:
continue
# 拼接完整URL
full_url = urljoin(base_url, href)
# 只爬取当前域名下的链接
if urlparse(full_url).netloc != urlparse(base_url).netloc:
continue
# 过滤静态资源
if any(full_url.endswith(suffix) for suffix in static_suffix):
continue
# 加入待爬队列
if full_url not in crawled_urls:
urls_to_crawl.append((full_url, depth + 1))
# 判断是否是需要登录的接口，是则加入测试列表
if is_need_login(full_url, requests.Session()):
test_urls.add(full_url)
time.sleep(request_delay)
except:
continue
return list(test_urls)
# 启动全站接口爬取
print("[+] 正在爬取全站权限接口，过滤无效内容...")
test_urls = crawl_all_urls(base_url, session_a)
print(f"[+] 接口爬取完成，共获取到{len(test_urls)}个需要权限的测试接口\n")步骤3：平行越权自动化检测
这是src最常见的漏洞类型，核心逻辑就是：用用户A的会话，去请求用户B的专属数据接口，看能不能成功拿到B的隐私数据。
我们先提取用户A和用户B的专属数据标识（比如用户名、用户ID），然后替换接口中的参数，自动完成交叉测试，通过响应内容的关键词判断是否越权。
python
# 核心函数4：平行越权漏洞检测
def check_horizontal_auth(urls, session_owner, session_attacker, owner_info, attacker_info):
vuln_results = []
print("[+] 开始检测平行越权（水平越权）漏洞...")
# 提取用户专属标识，用于参数替换和漏洞验证
owner_username = owner_info["username"]
attacker_username = attacker_info["username"]
for url in urls:
try:
# 1. 先让所属用户正常访问，获取正常响应的内容和关键词
owner_response = session_owner.get(url, headers=headers, timeout=10)
owner_text = owner_response.text
# 如果所属用户都访问不到，直接跳过
if owner_response.status_code != 200 or any(keyword in owner_text for keyword in forbidden_keywords):
continue
# 2. 替换URL中的用户标识，构造越权测试URL（适配username/userid等常见参数）
test_url = url.replace(owner_username, attacker_username)
# 3. 用攻击者的会话，访问构造的越权URL
attacker_response = session_attacker.get(test_url, headers=headers, timeout=10)
attacker_text = attacker_response.text
# 4. 核心漏洞验证逻辑
# 正向验证：越权响应中包含目标用户的专属信息
# 反向验证：越权响应中没有权限拦截关键词
if (attacker_username in attacker_text
and owner_username not in attacker_text
and not any(keyword in attacker_text for keyword in forbidden_keywords)
and attacker_response.status_code == 200):
result = {
"type": "平行越权（水平越权）",
"url": test_url,
"original_url": url,
"attacker": attacker_username,
"target": owner_username,
"description": f"用户{attacker_username}可越权访问用户{owner_username}的专属数据"
}
vuln_results.append(result)
print(f"[!] 发现{result['type']}漏洞")
print(f" 原始接口：{url}")
print(f" 越权接口：{test_url}")
print(f" 漏洞描述：{result['description']}\n")
time.sleep(request_delay)
except:
continue
return vuln_results步骤4：垂直越权自动化检测
这是src的高分高危漏洞，核心逻辑就是：用普通用户的会话，去请求管理员专属的后台接口，看能不能成功访问、拿到管理员权限的内容。
python
# 核心函数5：垂直越权漏洞检测
def check_vertical_auth(urls, session_normal, session_admin):
vuln_results = []
print("[+] 开始检测垂直越权漏洞...")
# 管理员页面专属关键词，用于验证是否成功访问管理员内容
admin_keywords = ["管理员", "admin", "后台管理", "用户管理", "系统设置", "权限管理"]
for url in urls:
try:
# 1. 先让管理员正常访问，确认是管理员专属接口
admin_response = session_admin.get(url, headers=headers, timeout=10)
admin_text = admin_response.text
# 如果不是管理员页面，直接跳过
if admin_response.status_code != 200 or not any(keyword in admin_text for keyword in admin_keywords):
continue
# 2. 用普通用户的会话，访问管理员接口
normal_response = session_normal.get(url, headers=headers, timeout=10)
normal_text = normal_response.text
# 3. 核心漏洞验证逻辑
if (any(keyword in normal_text for keyword in admin_keywords)
and not any(keyword in normal_text for keyword in forbidden_keywords)
and normal_response.status_code == 200):
result = {
"type": "垂直越权",
"url": url,
"description": "普通用户可越权访问管理员专属后台接口"
}
vuln_results.append(result)
print(f"[!] 发现{result['type']}漏洞")
print(f" 漏洞接口：{url}")
print(f" 漏洞描述：{result['description']}\n")
time.sleep(request_delay)
except:
continue
return vuln_results步骤5：整合完整脚本，一键启动扫描
把上面所有功能整合起来，做成一个完整可运行的脚本，新手只需要修改配置区的靶场地址和账号信息，就能直接运行，自动完成全流程检测，输出完整的漏洞报告。
python
import requests
from bs4 import BeautifulSoup
from urllib.parse import urlparse, urljoin
import time
# ====================== 配置区，新手仅需修改这里 ======================
# 靶场根地址，禁止替换为未授权的公网网站
base_url = "http://localhost/pikachu/"
# 多身份账号配置，对应靶场默认账号，可根据自己的靶场修改
user_config = {
"user_a": {"username": "lili", "password": "123456", "role": "normal"}, # 普通用户A
"user_b": {"username": "lucy", "password": "123456", "role": "normal"}, # 普通用户B
"admin": {"username": "admin", "password": "admin123", "role": "admin"} # 管理员用户
}
# 登录页面路径，不同靶场修改对应路径
login_path = "vul/overpermission/op1/op1_login.php"
# 请求延迟，避免打崩靶场/被WAF拦截
request_delay = 0.2
# 权限拦截关键词，用于反向验证漏洞
forbidden_keywords = ["无权限", "请登录", "非法请求", "权限不足", "登录后访问"]
# 管理员页面专属关键词
admin_keywords = ["管理员", "admin", "后台管理", "用户管理", "系统设置", "权限管理"]
# ======================================================================
# 请求头，模拟浏览器访问
headers = {
"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36",
"Content-Type": "application/x-www-form-urlencoded"
}
# 核心函数1：自动登录，创建并返回用户会话
def create_user_session(login_path, username, password):
session = requests.Session()
login_url = urljoin(base_url, login_path)
try:
session.get(login_url, headers=headers, timeout=10)
login_data = {"username": username, "password": password, "submit": "Login"}
session.post(login_url, data=login_data, headers=headers, timeout=10)
time.sleep(request_delay)
return session
except Exception as e:
print(f"[-] 用户{username}登录失败：{str(e)}")
return None
# 核心函数2：判断页面是否需要登录才能访问
def is_need_login(url, session):
try:
response = session.get(url, headers=headers, timeout=10)
for keyword in ["登录", "login", "用户名", "密码"]:
if keyword in response.text and len(response.text) < 2000:
return True
return False
except:
return False
# 核心函数3：爬取全站所有有效接口链接，去重并过滤无效内容
def crawl_all_urls(start_url, session, max_depth=2):
crawled_urls = set()
test_urls = set()
urls_to_crawl = [(start_url, 0)]
static_suffix = [".js", ".css", ".png", ".jpg", ".jpeg", ".gif", ".ico", ".svg", ".woff", ".ttf"]
while urls_to_crawl:
current_url, depth = urls_to_crawl.pop(0)
if depth > max_depth or current_url in crawled_urls:
continue
try:
response = session.get(current_url, headers=headers, timeout=10)
crawled_urls.add(current_url)
soup = BeautifulSoup(response.text, "html.parser")
for a_tag in soup.find_all("a"):
href = a_tag.get("href")
if not href:
continue
full_url = urljoin(base_url, href)
if urlparse(full_url).netloc != urlparse(base_url).netloc:
continue
if any(full_url.endswith(suffix) for suffix in static_suffix):
continue
if full_url not in crawled_urls:
urls_to_crawl.append((full_url, depth + 1))
if is_need_login(full_url, requests.Session()):
test_urls.add(full_url)
time.sleep(request_delay)
except:
continue
return list(test_urls)
# 核心函数4：平行越权漏洞检测
def check_horizontal_auth(urls, session_owner, session_attacker, owner_info, attacker_info):
vuln_results = []
owner_username = owner_info["username"]
attacker_username = attacker_info["username"]
for url in urls:
try:
owner_response = session_owner.get(url, headers=headers, timeout=10)
owner_text = owner_response.text
if owner_response.status_code != 200 or any(keyword in owner_text for keyword in forbidden_keywords):
continue
test_url = url.replace(owner_username, attacker_username)
attacker_response = session_attacker.get(test_url, headers=headers, timeout=10)
attacker_text = attacker_response.text
if (attacker_username in attacker_text
and owner_username not in attacker_text
and not any(keyword in attacker_text for keyword in forbidden_keywords)
and attacker_response.status_code == 200):
result = {
"type": "平行越权（水平越权）",
"url": test_url,
"original_url": url,
"attacker": attacker_username,
"target": owner_username,
"description": f"用户{attacker_username}可越权访问用户{owner_username}的专属数据"
}
vuln_results.append(result)
print(f"[!] 发现{result['type']}漏洞")
print(f" 原始接口：{url}")
print(f" 越权接口：{test_url}")
print(f" 漏洞描述：{result['description']}\n")
time.sleep(request_delay)
except:
continue
return vuln_results
# 核心函数5：垂直越权漏洞检测
def check_vertical_auth(urls, session_normal, session_admin):
vuln_results = []
for url in urls:
try:
admin_response = session_admin.get(url, headers=headers, timeout=10)
admin_text = admin_response.text
if admin_response.status_code != 200 or not any(keyword in admin_text for keyword in admin_keywords):
continue
normal_response = session_normal.get(url, headers=headers, timeout=10)
normal_text = normal_response.text
if (any(keyword in normal_text for keyword in admin_keywords)
and not any(keyword in normal_text for keyword in forbidden_keywords)
and normal_response.status_code == 200):
result = {
"type": "垂直越权",
"url": url,
"description": "普通用户可越权访问管理员专属后台接口"
}
vuln_results.append(result)
print(f"[!] 发现{result['type']}漏洞")
print(f" 漏洞接口：{url}")
print(f" 漏洞描述：{result['description']}\n")
time.sleep(request_delay)
except:
continue
return vuln_results
# 主函数：启动全流程扫描
def main():
print("="*70)
print("越权漏洞自动化检测爬虫启动中...")
print(f"目标靶场：{base_url}")
print("="*70 + "\n")
# 1. 初始化多用户会话
session_a = create_user_session(login_path, user_config["user_a"]["username"], user_config["user_a"]["password"])
session_b = create_user_session(login_path, user_config["user_b"]["username"], user_config["user_b"]["password"])
session_admin = create_user_session(login_path, user_config["admin"]["username"], user_config["admin"]["password"])
if not session_a or not session_b or not session_admin:
print("[-] 用户登录失败，请检查账号密码和登录路径配置")
return
# 2. 爬取全站测试接口
test_urls = crawl_all_urls(base_url, session_a)
if len(test_urls) == 0:
print("[-] 未获取到有效测试接口，请检查靶场地址配置")
return
# 3. 启动越权检测
horizontal_vulns = check_horizontal_auth(test_urls, session_a, session_b, user_config["user_a"], user_config["user_b"])
vertical_vulns = check_vertical_auth(test_urls, session_a, session_admin)
# 4. 输出最终漏洞报告
all_vulns = horizontal_vulns + vertical_vulns
print("="*70)
print("扫描完成！最终漏洞汇总报告")
print(f"共检测接口：{len(test_urls)}个")
print(f"共发现漏洞：{len(all_vulns)}个")
print(f" - 平行越权漏洞：{len(horizontal_vulns)}个")
print(f" - 垂直越权漏洞：{len(vertical_vulns)}个")
print("="*70)
for i, vuln in enumerate(all_vulns):
print(f"\n漏洞{i+1}：{vuln['type']}")
print(f"漏洞接口：{vuln['url']}")
print(f"漏洞描述：{vuln['description']}")
print("漏洞评级：中高危" if vuln['type'] == "平行越权" else "漏洞评级：高危")
if __name__ == "__main__":
main()实战验证：靶场一键跑通，自动挖出高危越权漏洞
我们用Pikachu靶场的越权模块做实战验证，全程100%合法合规，新手跟着做就能拿到结果：
-
启动phpStudy，打开Pikachu靶场，确认越权模块的默认账号密码（lili/123456、lucy/123456）；
-
把脚本配置区的base_url、login_path、账号密码，和自己的靶场对应起来；
-
保存脚本为
auth_scanner.py，打开命令行运行：bashpython auth_scanner.py -
等待脚本自动完成登录、接口爬取、越权检测，最终输出完整的漏洞报告。
正常运行的输出结果示例：
======================================================================
越权漏洞自动化检测爬虫启动中...
目标靶场：http://localhost/pikachu/
======================================================================
[+] 正在初始化多用户会话，自动登录中...
[+] 多用户会话初始化完成，已保持所有用户登录状态
[+] 正在爬取全站权限接口，过滤无效内容...
[+] 接口爬取完成，共获取到12个需要权限的测试接口
[+] 开始检测平行越权（水平越权）漏洞...
[!] 发现平行越权（水平越权）漏洞
原始接口：http://localhost/pikachu/vul/overpermission/op1/op1_mem.php?username=lili
越权接口：http://localhost/pikachu/vul/overpermission/op1/op1_mem.php?username=lucy
漏洞描述：用户lucy可越权访问用户lili的专属数据
[+] 开始检测垂直越权漏洞...
[!] 发现垂直越权漏洞
漏洞接口：http://localhost/pikachu/vul/overpermission/op2/admin.php
漏洞描述：普通用户可越权访问管理员专属后台接口
======================================================================
扫描完成！最终漏洞汇总报告
共检测接口：12个
共发现漏洞：2个
- 平行越权漏洞：1个
- 垂直越权漏洞：1个
======================================================================
漏洞1：平行越权（水平越权）
漏洞接口：http://localhost/pikachu/vul/overpermission/op1/op1_mem.php?username=lucy
漏洞描述：用户lucy可越权访问用户lili的专属数据
漏洞评级：中高危
漏洞2：垂直越权
漏洞接口：http://localhost/pikachu/vul/overpermission/op2/admin.php
漏洞描述：普通用户可越权访问管理员专属后台接口
漏洞评级：高危你看，只用一个脚本，就自动完成了从多用户登录、接口爬取、交叉测试、漏洞验证的全流程，不用手动开多个浏览器、换Cookie、改参数，10分钟就能跑完手动3天的工作量，还能精准识别工具扫不出来的业务逻辑漏洞。
进阶技巧：降低误报、提升效率的核心方法
1. 接口去重与精准过滤
- 接口去重：很多接口只是参数值不同，路径完全一致，我们可以通过提取URL的路径部分（去掉参数）去重，避免重复测试同一个接口；
- 无效接口过滤：除了静态资源，还要过滤掉登出、注销、退出登录这类接口，避免测试过程中会话失效；
- 优先级排序：把带userid、orderid、username这类用户专属参数的接口，设为最高优先级，优先测试，这类接口出越权的概率超过80%。
2. 误报排除的核心技巧
新手最头疼的就是误报，这里给大家3个零误报的验证技巧：
- 双向对比验证：不仅要对比越权请求和正常请求的内容，还要对比未登录状态下的请求内容，只有越权请求能拿到专属数据，未登录请求拿不到，才判定为有效漏洞；
- 内容相似度校验：计算越权响应和正常响应的内容相似度，相似度超过80%，才判定为有效，避免因为页面通用内容导致的误报；
- 动态参数适配：很多接口的参数是数字ID（比如userid=1），而不是用户名，我们可以先爬取用户的ID列表，再做参数替换，避免因为参数替换错误导致的误报和漏报。
3. 复杂场景适配
针对POST接口的越权测试，我们可以在现有脚本的基础上，扩展表单自动提取功能，自动爬取POST表单的字段，替换表单中的用户标识参数，完成POST接口的越权测试，覆盖更多业务场景。
结尾福利 & 下期预告
恭喜你，看到这里，你已经掌握了越权漏洞的自动化检测方法，拥有了自己的业务漏洞批量挖洞神器，再也不用被工具扫不出来的越权漏洞折磨，也不用手动熬夜测接口了，挖洞效率直接碾压大部分脚本小子。
越权漏洞是src的高分大户，而接下来要讲的未授权访问漏洞，是最容易被忽略、也是一挖一个准的高危漏洞------很多后台、数据接口、管理页面，不用登录、不用Cookie，直接就能访问，现成工具基本扫不出来，但是一提交就是高危漏洞。
下一篇文章，我就带你用爬虫实现未授权访问漏洞的批量排查，教你搞定这个最容易被忽略的高危风险，让你的挖洞库再添一个神器。
粉丝互动引导
评论区说说你遇到的最离谱的越权漏洞，是改个ID就能看全平台用户信息，还是普通用户直接就能进管理员后台？分享出来，大家一起避坑，一起涨分。
网安之路，底线为先，实战为王。我们下一篇文章，不见不散。