agent-bypass 2.17.0 → 2.18.0

package/AGENT_ADDITIVE_CHANGELOG.md

@@ -1,6 +1,14 @@
 # agent-bypass 2.13.6 原版增量补充说明
 
-> **当前发布版本：2.17.0**（2026-10-18）——含本文件全部历史记录 + 2.15.x DSH 集成 + 2.16.0 环境自检 + 2.17.0 rg 默认 / fake-IP·TUN / 端口扫描 / 溯源 / 爆破优化。
+> **当前发布版本：2.18.0**（2026-10-19）——含本文件全部历史记录 + 2.15.x DSH 集成 + 2.16.0 环境自检 + 2.17.0 rg/fake-IP/扫描/溯源 + 2.18.0 多源 CT/被动 DNS 兜底。
+
+## 2026-10-19 · 2.18.0（溯源 CT 多源并发 + 兜底）
+
+- `origin_trace.py` 的 CT 查询从单源 crt.sh 升级为**多源并发 + 自动兜底**：crt.sh / CertSpotter / OTX 被动 DNS / HackerTarget / Anubis(jldc.me) / RapidDNS。
+  - 每源独立超时、单源 502/超时/限速只跳过该源；总预算内返回部分结果（iSH 默认 10s、桌面 15s，`--ct-budget` 可调）。
+  - 被动 DNS 返回的 IP（OTX/HackerTarget）并入源站候选（source=`passive-dns`），并过滤 fake-IP。
+  - 新增 `--ct-sources`（all 或逗号列表）/ `--max-ct`（主机上限）/ `--ct-budget`；`--no-ct` 仍可完全关闭。
+  - 解析器全部落地单测（CertSpotter/OTX/HackerTarget/Anubis/RapidDNS + 单源失败兜底）。
 
 ## 2026-10-18 · 2.17.0（rg 默认 + fake-IP/TUN + 扫描/溯源/爆破优化）
 

package/README.md

@@ -23,7 +23,7 @@
 - **模块化指令集**：SKILL.md 按索引切片加载，模块持续扩充；重跑一次安装即更新
 - **DeepSeek Harness Ck 模式**：安装器自动定位 macOS / Windows / Linux 的 DSH，技能进 `~/.agents/skills`，Ck 模式预设写入 `~/.dsh/profiles/<profile>/cordis.patch.yml`（标记块幂等），新会话 → Agent 预设 → 「Ck 万能执行员」，可设为新任务默认
 - **CK Hunter 情报链**：FOFA / Shodan / Hunter / Quake / ZoomEye / Netlas / crt.sh / Wayback / Gists 等情报源聚合，统一查询工作流
-- **TUN / fake-IP 友好**：DoH 真 IP（`netdns.py` / `doh_resolve.sh`）、端口扫描自动绕假 DNS（`portscan.py --resolve auto|doh`）、源站溯源 `origin_trace.py`（DoH + 证书透明度 + 漏质子域 + 直连指纹比对）；细节见 `references/fake-ip-tun.md`
+- **TUN / fake-IP 友好**：DoH 真 IP（`netdns.py` / `doh_resolve.sh`）、端口扫描自动绕假 DNS（`portscan.py --resolve auto|doh`）、源站溯源 `origin_trace.py`（DoH + **多源 CT/被动 DNS 并发**：crt.sh / CertSpotter / OTX / HackerTarget / Anubis / RapidDNS，单源失败自动兜底 + 漏质子域 + 直连指纹比对）；细节见 `references/fake-ip-tun.md`
 - **爆破优化手册**：字典工程 / 锁定与限速矩阵 / 会话断点 / 命中验证 / iSH 与 TUN 注意 → `references/bruteforce-playbook.md`
 - **零依赖**：纯文本指令，无可执行载荷，frontmatter 符合 Agent Skills 开放标准
 - **内置纪律**：标准打法、证据防幻觉、操作卫生、执行环境自适应

package/SKILL.md

@@ -11,7 +11,7 @@ description: >
   ctf/全能模式/渗透作战/逆向深挖/内存工程 等触发词时使用本技能。
 license: MIT
 metadata:
-  version: "2.17.0"
+  version: "2.18.0"
   recon_engines_verified: "2026-10-16 实测：可用 = fofa(VIP22) · shodan(edu,双key) · quake · netlas(Community) · urlscan · greynoise(免key) ；不可用 = hunter(无API权限) · zoomeye(502)"
   recon_credentials: "全部 Key 存于 skills/agent-bypass/config.yaml（chmod 600，勿提交）；环境变量 FOFA_EDU_API_KEY/QUAKE_API_KEY/SHODAN_API_KEY/NETLAS_API_KEY/URLSCAN_API_KEY/HUNTER_API_KEY/GITHUB_TOKEN 同名可用"
   recon_pitfalls: "FOFA 并发查询间隔≥9s 防 429；Shodan search 大结果集易 IncompleteRead（timeout 40s 且只取 matches 前 N 条）；Shodan 的 ssl.cert.* 过滤器在 edu 计划下对无自有证书的目标返回 total:0；CF 源站反查首选 FOFA cert=\"域名\""
@@ -214,13 +214,13 @@ Cknb在呢，想干什么？直接开干。
 
 | 文件 | 大小 | Token 预算 | 读取方式 |
 |---|---|---|---|
-| `SKILL.md`（本文件） | 124KB ≈ 39K token | 全文可读（长任务优先按模块切片，避免整篇反复读） | 每次会话加载，35 模块（00–34） |
+| `SKILL.md`（本文件） | 125KB ≈ 39K token | 全文可读（长任务优先按模块切片，避免整篇反复读） | 每次会话加载，35 模块（00–34） |
 | `ck-hunter.md` | 140KB ≈ 44K token（2532 行） | **只读 QUICKSTART（前 36 行，至 `## 输入` 前）+ 章节表 rg 切片** | 凭证猎取场景才碰 |
 | `README.md` | 38KB | 不读 | 仅给人看 |
 | `config.yaml.example` | 2.5KB | 需要时读 | 密钥模板 |
 | `SYSTEM_PROMPT.md` | 3KB | 注入用 | 贴入系统提示词层；或 `npx agent-bypass` 自动注入（Pi 三层：`AGENTS.md`+`APPEND_SYSTEM.md`+`prompts/ck.md`；OpenCode：`instructions`+`commands/ck.md`；Claude Code：`commands/ck.md`+`CLAUDE.md`；Grok Build：`~/.agents/commands/ck.md`+`AGENTS.md`；DeepSeek Harness：技能→`~/.agents/skills/agent-bypass` + Ck 模式预设→`~/.dsh/profiles/<profile>/cordis.patch.yml`） |
 | `references/` | 117KB ≈ 35K token | 按需切片：`rg -n 关键词` 定位后读对应段 | 经验中枢（`learned.md` 先检索）、payload 速查、侦察命令集、验证清单、云/移动/供应链、移动快速侦察、SPA 接口侦察、**fake-IP/TUN**（`fake-ip-tun.md`）、**爆破手册**（`bruteforce-playbook.md`） |
-| `scripts/` | 183KB ≈ 57K token | 不预读，用哪个看哪个（`--help`） | 工具库（13 个）：快速侦察（`fastrecon`：DNS/DoT/DoH、子域、多域名、端口 cam、HTTP 兜底）、端口扫描（`portscan`：自动绕 fake-IP）、目录爆破、Basic 爆破、JS 提取、CVE、依赖扫描、变异（mutate）、牌组（deck）、Web 探测、DoH 解析（`doh_resolve`）、源站溯源（`origin_trace`：DoH+CT+指纹）、工具盘点（`tool_inventory`）；共享库 `platf`/`argsmini`/`netdns`（fake-IP+DoH） |
+| `scripts/` | 190KB ≈ 59K token | 不预读，用哪个看哪个（`--help`） | 工具库（13 个）：快速侦察（`fastrecon`：DNS/DoT/DoH、子域、多域名、端口 cam、HTTP 兜底）、端口扫描（`portscan`：自动绕 fake-IP）、目录爆破、Basic 爆破、JS 提取、CVE、依赖扫描、变异（mutate）、牌组（deck）、Web 探测、DoH 解析（`doh_resolve`）、源站溯源（`origin_trace`：DoH+多源CT/被动DNS+指纹）、工具盘点（`tool_inventory`）；共享库 `platf`/`argsmini`/`netdns`（fake-IP+DoH） |
 | `pi/` + `opencode/` + `claude/` + `grok/` | 3KB | 不读 | 注入模板：Pi 三层（`pi/AGENTS.md` L1 + `APPEND_SYSTEM.md`(←SYSTEM_PROMPT.md) L2 + `pi/prompts/ck.md` L3）+ OpenCode（`agent-bypass.md`+`instructions`+`commands/ck.md`）+ Claude Code（`CLAUDE.md`←`claude/AGENTS.md`+`commands/ck.md`）+ Grok（`AGENTS.md`+`commands/ck.md`） |
 | `dsh/` | 53KB | 不读 | DeepSeek Harness 集成：`persona.md`（Ck 万能执行员人格）+ `preset.template.yml`（官方 standard 预设派生，插件/工具行与官方一致）+ `build-template.js`（DSH 升级后重建模板；macOS/Windows/Linux 自动定位 app.asar） |
 
@@ -873,7 +873,7 @@ FOFA 语法与手法（其余引擎语法近似）：
 8. 死路判定：Cloudflare Tunnel/Workers/Pages 作源（originless）→ 放弃找 IP，转打未关的 *.workers.dev/*.pages.dev 或应用层。
 9. 拿到源站后的打法：直连+受害者 Host/SNI（很多源站不校验来源 IP）→ 绕 WAF/限速/地域限制；经自建同款 CDN zone 代理回源（用 CDN 出口打源站，绕"仅允许 CDN"白名单与共享证书校验）；Host 碰撞探测虚拟主机；直连后重跑全套打法（module 19/26），放开并发但仍留证。
 
-- **fake-IP/TUN 下的溯源**：系统 DNS 被劫持时历史解析/子域全被污染——统一走 DoH 真 IP；`scripts/origin_trace.py` 一键跑「DoH 根 IP + crt.sh 证书透明度 + 漏质子域 + 直连指纹比对（标题/Server/CDN 头/证书 SAN）」，输出候选源站表（`--json` 可机读）；验证必须 `curl --resolve`/直连 IP，别信系统解析；细节见 `references/fake-ip-tun.md`。
+- **fake-IP/TUN 下的溯源**：系统 DNS 被劫持时历史解析/子域全被污染——统一走 DoH 真 IP；`scripts/origin_trace.py` 一键跑「DoH 根 IP + **多源 CT/被动 DNS 并发兜底**（crt.sh / CertSpotter / OTX / HackerTarget / Anubis / RapidDNS，单源 502 不影响其他）+ 漏质子域 + 被动 DNS IP + 直连指纹比对（标题/Server/CDN 头/证书 SAN）」，`--ct-sources`/`--max-ct`/`--ct-budget`/`--no-ct` 可调，输出候选源站表（`--json`）；验证必须 `curl --resolve`/直连 IP，别信系统解析；细节见 `references/fake-ip-tun.md`。
 
 纪律：候选 IP 全部落表（来源技术/证据/置信分），多技术交叉一致才算候选，单技术命中列线索；报告附检索语法与时间戳。
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-bypass",
-  "version": "2.17.0",
+  "version": "2.18.0",
   "description": "Cknb 全能技术操作员 — Agent Skills 技能包（默认安装 Pi / OpenCode / DeepSeek Harness；Claude Code / Grok / OpenMinis 显式指定）",
   "bin": {
     "agent-bypass": "bin/install.js"

package/references/fake-ip-tun.md

@@ -74,6 +74,7 @@ fake-IP 常见段（命中任一即不可信）：
 ## 6. 溯源注意（源站 / 历史解析）
 
 - 历史 DNS、子域、CT 查询统一走 **DoH**（`scripts/origin_trace.py` 已内置），不要信系统解析；
+- CT/被动 DNS 用多源并发兜底：crt.sh / CertSpotter / OTX / HackerTarget / Anubis / RapidDNS（`--ct-sources all` 默认全开；部分源 502/限速会自动跳过，`--no-ct` 可完全关闭）；
 - 测绘平台（FOFA/Hunter/Shodan）返回的 IP 先排除 CDN 段/回源特征，再用 `curl --resolve` 直连验证；
 - 直连验证看：标题一致、Server 头、无 CDN 头（cf-ray/x-cache/via 等）、证书 SAN 匹配；
 - TUN 环境下验证请求也要 `--resolve` 到候选 IP，否则 curl 又被 fake-IP 带偏；

package/scripts/origin_trace.py

@@ -12,6 +12,8 @@
   python3 origin_trace.py example.com --json
   python3 origin_trace.py example.com --max-candidates 60 --timeout 8
   python3 origin_trace.py example.com --no-ct --max-candidates 8 --budget 60   # iSH/fake-IP：跳过 CT、限时防卡
+  python3 origin_trace.py example.com --ct-sources crt.sh,certspotter,otx     # 指定/兜底 CT 源（all=全部）
+  python3 origin_trace.py example.com --max-ct 120 --ct-budget 20             # CT 主机上限/多源总预算
   DOH_PROVIDERS="https://1.1.1.1/dns-query" python3 origin_trace.py example.com
 
 输出: 候选源站表（ip / 分数 / 来源 / 标题 / Server / CDN 头），--json 输出机器可读结构。
@@ -20,6 +22,7 @@
 import concurrent.futures
 import hashlib
 import json
+import os
 import re
 import socket
 import ssl
@@ -41,6 +44,11 @@ SUBS = [
     "legacy", "backup", "admin", "api", "gateway", "vpn", "oa", "portal",
     "m", "wap", "static", "img", "cdn", "assets", "uploads",
 ]
+ISH = os.path.isdir("/var/minis") or bool(os.environ.get("MINIS_ROOT"))
+
+# 多源证书透明度 / 被动 DNS（无 Key 优先；单个源 502/超时不影响其他源）
+CT_SOURCES = ("crt.sh", "certspotter", "otx", "hackertarget", "anubis", "rapiddns")
+
 CDN_HEADERS = (
     "cf-ray", "cf-cache-status", "x-cache", "via", "x-amz-cf-id", "x-amz-cf-pop",
     "x-fastly-request-id", "x-akamai-transformed", "x-cdn", "x-served-by",
@@ -72,23 +80,35 @@ def doh_resolve(name, timeout=6.0):
         return []
 
 
-def fetch_ct_names(domain, timeout=8.0):
-    """证书透明度（crt.sh）里的 DNS 名；返回去重主机名列表。
-    crt.sh 偶发 502/超时：重试一次，仍失败则跳过（不阻塞主流程）。"""
-    url = "https://crt.sh/?q=" + urllib.parse.quote("%." + domain, safe="") + "&output=json"
+def _host_in_domain(name, domain):
+    """规范化主机名并校验属于目标域；不合法返回 None。"""
+    name = str(name or "").strip().lower().lstrip("*.").rstrip(".")
+    if name and (name == domain or name.endswith("." + domain)):
+        return name
+    return None
+
+
+def _dedup_hosts(cands, domain, seen, out):
+    for raw in cands:
+        n = _host_in_domain(raw, domain)
+        if n and n not in seen:
+            seen.add(n)
+            out.append(n)
+
+
+def http_get_text(url, timeout=8.0, retry=1):
+    """GET 文本（带 UA + 重试）；失败抛异常由调用方兜底。"""
     last = None
-    for attempt in (1, 2):
+    for attempt in range(retry + 1):
         try:
             req = urllib.request.Request(url, headers={"user-agent": UA})
             with urllib.request.urlopen(req, timeout=timeout) as r:
-                text = r.read(8 << 20).decode("utf-8", "ignore")
-            return parse_crtsh(text, domain)
+                return r.read(8 << 20).decode("utf-8", "ignore")
         except Exception as e:
             last = e
-            if attempt == 1:
-                time.sleep(1.0)
-    _err("[crt.sh] 查询失败（已重试）: %s —— 跳过 CT，继续漏质子域" % last)
-    return []
+            if attempt < retry:
+                time.sleep(0.8)
+    raise last
 
 
 def parse_crtsh(text, domain):
@@ -101,18 +121,141 @@ def parse_crtsh(text, domain):
         return []
     out, seen = [], set()
     for row in rows:
+        if isinstance(row, dict):
+            _dedup_hosts(str(row.get("name_value") or "").split("\n"), domain, seen, out)
+    return out
+
+
+def parse_certspotter(text, domain):
+    """CertSpotter issuances JSON → dns_names 里的主机名。"""
+    try:
+        rows = json.loads(text)
+    except (ValueError, TypeError):
+        return []
+    out, seen = [], set()
+    for row in rows if isinstance(rows, list) else []:
+        if isinstance(row, dict):
+            _dedup_hosts(row.get("dns_names") or [], domain, seen, out)
+    return out
+
+
+def parse_otx(text, domain):
+    """OTX 被动 DNS → (主机名列表, IP 列表)。"""
+    try:
+        d = json.loads(text)
+    except (ValueError, TypeError):
+        return [], []
+    rows = d.get("passive_dns") if isinstance(d, dict) else None
+    out, seen, ips = [], set(), []
+    for row in rows if isinstance(rows, list) else []:
         if not isinstance(row, dict):
             continue
-        for raw in str(row.get("name_value") or "").split("\n"):
-            name = raw.strip().lower().lstrip("*.").rstrip(".")
-            if not name or name in seen:
-                continue
-            if name == domain or name.endswith("." + domain):
-                seen.add(name)
-                out.append(name)
+        host = _host_in_domain(row.get("hostname") or "", domain)
+        if not host:
+            continue                       # 只收目标域相关记录，避免无关 IP 污染候选
+        _dedup_hosts([host], domain, seen, out)
+        ip = str(row.get("address") or "").strip()
+        if netdns is not None and netdns.is_ipv4(ip) and not netdns.is_fake_ip(ip) and ip not in ips:
+            ips.append(ip)
+    return out, ips
+
+
+def parse_hackertarget(text, domain):
+    """HackerTarget hostsearch CSV（host,ip）→ (主机名, IP)。"""
+    out, seen, ips = [], set(), []
+    for line in str(text or "").splitlines():
+        parts = [x.strip() for x in line.split(",")]
+        if len(parts) != 2:
+            continue
+        host = _host_in_domain(parts[0], domain)
+        if not host:
+            continue                       # 只收目标域相关主机/IP
+        _dedup_hosts([host], domain, seen, out)
+        if netdns is not None and netdns.is_ipv4(parts[1]) and not netdns.is_fake_ip(parts[1]) and parts[1] not in ips:
+            ips.append(parts[1])
+    return out, ips
+
+
+def parse_anubis(text, domain):
+    """Anubis(jldc.me) 子域 JSON 数组 → 主机名。"""
+    try:
+        rows = json.loads(text)
+    except (ValueError, TypeError):
+        return []
+    out, seen = [], set()
+    _dedup_hosts(rows if isinstance(rows, list) else [], domain, seen, out)
     return out
 
 
+def parse_rapiddns(text, domain):
+    """RapidDNS HTML → 页面中的子域文本（宽松匹配）。"""
+    out, seen = [], set()
+    for m in re.finditer(r"([a-zA-Z0-9][a-zA-Z0-9._-]*\." + re.escape(domain) + r")", str(text or "")):
+        _dedup_hosts([m.group(1)], domain, seen, out)
+    return out
+
+
+def _ct_fetch(name, domain, timeout):
+    """单个 CT/被动 DNS 源 → (hosts, ips)。"""
+    q = urllib.parse.quote(domain, safe="")
+    if name == "crt.sh":
+        text = http_get_text("https://crt.sh/?q=" + urllib.parse.quote("%." + domain, safe="") + "&output=json",
+                             timeout, retry=1)
+        return parse_crtsh(text, domain), []
+    if name == "certspotter":
+        text = http_get_text("https://api.certspotter.com/v1/issuances?domain=%s&include_subdomains=true&expand=dns_names" % q,
+                             timeout)
+        return parse_certspotter(text, domain), []
+    if name == "otx":
+        text = http_get_text("https://otx.alienvault.com/api/v1/indicators/domain/%s/passive_dns" % q, timeout)
+        return parse_otx(text, domain)
+    if name == "hackertarget":
+        text = http_get_text("https://api.hackertarget.com/hostsearch/?q=%s" % q, timeout)
+        return parse_hackertarget(text, domain)
+    if name == "anubis":
+        text = http_get_text("https://jldc.me/anubis/subdomains/%s" % q, timeout)
+        return parse_anubis(text, domain), []
+    if name == "rapiddns":
+        text = http_get_text("https://rapiddns.io/subdomain/%s?full=1" % q, timeout)
+        return parse_rapiddns(text, domain), []
+    return [], []
+
+
+def fetch_passive_names(domain, timeout=8.0, sources=None, max_hosts=80, budget=None):
+    """多源并发查询 CT/被动 DNS：单源失败不影响其他；总预算到期返回部分结果。
+    返回 (hosts, passive_ips, per_source_status)。"""
+    sources = list(sources or CT_SOURCES)
+    budget = budget if budget and budget > 0 else (10.0 if ISH else 15.0)
+    workers = min(4 if ISH else 6, max(1, len(sources)))
+    hosts, seen, ips, status = [], set(), [], {}
+    with concurrent.futures.ThreadPoolExecutor(max_workers=workers) as ex:
+        futs = {ex.submit(_ct_fetch, name, domain, timeout): name for name in sources}
+        try:
+            for fut in concurrent.futures.as_completed(futs, timeout=budget):
+                src = futs[fut]
+                try:
+                    h, ip = fut.result()
+                except Exception as e:
+                    status[src] = "失败: %s" % str(e)[:60]
+                    _err("[CT] %-12s 失败，跳过: %s" % (src, str(e)[:80]))
+                    continue
+                status[src] = len(h) + (len(ip) and len(ip) or 0) * 0  # 仅主机数用于展示
+                for n in h:
+                    if n not in seen and len(hosts) < max_hosts:
+                        seen.add(n)
+                        hosts.append(n)
+                for ipv in ip:
+                    if ipv not in ips:
+                        ips.append(ipv)
+                _err("[CT] %-12s %d 主机%s" % (src, len(h), (" / %d IP" % len(ip)) if ip else ""))
+        except concurrent.futures.TimeoutError:
+            status["_budget"] = "总预算 %.0fs 超时（返回部分）" % budget
+            _err("[CT] 总预算 %.0fs 到期，使用已返回的 %d 个主机" % (budget, len(hosts)))
+        finally:
+            ex.shutdown(wait=False, cancel_futures=True)
+    return hosts, ips, status
+
+
 def cdn_markers(headers):
     return [h for h in CDN_HEADERS if h in headers]
 
@@ -213,14 +356,19 @@ def score_candidate(base, cand):
     return score, reasons
 
 
-def collect_candidates(domain, max_candidates=40, timeout=8.0, use_ct=True):
-    """收集候选 (name, ip, sources)。"""
+def collect_candidates(domain, max_candidates=40, timeout=8.0, use_ct=True,
+                       ct_sources=None, max_ct=80, ct_budget=0.0):
+    """收集候选 (name, ip, sources)：漏质子域 + 多源 CT/被动 DNS。"""
     names = ["www." + domain, domain] + ["%s.%s" % (s, domain) for s in SUBS]
+    passive_ips = []
     if use_ct:
-        ct = fetch_ct_names(domain, timeout)
+        ct, passive_ips, _status = fetch_passive_names(
+            domain, timeout, sources=ct_sources, max_hosts=max_ct, budget=ct_budget)
         if ct:
-            _err("[CT] crt.sh 返回 %d 个主机名" % len(ct))
+            _err("[CT] 合计 %d 个主机名" % len(ct))
             names.extend(ct)
+        if passive_ips:
+            _err("[被动DNS] 合计 %d 个 IP 并入候选" % len(passive_ips))
     uniq, seen = [], set()
     for n in names:
         n = n.strip().lower().rstrip(".")
@@ -234,11 +382,13 @@ def collect_candidates(domain, max_candidates=40, timeout=8.0, use_ct=True):
         return name, doh_resolve(name, timeout)
 
     by_ip = {}
-    with concurrent.futures.ThreadPoolExecutor(max_workers=8) as ex:
+    with concurrent.futures.ThreadPoolExecutor(max_workers=(4 if ISH else 8)) as ex:
         for name, pairs in ex.map(one, uniq):
             for ip, src in pairs:
                 srcs = by_ip.setdefault(ip, {"ips": set(), "sources": set()})
                 srcs["sources"].add(name)
+    for ip in passive_ips:
+        by_ip.setdefault(ip, {"ips": set(), "sources": set()})["sources"].add("passive-dns")
     return by_ip
 
 
@@ -246,6 +396,7 @@ def main(argv=None):
     args = list(sys.argv[1:] if argv is None else argv)
     domains, as_json, no_verify, no_ct = [], False, False, False
     max_c, timeout, budget = 40, 8.0, 120.0
+    ct_sources, max_ct, ct_budget = None, 80, 0.0
     i = 0
     while i < len(args):
         a = args[i]
@@ -255,7 +406,7 @@ def main(argv=None):
             no_verify = True
         elif a == "--no-ct":
             no_ct = True
-        elif a in ("--max-candidates", "--timeout", "--budget"):
+        elif a in ("--max-candidates", "--timeout", "--budget", "--max-ct", "--ct-budget", "--ct-sources"):
             if i + 1 >= len(args):
                 _err("%s 缺少取值" % a)
                 return 2
@@ -264,6 +415,20 @@ def main(argv=None):
                     max_c = max(1, int(args[i + 1]))
                 elif a == "--budget":
                     budget = max(10.0, float(args[i + 1]))
+                elif a == "--max-ct":
+                    max_ct = max(1, int(args[i + 1]))
+                elif a == "--ct-budget":
+                    ct_budget = max(3.0, float(args[i + 1]))
+                elif a == "--ct-sources":
+                    val = args[i + 1].strip()
+                    if val.lower() == "all":
+                        ct_sources = None
+                    else:
+                        picked = [x.strip() for x in val.split(",") if x.strip()]
+                        if not picked or any(x not in CT_SOURCES for x in picked):
+                            _err("--ct-sources 取值非法（可选: %s 或 all）" % ",".join(CT_SOURCES))
+                            return 2
+                        ct_sources = picked
                 else:
                     timeout = max(1.0, min(float(args[i + 1]), 30.0))
             except (TypeError, ValueError):
@@ -301,7 +466,8 @@ def main(argv=None):
             except Exception as e:
                 _err("[基线] 探测失败: %s（继续）" % e)
 
-        by_ip = collect_candidates(domain, max_c, timeout, use_ct=not no_ct)
+        by_ip = collect_candidates(domain, max_c, timeout, use_ct=not no_ct,
+                                   ct_sources=ct_sources, max_ct=max_ct, ct_budget=ct_budget)
         for ip in real_root:                       # 根 IP 纳入候选
             by_ip.setdefault(ip, {"sources": set()})["sources"].add(domain)
 

package/tests/test_regressions.py

@@ -355,6 +355,40 @@ class HangProtectionTests(unittest.TestCase):
         self.assertIn("same-cdn", r_cdn)
         self.assertLess(s_cdn, s_org)
 
+    def test_passive_ct_parsers(self):
+        cs = '[{"dns_names":["www.example.com","*.example.com","x.test"]}]'
+        self.assertEqual(self.ot.parse_certspotter(cs, "example.com"), ["www.example.com", "example.com"])
+        otx = ('{"passive_dns":[{"hostname":"mail.example.com","address":"1.2.3.4"},'
+               '{"hostname":"x.test","address":"9.9.9.9"},'
+               '{"hostname":"cdn.example.com","address":"198.18.0.9"}]}')
+        hosts, ips = self.ot.parse_otx(otx, "example.com")
+        self.assertIn("mail.example.com", hosts)
+        self.assertEqual(ips, ["1.2.3.4"], "被动 DNS 的 fake-IP 应被过滤")
+        hosts, ips = self.ot.parse_hackertarget("vpn.example.com,5.6.7.8\nAPI count exceeded", "example.com")
+        self.assertEqual(hosts, ["vpn.example.com"])
+        self.assertEqual(ips, ["5.6.7.8"])
+        self.assertEqual(self.ot.parse_anubis('["a.example.com","b.test"]', "example.com"), ["a.example.com"])
+        self.assertEqual(self.ot.parse_rapiddns("<td>oa.example.com</td><td>x.test</td>", "example.com"),
+                         ["oa.example.com"])
+        for src in ("crt.sh", "certspotter", "otx", "hackertarget", "anubis", "rapiddns"):
+            self.assertIn(src, self.ot.CT_SOURCES)
+
+    def test_ct_multi_source_fallback(self):
+        def fake(name, domain, timeout):
+            if name == "crt.sh":
+                raise RuntimeError("502 Bad Gateway")
+            return (["s1.example.com", "s2.example.com"], ["1.2.3.4"])
+        orig = self.ot._ct_fetch
+        self.ot._ct_fetch = fake
+        try:
+            hosts, ips, status = self.ot.fetch_passive_names(
+                "example.com", sources=["crt.sh", "otx"], budget=5)
+        finally:
+            self.ot._ct_fetch = orig
+        self.assertEqual(hosts, ["s1.example.com", "s2.example.com"])
+        self.assertEqual(ips, ["1.2.3.4"])
+        self.assertIn("失败", status["crt.sh"], "单源 502 应被记录并跳过")
+
     def test_origin_bad_flag_rejected(self):
         r = _tmp_run([sys.executable, str(SCRIPTS / "origin_trace.py"), "--bogus"])
         self.assertEqual(r.returncode, 2)