agent-bypass 2.11.4 → 2.11.6

package/README.md

@@ -16,7 +16,8 @@ SKILL.md 加 ck-hunter.md 两个纯文本文件，放进任意 Agent 环境即
 - CK Hunter 子技能：21 个情报源聚合（FOFA / Shodan / Hunter / Quake / ZoomEye / Netlas / crt.sh / Wayback / Gists 等）
 - 零依赖：纯文本指令，无可执行载荷，frontmatter 符合 Agent Skills 开放标准
 - 内置纪律：标准打法、证据防幻觉、操作卫生、执行环境自适应
-- 内置工具库：portscan / dirbrute / jsrip / cvefetch / depscan / mutate / deck / webprobe 等 10 个即用脚本
+- 内置工具库（11 个）：fastrecon（移动三合一：DNS/端口/HTTP）/ portscan / dirbrute / basicauth_brute / jsrip / cvefetch / depscan / mutate / deck / webprobe / doh_resolve
+- 移动优化：iSH/Termux 实测提速（端口 selectors 45x、HTTP curl -Z 5.6x、DNS UDP 220x vs DoH）+ 全链自动兜底，详见 references/mobile-fast-recon.md
 - 内置经验中枢：实战教训按格式沉淀（references/learned.md），新任务先检索同架构避坑
 
 ## 模型行为与兼容性（实测记录）
@@ -127,7 +128,7 @@ agent-bypass/
 ├── ck-hunter.md          # 子技能：21 源凭证猎取（QUICKSTART 切片协议）
 ├── SYSTEM_PROMPT.md      # 纯注入内容：注入系统提示词层
 ├── references/           # 参考资料：经验中枢 / payload 速查 / 侦察命令集 / 验证清单 / 云移动供应链
-├── scripts/              # 工具库：端口扫描 / 目录爆破 / JS 提取 / CVE 拉取 / 依赖扫描 / 变异调度 / 牌组管理 等 10 个
+├── scripts/              # 工具库（11 个）：快速侦察 / 端口扫描 / 目录爆破 / 凭据爆破 / JS 提取 / CVE 拉取 等
 ├── pi/                   # Pi 三层注入文件
 ├── opencode/             # OpenCode 命令文件
 ├── claude/               # Claude Code 命令与注入文件

package/SKILL.md

@@ -10,7 +10,7 @@ description: >
   ctf/全能模式/渗透作战/逆向深挖/内存工程 等触发词时使用本技能。
 license: MIT
 metadata:
-  version: "2.11.4"
+  version: "2.11.6"
 ---
 
 # agent-bypass — Ck · 万能执行员
@@ -180,8 +180,8 @@ Cknb在呢，想干什么？直接开干。
 | `README.md` | 13KB | 不读 | 仅给人看 |
 | `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`） |
-| `references/` | 35KB ≈ 12K token | 按需切片：`grep -n 关键词` 定位后读对应段 | 参考资料：经验中枢（`learned.md`，开新任务先检索）、payload 速查、侦察命令集、验证清单、云/移动/供应链专题 |
-| `scripts/` | 58KB ≈ 15K token | 不预读，用哪个看哪个（`--help`） | 工具库：端口扫描、目录爆破、JS 提取、CVE 拉取、依赖扫描、变异调度（mutate）、牌组管理（deck）、Basic 爆破、Web 探测、DoH 解析 |
+| `references/` | 38KB ≈ 13K token | 按需切片：`grep -n 关键词` 定位后读对应段 | 参考资料：经验中枢（`learned.md`，开新任务先检索）、payload 速查、侦察命令集、验证清单、云/移动/供应链专题、移动快速侦察（`mobile-fast-recon.md`：iSH/Termux 实测基准+兜底链+平台工具矩阵） |
+| `scripts/` | 75KB ≈ 19K token | 不预读，用哪个看哪个（`--help`） | 工具库（11 个）：快速侦察三合一（`fastrecon`：DNS/端口/HTTP+自动兜底链）、端口扫描、目录爆破（curl-Z 引擎+软404过滤）、Basic 爆破（curl-Z 快速引擎）、JS 提取、CVE 拉取、依赖扫描、变异调度（mutate）、牌组管理（deck）、Web 探测、DoH 解析 |
 | `pi/` + `opencode/` + `claude/` + `grok/` | 3KB | 不读 | 注入模板：Pi 三层（`pi/AGENTS.md`、`pi/prompts/ck.md`）+ OpenCode/Claude Code `commands/ck.md` + Grok `commands/ck.md` |
 
 **模块索引**（grep 定位）：00 身份 · 01 运行时 · 02 可移植 · 03 第一性原则 · 04 轨道 · 05 子技能加载 · 06 主动执行 · 07 策略引擎 · 08 双用模式 · 09 工作协议 · 10 人格 · 20 黑话路由 · 30 标准流程 · 40 逆向 · 41 Pwn · 42 网络 · 43 密码学 · 44 移动 · 45 取证 · 46 渗透 · 47 内存 · 48 协议 · 49 漏洞研究 · 50 JS 逆向 · 51 修复 · 52 卡密 · 53 Web注入 · 54 泄漏 · 55 红队 · 56 测绘源站 · 60 自动化 · 61 防幻觉 · 70 输出
@@ -415,6 +415,8 @@ Exploit 构建：
 
 工具：curl/curl-impersonate(`--resolve`/`--http2`/`--http3`/`--proxy`)、requests/httpx/aiohttp/tls-client(异步并发+TLS 指纹伪装)、tcpdump/tshark、dig/DoH/dnsx、openssl(`s_client`/`JARM`/`JA3`/`JA4`)、nmap/masscan、nuclei(模板编写)/ffuf/feroxbuster、sqlmap、katana/gau/waybackurls/subfinder/amass、browser_use/playwright、mitmproxy、frida hook SSL_pin_bypass。
 
+移动执行（iSH/Termux）：fastrecon 三合一（DNS=UDP 并发+缓存 / SCAN=selectors / HTTP=curl -Z）+ 全链自动兜底（getent / 线程池 / urllib 降级）；Termux 原生优先 rustscan / naabu / masscan / ffuf / feroxbuster。实测基准与参数详见 references/mobile-fast-recon.md。
+
 纪律：URL/HAR/JS bundle → 断点定位 fetch/XHR → 签名还原 Python 复现 → 枚举端点→推断 schema→round-trip 校验→产出 client。
 
 作战面（授权范围内全数纳入；火力时机与多路径由 module 07 决定）：

package/bin/install.js

@@ -314,7 +314,7 @@ function uninstallGrok() {
 // 技能库主副本（SSOT）两种位置（设置里可选）：
 //   A. ~/.agents/skills/agent-bypass/（Agent Skills 开放标准，Grok 等直读）
 //   B. ~/.cc-switch/skills/agent-bypass/（CC Switch 默认）
-// 策略：主副本已存在（已纳管）→ 覆盖更新（软链自动穿透到真身）；未纳管 → 不制造孤立目录，提示导入。
+// 策略：主副本已存在（已纳管）→ 覆盖更新（软链自动穿透到真身）；不存在 → 首次建立主副本，随后在 CC Switch 中导入纳管。
 function ccswitchSso() {
   const cands = [path.join(HOME, '.agents', 'skills', 'agent-bypass'), path.join(HOME, '.cc-switch', 'skills', 'agent-bypass')];
   for (const p of cands) if (exists(p)) return p;
@@ -329,8 +329,11 @@ function installCcswitch() {
     return;
   }
   if (exists(path.join(HOME, '.cc-switch'))) {
-    info('CC Switch 技能库中尚无 agent-bypass（未纳管）');
-    info('如需纳管：在 CC Switch \u2192 Skills 中导入应用目录的 agent-bypass，之后重跑本安装器即可同步更新');
+    // 首次建立 SSOT：技能库位置按设置选 ~/.agents/skills（Agent Skills 开放标准）——直接写入主副本
+    const init = path.join(HOME, '.agents', 'skills', 'agent-bypass');
+    installSkills(init);
+    info('已在 CC Switch 技能库位置建立 agent-bypass 主副本（~/.agents/skills）');
+    info('下一步：在 CC Switch \u2192 Skills 中对 agent-bypass 执行导入/纳管；此后本命令一步同步全平台');
   } else {
     info('未检测到 ~/.cc-switch，跳过');
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-bypass",
-  "version": "2.11.4",
+  "version": "2.11.6",
   "description": "Cknb 全能技术操作员 — Agent Skills 技能包（自动安装到 Pi / OpenCode / Claude Code / Grok Build / OpenMinis）",
   "bin": {
     "agent-bypass": "bin/install.js"

package/references/mobile-fast-recon.md

@@ -0,0 +1,102 @@
+# 移动环境快速侦察（iSH / Termux）
+
+手机端（iOS iSH、Android Termux）执行扫描/爆破的优化方案、实测基准与自动兜底链。
+以下数字为本机 iSH（iOS, Alpine aarch64 模拟环境）实测，2026-09。
+
+## 一、实测基准（iSH）
+
+| 场景 | 慢办法 | 快办法 | 倍数 |
+|---|---|---|---|
+| 50 端口（静默目标，等超时） | 串行 40.2s | selectors 并发 0.89s | 45x |
+| 500 端口（本地） | - | selectors 0.9s | - |
+| 10 URL HTTP 探测 | 串行 15.2s | curl -Z 并行 2.7s | 5.6x |
+| 目录爆破 183 路径 | py 线程池 106s | curl -Z 引擎 6s | 17.7x |
+| DNS 单域名（本地 resolver） | DoH 1102ms | UDP 直发 5ms | 220x |
+| DNS 30 域名批量 | getent 串行 0.2s | UDP 并发 0.1s | 1.4x |
+
+关键坑：
+- 每个请求重建 urllib opener → 触发 getproxies() 读系统代理设置（iSH 下单次约 200ms）→ opener 必须全局缓存。
+- DoH 在移动环境极慢（每域名一次 HTTPS 往返 + 走代理）；批量解析用本地 resolver（/etc/resolv.conf，通常 198.18.x.x 代理回环）UDP 直发。
+- 外网 UDP:53 通常被代理环境过滤，UDP 只打本地 resolver。
+
+## 二、fastrecon 用法速查
+
+三合一：dns（UDP 并发+缓存）/ scan（selectors）/ http（curl -Z）。
+
+```bash
+# DNS 批量（UDP 并发 + 本地缓存 + getent 兜底）
+python3 scripts/fastrecon.py dns example.com,github.com
+python3 scripts/fastrecon.py dns subs.txt -w 50
+
+# 端口扫描（selectors 并发 + 逐 sock 精确超时）
+python3 scripts/fastrecon.py scan 192.168.1.1 -p top100
+python3 scripts/fastrecon.py scan 10.0.0.0/24 -p 22,80,443 -t 0.6
+python3 scripts/fastrecon.py scan host -p 1-1000 -b        # 抓服务横幅
+
+# HTTP 批量（curl -Z 并行，10 秒扫完数百 URL）
+python3 scripts/fastrecon.py http urls.txt -b 48
+python3 scripts/fastrecon.py http 'https://a.com,https://b.com' --code
+```
+
+## 三、自动兜底链（快 → 慢）
+
+| 能力 | 主路径（默认） | 自动兜底 1 | 自动兜底 2 |
+|---|---|---|---|
+| DNS | UDP 并发直发（5ms/个） | 失败率>60% → getent 并发 | DoH（最后手段，慢） |
+| 端口 | selectors 并发（45x） | selectors 异常 → 线程池 connect | 低并发串行 |
+| HTTP | curl -Z 并行（C 实现） | 无 curl → Python urllib 并发 | 单请求逐个 |
+| 目录爆破 | dirbrute --engine curl（批量+软404过滤） | 无 curl → --engine py 线程池 | - |
+| 凭据爆破 | basicauth curl -Z（URL 内嵌凭据并行） | 无 curl / 需 delay 控制 → py 精细模式 | - |
+
+fastrecon 内置自动切换；dirbrute / basicauth_brute 用 --engine auto（默认）自动选择。
+
+## 四、平台工具矩阵
+
+### iSH（iOS）
+- 可用：Python 纯标准库、curl、busybox、apk（i386 包，nmap 可装但模拟层慢）
+- 推荐：fastrecon 全家桶 + curl -Z
+- 不可行：Go/Rust 原生二进制（x86 模拟架构不匹配）
+
+### Termux（Android arm64）
+- 原生工具优先：
+  - `pkg install nmap`（C）
+  - `pkg install rustscan`（Rust，65k 端口 3 秒级，依赖 nmap）
+  - `pkg install masscan`（C，SYN 异步高速；或 anasfanani/masscan-termux-android）
+  - `pkg install ffuf`、`pkg install feroxbuster`（内容发现）
+  - naabu（Go，ProjectDiscovery release 直接下载 arm64）
+- 无 root：SYN 半开不可用（masscan/nmap -sS 需 root）；TCP connect（rustscan/naabu/fastrecon）通用。
+- 兜底：原生工具不可用时回退 fastrecon / dirbrute（Python 版照常可跑）。
+
+## 五、性能技巧清单
+
+1. 并发模型优先级：selectors（单线程 IO 多路复用）> 线程池 > 串行。iSH 线程切换开销大，selectors 最稳。
+2. 超时管理：非阻塞 connect 超时不会触发 select 事件——必须逐 socket 计时清理，否则整轮扫描被拖到兜底超时。
+3. DNS：批量 UDP 并发 + 本地缓存文件；避免 DoH；getent 兜底。
+4. HTTP：curl -Z（--parallel-max）是 C 级并行，比 Python 快一个数量级；每个 URL 必须配对 -o /dev/null（否则多余 body 污染 stdout）。
+5. urllib：opener 全局缓存（getproxies 系统调用是隐藏杀手）。
+6. 测试方法：单线程测试服务器会制造假象（客户端背锅）；并发测试用多线程服务器。
+7. 软404：目标返回"200 假页面"时，先探测随机路径取基线（状态码+大小），过滤假阳性（dirbrute curl 引擎内置此逻辑）。
+8. 大范围扫描：先用 top100 快扫定位存活，再做全端口深扫；CIDR 用 /24 以内切片分次跑。
+
+## v2.11.6 提速与自适配（2026-09-28）
+
+### iSH import 成本实测与懒加载策略
+- 实测（每次调用固定成本）：urllib.request 5s、subprocess 3s、concurrent.futures 2s、argparse 1.8s、json 1.8s、ssl 1s、socket/selectors 各 1s
+- 策略：重模块全部懒加载（首次用才 import）；argparse 换 argsmini.py 极简解析（0 成本）；curl 调用改 os.popen（免 subprocess 3s）；dns 线程池自研（免 cf 2s）
+- 自适配：platf.py 探测 iSH/Termux/RPi/Linux/macOS/Windows → 并发/超时自动调参
+
+### 耗时对比（iSH 实测，含 Python 启动）
+| 命令 | 改造前 | v2.11.6 |
+|------|--------|---------|
+| scan | 4-7s | 1s |
+| dns | 7s | 2s |
+| dirbrute | 7-8s | 3s |
+| basicauth | 8s | 5s |
+
+### DoT（DNS over TLS）
+- `fastrecon dns example.com --via dot --resolver 1.1.1.1`（RFC 7858：TCP 853+TLS，帧格式同 TCP）
+- `--via auto`：UDP 失败自动切 DoT；论文实测 DoT 优于 DoH、Do53 最快
+- 解析链：UDP →（auto 时）DoT → getent → DoH
+
+### 摄像头端口组（-p cam）
+80/81/88/443/554/8554/8000/8080/8081/8899/34567/37777/9527/2000/2020/1935/5000/5001/5540/7070/7447/4520/8787——覆盖 Hikvision/Dahua/XMeye/Axis/Reolink 等相机与 NVR。

package/scripts/argsmini.py

@@ -0,0 +1,158 @@
+"""argparse 极简兼容层（iSH 上省 ~1.8s import 成本）。
+覆盖三工具用到的子集：位置参数、--opt 值、type、default、choices、
+store_true、subparsers(dest)、parse_args、error、-h。
+不支持：前缀缩写、nargs、metavar、互斥组等（三工具未用）。"""
+import sys
+
+
+def _basename(p):
+    return p.rsplit('/', 1)[-1] or p
+
+
+class _NS:
+    pass
+
+
+class ArgumentParser:
+    def __init__(self, prog=None, description=None, **kw):
+        self.prog = prog or _basename(sys.argv[0])
+        self.description = description or ''
+        self._opts = []
+        self._sub_dest = None
+        self._sub_parsers = {}
+
+    def add_argument(self, *names, **kw):
+        flag = kw.get('action') == 'store_true'
+        if len(names) == 1 and not names[0].startswith('-'):
+            o = dict(dest=names[0], flags=None, pos=True, is_flag=False,
+                     type=kw.get('type', str), default=kw.get('default'),
+                     choices=kw.get('choices'), help=kw.get('help', ''))
+        else:
+            longs = [n for n in names if n.startswith('--')]
+            dest = (longs[0] if longs else names[0]).lstrip('-').replace('-', '_')
+            o = dict(dest=dest, flags=list(names), pos=False, is_flag=flag,
+                     type=kw.get('type', str),
+                     default=kw.get('default', False if flag else None),
+                     choices=kw.get('choices'), help=kw.get('help', ''))
+        self._opts.append(o)
+
+    def add_subparsers(self, dest=None, **kw):
+        self._sub_dest = dest or 'cmd'
+        holder = self
+
+        class _Sub:
+            def add_parser(self, name, help=''):
+                p = ArgumentParser(prog='%s %s' % (holder.prog, name), description=help)
+                holder._sub_parsers[name] = p
+                return p
+        return _Sub()
+    def parse_args(self, argv=None):
+        argv = list(sys.argv[1:] if argv is None else argv)
+        if self._sub_parsers:
+            if not argv:
+                ns = _NS()
+                setattr(ns, self._sub_dest, None)
+                return ns
+            for i, t in enumerate(argv):
+                if not t.startswith('-'):
+                    name, rest = t, argv[:i] + argv[i + 1:]
+                    break
+            else:
+                if argv[0] in ('-h', '--help'):
+                    self.print_help()
+                    raise SystemExit(0)
+                self.error('unrecognized arguments: %s' % argv[0])
+            sp = self._sub_parsers.get(name)
+            if sp is None:
+                self.error('无效命令: %s（可选: %s）' % (name, ', '.join(sorted(self._sub_parsers))))
+            ns = sp.parse_args(rest)
+            setattr(ns, self._sub_dest, name)
+            return ns
+        ns = _NS()
+        for o in self._opts:
+            setattr(ns, o['dest'], o['default'])
+        pos_order = [o for o in self._opts if o['pos']]
+        pos_idx = 0
+        i = 0
+        while i < len(argv):
+            t = argv[i]
+            if t in ('-h', '--help'):
+                self.print_help()
+                raise SystemExit(0)
+            if t.startswith('-') and t != '-':
+                o = self._find(t)
+                if o is None:
+                    self.error('unrecognized arguments: %s' % t)
+                if o['is_flag']:
+                    setattr(ns, o['dest'], True)
+                    i += 1
+                else:
+                    if i + 1 >= len(argv):
+                        self.error('argument %s: expected one argument' % t)
+                    setattr(ns, o['dest'], self._conv(o, argv[i + 1], t))
+                    i += 2
+            else:
+                if pos_idx >= len(pos_order):
+                    self.error('unrecognized arguments: %s' % t)
+                o = pos_order[pos_idx]
+                setattr(ns, o['dest'], self._conv(o, t, o['dest']))
+                pos_idx += 1
+                i += 1
+        for o in pos_order[pos_idx:]:
+            if o['default'] is None:
+                self.error('the following arguments are required: %s' % o['dest'])
+        return ns
+
+    def _find(self, flag):
+        for o in self._opts:
+            if o['flags'] and flag in o['flags']:
+                return o
+        return None
+    def _conv(self, o, raw, shown):
+        if o['type'] is not str:
+            try:
+                v = o['type'](raw)
+            except (ValueError, TypeError):
+                self.error('argument %s: invalid %s value: %r' % (shown, o['type'].__name__, raw))
+                return None
+        else:
+            v = raw
+        if o['choices'] is not None and v not in o['choices']:
+            self.error('argument %s: invalid choice: %r (choose from %s)' % (
+                shown, v, ', '.join(map(repr, o['choices']))))
+        return v
+
+    def print_help(self, out=None):
+        out = out if out is not None else sys.stdout
+        w = out.write
+        w('usage: %s [-h] [options]\n' % self.prog)
+        if self.description:
+            w('\n%s\n' % self.description)
+        w('\noptions:\n')
+        for o in self._opts:
+            if o['flags']:
+                w('  %s  %s\n' % (', '.join(o['flags']), o['help']))
+            else:
+                w('  %s  %s\n' % (o['dest'], o['help']))
+        if self._sub_parsers:
+            w('\ncommands:\n')
+            for n, p in sorted(self._sub_parsers.items()):
+                w('  %s  %s\n' % (n, p.description))
+        w('  -h, --help  show this help message and exit\n')
+
+    def error(self, message):
+        sys.stderr.write('%s: error: %s\n' % (self.prog, message))
+        raise SystemExit(2)
+
+
+if __name__ == '__main__':
+    ap = ArgumentParser(prog='amtest', description='argsmini 自测')
+    sub = ap.add_subparsers(dest='cmd')
+    d = sub.add_parser('dns', help='dns test')
+    d.add_argument('target', help='域名')
+    d.add_argument('-w', '--workers', type=int, default=8, help='并发')
+    d.add_argument('--dot', action='store_true', help='DoT')
+    d.add_argument('--via', choices=['udp', 'dot'], default='udp', help='通道')
+    ns = ap.parse_args()
+    print('cmd=%s target=%s workers=%r dot=%r via=%s' % (
+        ns.cmd, ns.target, ns.workers, ns.dot, ns.via))

package/scripts/basicauth_brute.py

@@ -4,23 +4,94 @@
 HTTP Basic Auth 爆破（低并发 + 退避，避免触发 WAF/封 IP）
 用法: python3 basicauth_brute.py <url> <userlist> <passlist> [--conc 4] [--delay 0.15]
 """
-import sys, ssl, base64, time, json, argparse, urllib.request, urllib.error, concurrent.futures
+import os, sys, base64, time, json, shutil, re
+import argsmini as argparse
+
+# ---- 懒加载/popen 优化：ssl/urllib/concurrent import 各耗 1-5s（iSH），仅首次用时载入 ----
+_ssl_m = None
+def _get_ssl():
+    global _ssl_m
+    if _ssl_m is None: import ssl as _s; _ssl_m = _s
+    return _ssl_m
+_url_m = None
+def _get_urllib():
+    global _url_m
+    if _url_m is None: import urllib.request as _r; import urllib.error as _e; _url_m = (_r, _e)
+    return _url_m
+_cf_m = None
+def _get_cf():
+    global _cf_m
+    if _cf_m is None: import concurrent.futures as _c; _cf_m = _c
+    return _cf_m
+def _quote(s):
+    import urllib.parse as _p
+    return _p.quote(s, safe='')
+def _unquote(s):
+    import urllib.parse as _p
+    return _p.unquote(s)
+_SAFE = frozenset("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789@%_+=:,./-")
+def _shq(s):
+    if s and all(c in _SAFE for c in s): return s
+    return "'%s'" % s.replace("'", "'" + chr(92) + "'" + "'")
+def _run_curl(cargs):
+    p = os.popen(" ".join(_shq(a) for a in cargs) + " 2>/dev/null")
+    out = p.read(); p.close(); return out
+_CTX = None
+def _ctx():
+    global _CTX
+    if _CTX is None:
+        _s = _get_ssl()
+        c = _s.SSLContext(_s.PROTOCOL_TLS_CLIENT)
+        c.check_hostname = False
+        c.verify_mode = _s.CERT_NONE
+        _CTX = c
+    return _CTX
 
 UA = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0 Safari/537.36"
-CTX = ssl.create_default_context(); CTX.check_hostname = False; CTX.verify_mode = ssl.CERT_NONE
 
 def try_one(url, user, pwd, delay):
+    _r, _e = _get_urllib()
     if delay: time.sleep(delay)
     tok = base64.b64encode(f"{user}:{pwd}".encode()).decode()
-    r = urllib.request.Request(url, headers={"User-Agent": UA, "Authorization": f"Basic {tok}"})
+    r = _r.Request(url, headers={"User-Agent": UA, "Authorization": f"Basic {tok}"})
     try:
-        with urllib.request.urlopen(r, timeout=10, context=CTX) as resp:
+        with _r.urlopen(r, timeout=10, context=_ctx()) as resp:
             return (user, pwd, resp.status, resp.read(200))
-    except urllib.error.HTTPError as e:
+    except _e.HTTPError as e:
         return (user, pwd, e.code, b"")
     except Exception as e:
         return (user, pwd, 0, str(e).encode()[:100])
 
+def brute_curl(url, users, passes, batch, timeout):
+    """快速引擎：curl -Z 批量（URL 内嵌凭据，状态码区分）"""
+    pairs = [(u, p) for u in users for p in passes]
+    scheme, _, rest = url.partition('://')
+    hits = 0
+    for i in range(0, len(pairs), batch):
+        chunk = pairs[i:i + batch]
+        cargs = ['curl', '-sZ', '--parallel-max', str(batch), '-m', str(timeout),
+                 '-w', '%{http_code} %{url_effective}\n']
+        for u, p in chunk:
+            cargs += ['-o', '/dev/null', f"{scheme}://{_quote(u)}:{_quote(p)}@{rest}"]
+        try:
+            out = _run_curl(cargs)
+        except OSError:
+            continue
+        for line in out.splitlines():
+            code_s, _, eff = line.partition(' ')
+            code = int(code_s) if code_s.isdigit() else 0
+            m = re.match(r'^[a-zA-Z]+://([^@]+)@', eff)
+            cred = _unquote(m.group(1)) if m else ''
+            u, _, p = cred.partition(':')
+            if code in (200, 301, 302):
+                hits += 1
+                print(json.dumps({"HIT": True, "user": u, "pass": p, "status": code}))
+            elif code not in (401, 0):
+                print(json.dumps({"odd": True, "user": u, "pass": p, "status": code}))
+        print(f"[*] {min(i + batch, len(pairs))}/{len(pairs)} done", file=sys.stderr)
+    print(json.dumps({"done": True, "attempts": len(pairs), "hits": hits}))
+
+
 def main():
     ap = argparse.ArgumentParser()
     ap.add_argument("url"); ap.add_argument("users"); ap.add_argument("passes")
@@ -29,10 +100,14 @@ def main():
     users = [l.strip() for l in open(a.users) if l.strip()]
     passes = [l.strip() for l in open(a.passes) if l.strip()]
     print(f"[*] {len(users)} users x {len(passes)} passes = {len(users)*len(passes)} attempts", file=sys.stderr)
+    if (not a.delay or a.delay <= 0) and shutil.which("curl"):
+        print("[*] 快速模式: curl -Z 批量（无 curl 或缺 delay 控制需求时自动改用线程池）", file=sys.stderr)
+        brute_curl(a.url, users, passes, 48, 10)
+        return
     n = 0
-    with concurrent.futures.ThreadPoolExecutor(max_workers=a.conc) as ex:
+    with _get_cf().ThreadPoolExecutor(max_workers=a.conc) as ex:
         futs = [ex.submit(try_one, a.url, u, p, a.delay) for u in users for p in passes]
-        for f in concurrent.futures.as_completed(futs):
+        for f in _get_cf().as_completed(futs):
             u, p, st, body = f.result()
             n += 1
             if st in (200, 302, 301):