从多线程爆破到优先级调度:Web漏洞扫描器的任务调度系统设计
解决"怎么高效、安全地扫描"这个问题
本文是《基于多样本一致性检测的Web漏洞扫描误报优化方法实践》的续篇,系列第二篇,本系列三篇完整覆盖扫描器标准化的工程落地。第一篇讲验证层——怎么判断漏洞是真是假;这篇讲调度层——请求怎么排队、怎么限速、怎么重试。第三篇先挖个坑,方向是基于响应一致性分析的连续评分体系——不再是简单的「已确认/未确认」二分,而是给每个发现打一个置信度分数。
一、引子:为什么需要调度层
先看一个经典的扫描器实现:
for payload in payloads:
resp = requests.get(url + payload)
if "error" in resp.text:
print("found")这段代码其实就是一个完整的"扫描器"——循环发payload,等响应,判断结果,下一个。
这类扫描器在实际跑的时候会陷入一个两难:并发开大了,目标直接断连或者WAF封IP;并发开小了,一个站点几千个参数、几万条payload,扫到天亮都跑不完。更麻烦的是,你正在跑SQLi的payload,结果发现参数存在XSS,这时候你想立刻验证,但前面还有几千个请求排队等着——等排到了,可能连响应报文都丢了。
为什么会出现这个问题?因为扫描任务已经不是 scan(url) 一个函数能解决的问题了。当你把 SQLi、XSS、SSRF、IDOR、资产发现这些检测逻辑拆成独立的插件,每个插件各自维护自己的检测逻辑,扫描器面对的就是一堆不同性质、不同生命周期、不同优先级的任务。插件化是调度存在的前提——调度器管的不是"某个漏洞类型的检测",而是 Plugin Task。
整体链路可以概括为:
Run
插件系统 → 产生Plugin Task → Scheduler调度 → 按优先级排队 → 限速/退避执行 → Verification验证这篇文章讲的就是中间这层——调度层怎么把这些Task安全高效地跑起来。
二、任务分层:为什么验证优先级最高
实战场景
前段时间测一个电商平台的订单接口,同时跑了 SQLi、XSS、SSRF 三个插件。突然日志里看到一个疑似 RCE 的回显——我赶紧想手动发个请求确认,但队列里还有 800 多个 payload 没发完。等它们跑完?黄花菜都凉了——目标说不定已经补了补丁,或者 WAF 开始拦截异常请求了。这就是为什么需要优先级:验证请求必须能插队。
大多数扫描器只有一种任务:发payload。这导致了前面说的"验证请求被大量检测请求阻塞"的问题。
WebHunter 把任务分成三个优先级:
Apply
class TaskPriority(IntEnum):
HIGH = 0 # 漏洞验证、请求重放
NORMAL = 1 # 插件扫描(SQLi/XSS/SSRF等)
LOW = 2 # 资产发现为什么验证(HIGH)的优先级最高?不是因为"漏洞验证很重要"这种正确但空洞的理由。
漏洞验证在扫描链路里承担的是收敛角色。前面的发现阶段和检测阶段产出的都是"候选结果"——这个参数可能存在SQLi,那个URL可能存在SSRF,但都是"可能"。验证阶段决定这些候选里哪些是真洞,哪些是误报。如果验证请求被大量NORMAL级别的检测请求堵在队列里出不去,扫描器就会积累大量"未闭环"的候选结果。这些结果既不能当漏洞上报,也不能直接丢弃,悬在半空中,整个扫描器的输出质量就卡在这里。
反过来看资产发现任务(LOW),它的特点是数量大、时效性低。发现阶段多扫出一个端点还是少扫出一个端点,对本次扫描的最终结论影响有限。即使被延迟甚至丢弃重排,也不会影响已发现漏洞的确认。
NORMAL 级别的插件扫描居中,是主力消耗资源的部分。SQLi、XSS、SSRF这些检测逻辑跑得最多,请求量最大。
出队逻辑很直接:
Apply
def pop(self):
for priority in (TaskPriority.HIGH, TaskPriority.NORMAL, TaskPriority.LOW):
if not self._queues[priority].is_empty():
task = self._queues[priority].pop()
return task
return None每次出队,先看HIGH队列有没有任务,有就优先处理,HIGH空了才取NORMAL,最后才是LOW。这个逻辑保证了:一旦检测阶段产出一个需要验证的候选,验证请求可以插队到最前面,不需要等后面几百个SQLi payload发完。
三、并发限速:优先级令牌加权 + 预留机制
实战场景
碰到过一个政府网站,WAF 配置很严,QPS 超过 30 就直接封 IP 24 小时。但问题是扫描任务里有大量 LOW 优先级的资产发现请求(扫目录、扫备份文件),如果这些低级任务把令牌吃光了,验证请求到达时只能干等,然后整个扫描器的输出质量就卡在半路上。关键是不能给 HIGH 单独开一个桶——那样架构就分裂了。
分层解决了优先级问题,但没解决压力问题。如果不同优先级的任务在限速层被一视同仁地限流,分层的意义就大打折扣。
大多数扫描器在这一层做的是全局QPS限制,所有请求共用一个限速器。这种做法的问题是:如果全局令牌被低优先级任务大量消耗,高优先级的验证请求到达时可能拿不到令牌,仍然需要等待。
WebHunter 的做法不是在限速层按优先级拆分独立资源池(比如给HIGH单独开一个桶),而是用优先级令牌加权 + 预留机制来实现差异化限速。
核心实现在 scheduler/rate_limiter.py。全局只有一个令牌桶:
Apply
class RateLimiter:
def __init__(self, qps=50.0, burst=None, cache_ttl=60.0,
reserve_high=True, high_reserve_pct=0.2):
self.bucket = TokenBucket(qps=qps, burst=burst) # 全局唯一一个桶
self.backoff = AdaptiveBackoff() # 域名级退避(内部按host分)
self.cache = RequestCache(ttl_sec=cache_ttl)不同优先级的任务消耗的令牌数不同:
Apply
PRIORITY_TOKENS = {
Priority.HIGH: 1, # 验证任务消耗最少token,最容易抢到
Priority.NORMAL: 2,
Priority.LOW: 4, # 发现任务消耗最多,天然被限制得最狠
}HIGH任务每次只消耗 1个令牌,NORMAL消耗 2个,LOW消耗 4个。在相同的令牌补充速率下,LOW任务的实际QPS只有HIGH的四分之一。
但这还不够——如果桶里只剩3个令牌,HIGH任务可以正常通过(只需1个),NORMAL任务可能刚好够(需要2个),LOW任务则直接被卡住(需要4个)。但如果桶里只剩1个令牌呢?HIGH任务也拿不到。
这个问题的解法是预留机制:
Apply
def acquire(self, host, priority=Priority.NORMAL, block=True):
# 第一步:域名级退避(下节展开)
delay = self.backoff.get_delay(host)
if delay > 0:
time.sleep(delay)
tokens = PRIORITY_TOKENS.get(priority, 2)
# 第二步:高优先级预留检查
if self._reserve_high and priority != Priority.HIGH:
reserved = self.bucket.burst * self._high_reserve_pct # 预留20%桶容量给HIGH
if self.bucket.available < tokens + reserved:
while self.bucket.available < tokens + reserved:
time.sleep(0.01) # NORMAL/LOW在这里被卡住等待
# 第三步:消耗令牌
return self.bucket.consume(count=tokens, block=block)逻辑拆开来是这样的:
- HIGH任务不触发预留检查,直接走 consume(1)——只要桶里至少有1个令牌就能通过。
- NORMAL/LOW任务在消耗令牌前,先检查"桶里剩余的令牌数"是否大于"本次消耗数 + 预留量"。预留量是桶容量的 20%(high_reserve_pct=0.2),这20%只给HIGH任务用。如果剩余量不够,NORMAL/LOW就在这里自旋等待,直到桶里有足够余额。
也就是说,即使桶里只剩20%的容量,HIGH任务仍然可以畅通无阻,而NORMAL/LOW任务必须等桶恢复到足够水位才能放行。
这个机制的价值在于:它把第二节讲的优先级模型延续到了限速层。不是在任务队列层面分完优先级就完事了,而是在网络请求的出口处再用令牌消耗量和预留额度做了一层差异化控制。两个层面的优先级策略是同一套设计思路的一致延伸。
另外要说明一个设计边界:当前架构是单目标深度扫描场景(Scanner.scan(target_url: str)接收单个URL),不是多目标并发测绘。因为一次扫描只针对一个目标,全局唯一令牌桶天然等价于"目标级"限速,不需要再按域名拆分。真正需要按域名(host)隔离的是退避层——下节展开。
四、域名级退避:为什么失败处理要按域名隔离
实战场景
实战中碰到过一个典型场景:扫描某目标时,api.example.com/login 接口持续返回 429,但 static.example.com 和 www.example.com 完全正常。如果只有一个全局退避计数器,整个站点的扫描都被拖慢——api 超载了,凭什么 static 的目录扫描也要跟着等?
限速是全局的,但退避是域名的——这两个设计在同一个 RateLimiter.acquire() 方法里是分两步执行的:先查域名退避状态,再走全局令牌桶。两者不是一回事,解决的问题也不同。
- 限速解决的是"不要让请求超过目标承受能力"
- 退避解决的是"目标某个服务已经出问题了,不要再继续加压"
如果一个扫描器只有一个全局退避计数器,那 api.example.com 超时5次后,整个扫描器的所有请求都会被拖慢——包括 www.example.com 和 static.example.com 的请求。这显然不合理。同一个站点下的不同子域名,背后的服务器、网络路径、限流策略可能完全不同。A域名返回429,不代表B域名也超载了。
AdaptiveBackoff 内部用 Dict[str, int] 按host记录失败次数,互不干扰:
Apply
class AdaptiveBackoff:
def __init__(self, base_delay=0.5, max_delay=30.0, success_decay=0.5):
self.base_delay = base_delay
self.max_delay = max_delay
self.success_decay = success_decay
self._failures: Dict[str, int] = defaultdict(int)
def record_failure(self, host):
self._failures[host] += 1
def get_delay(self, host):
count = self._failures.get(host, 0)
if count == 0:
return 0.0
base_delay = min(self.base_delay * (2 ** (count - 1)), self.max_delay)
jitter = random.uniform(0, base_delay) # full jitter:抖动范围 [0, delay]
return base_delay + jitter
def record_success(self, host):
cur = self._failures.get(host, 0)
if cur > 0:
self._failures[host] = int(cur * (1 - self.success_decay))几个关键设计:
- record_failure() 只负责计数,不返回延迟值。算延迟是 get_delay() 单独做的事——职责分离。
- 延迟计算公式:base_delay * 2^(fail_count - 1),上限 max_delay。失败1次等0.5s,2次等1s,3次等2s,4次等4s...最快6次失败到达30s上限。
- 抖动范围是 [0, delay],在退避时长基础上再叠加一个等量级的随机浮动——这是 Backoff 领域的 full jitter 策略,来自 AWS 那篇《Exponential Backoff and Jitter》。不加这个抖动的话,所有失败协程虽然退避时长是指数级的,但到期时间仍然完全一样,重试请求会在同一时刻爆发,起不到错峰效果。full jitter 的意义正在于此:让恢复时间在指数范围内均匀散开。
- record_success() 是乘法衰减:int(cur * (1 - success_decay))。success_decay=0.5 时,失败计数每次折半。失败8次后的一次成功,计数变成4,而不是7——衰减比例而不是线性递减,避免了"失败很多次后成功一次就骤降太快"。
退避触发的条件不止是网络超时和连接错误。403和429同样会触发 record_failure()。403表示"请求被拒绝",429表示"你太快了"——这两个状态码是目标主动发出的保护信号,在安全扫描场景里比网络错误更常见。退避策略需要能识别这些信号并做出反应。
五、重试:失败不等于放弃,但也不能无限重试
实战场景
有次扫描一个金融站点,某参数可能存在的 SQL 注入因为网络抖动第一次验证超时了。如果这个任务就这么丢了,那这个漏洞就从报告里消失了——你连知道它的机会都没有。但如果无限重试,又可能卡在某个故障接口上死循环。所以需要一套机制:给你机会,但不是无限次机会。
退避控制的是"等多长时间再试",重试队列管的是"还试不试、试几次、重试后优先级怎么变"。
RetryQueue 的核心逻辑:
Apply
class RetryQueue:
def __init__(self, max_retries=3):
self.max_retries = max_retries
self._queue = []
self._retry_count = {}
def push(self, task):
task_id = task.task_id
count = self._retry_count.get(task_id, 0) + 1
if count > self.max_retries:
logger.warning(f"Task {task_id} exceeded max retries, dropping")
return
self._retry_count[task_id] = count
self._queue.append((task, count))重试 3次 仍失败就丢弃。这个上限防止了某个故障端点让扫描器陷入无限重试循环。
重试入队时,会提升任务的优先级:
Apply
def pop_ready(self):
now = time.time()
ready = []
for entry in self._pending:
if entry.next_retry_at <= now:
escalated_task = QueueTask(
task_id=entry.task_id,
url=entry.url,
priority=TaskPriority.HIGH, # 升级为HIGH
data=entry.data
)
ready.append(escalated_task)
return ready这个设计的逻辑是:一个任务失败后重新入队,说明它遇到过问题、值得给它第二次机会。把它提升到HIGH优先级,让它能够跳过队列里排在前面的大量未执行任务,尽快完成重试。
重试队列、退避控制器、令牌桶,三个组件各管各的事,各自有独立的单元测试覆盖。关注点分离是调度层设计的基本约束——如果这三个逻辑混在一起写,后期改任何一个都会牵动另外两个。
六、缓存:不是加速,是控制扫描面
实战场景
扫描器跑完检测阶段后,发现某参数可能存在 SQL 注入。验证阶段需要再对这个参数发一次同样的 GET 请求来确认。如果不做缓存,同一个请求就要打两次——不仅是效率问题,更重要的是:你每多发一次请求,就被目标日志多记一次。对安全扫描来说,请求次数本身就是一种攻击面。
RequestCache 在扫描器里的定位和通用缓存有本质区别——不是为了加速,而是为了减少重复攻击。
方法签名是面向HTTP请求的:
class RequestCache:
def __init__(self, ttl_sec=60.0, max_entries=10000):
self.ttl = ttl_sec
self.max_entries = max_entries
def get(self, method, url, body=None):
key = self._make_key(method, url, body)
...
def set(self, method, url, response, body=None):
key = self._make_key(method, url, body)
...排除了 POST/PUT/PATCH/DELETE 和 5xx 响应。为什么?因为安全扫描器对目标的基本原则是:尽量少碰目标。同一个 GET 请求,检测阶段发了一次,验证阶段又要发一次,如果响应可缓存,没必要重复攻击同一个端点。这不是为了让扫描更快(虽然客观上确实更快了),而是为了降低扫描器自身产生的流量噪声。
另外有一个 invalidate_host(host) 方法——当某个域名被退避控制器标记为不可达时,同时清空该域名的缓存条目,避免缓存层返回过期数据影响后续判断。这个联动是退避和缓存两个组件在具体场景下的配合,不是强耦合,而是事件驱动的协作。
七、结尾:调度层如何和验证层衔接
上一篇文章讲的是三阶段验证:payload A、payload B、控制组,通过三个请求的响应差异判断漏洞是真是假。
这篇文章讲的是调度:这些请求怎么排队、怎么限速、怎么退避、怎么重试、怎么缓存。
两篇文章合起来,覆盖了扫描链路中两个关键问题:
- 验证层回答:这个漏洞是真是假?——提高扫描结果的可信度
- 调度层回答:什么时候、以什么方式执行请求?——提高扫描过程的可控性
一个负责输出质量,一个负责执行效率。两者互补但不重叠。
一点自知之明
以上所有机制都有对应单元测试覆盖(tests/test_scheduler_upgrade.py,包括多host退避互不干扰、衰减逻辑、高吞吐场景),不是写完没验证过的demo代码。
但有两个真实边界需要说明:
1. 单目标架构。 当前 Scanner.scan() 接收单个 target_url,令牌桶全局单例在这个前提下是合理的设计——一次只扫一个站点,不需要按目标拆分。但如果未来要支持多目标并发扫描,令牌桶需要改成按目标实例化,而不是现在的单例模式。
2. 阈值是经验值。 high_reserve_pct=0.2、success_decay=0.5、max_delay=30.0 这些参数目前是拍脑袋定的,没有针对不同类型目标(CDN前置 vs 裸源站、高并发API vs 静态页)做过系统性调优。在当前的项目阶段,这组值能work,但不一定是最优的。这是后续可以优化的方向。
相比目前主流扫描器普遍采用的固定QPS+简单重试策略,这套设计的主要差异在于优先级和退避是解耦的两个维度——优先级决定谁先执行,退避决定失败后怎么恢复,两者独立调整,互不干扰。这个思路的价值在复杂扫描场景(大量任务、多个子域名、目标有防护机制)下会体现得更明显。
