agent-bypass 2.16.0 → 2.18.0

package/references/fake-ip-tun.md

@@ -0,0 +1,114 @@
+# fake-IP / TUN 环境下的扫描与溯源（iSH / iOS / 桌面代理通用）
+
+> 症状：iSH 或桌面开了 TUN（Clash / mihomo / sing-box / Stash / Surfboard 等）后，
+> 端口扫描全超时、nmap 报 "host seems down"、curl 能通但扫不到端口、溯源拿到一堆假 IP。
+
+## 1. 判定：是不是被 fake-IP 劫持了
+
+```sh
+# 解析任意已知域名，看是否落在 fake-IP 段
+nslookup example.com            # iSH/BusyBox 自带；或 getent ahostsv4 example.com
+python3 scripts/doh_resolve.sh example.com    # DoH 真 IP（正常应返回真实公网 IP）
+python3 scripts/netdns.py example.com          # 对照：系统解析 vs DoH
+```
+
+fake-IP 常见段（命中任一即不可信）：
+- `198.18.0.0/15`（198.18.x / 198.19.x）——Clash/mihomo/sing-box 默认 fake-ip-range
+- `198.51.100.0/24`、`203.0.113.0/24`（TEST-NET）与 `240.0.0.0/4`（保留段）——部分代理实现
+
+判据：**系统解析落在上述段、DoH 返回真实公网 IP = TUN 劫持了 UDP:53**。
+
+## 2. 为什么扫不动
+
+- 端口扫描是 raw socket / connect：连接假地址（198.18.x）不可路由 → 全超时/误判全关。
+- 系统解析结果会被缓存：代理切换后旧 fake-IP 仍可能残留。
+- 溯源/测绘同理：子域、历史 DNS、CT 目标如果都走系统解析，拿到的都是假 IP。
+
+## 3. 处理优先级（从便宜到重）
+
+1. **DoH 拿真 IP（首选，无需动代理配置）**：
+   ```sh
+   sh scripts/doh_resolve.sh target.com              # A（--aaaa 同时查 IPv6）
+   python3 scripts/netdns.py target.com --doh
+   python3 scripts/fastrecon.py dns target.com --doh  # 批量 + 缓存
+   ```
+   DoH 走 HTTPS/443，不经过被劫持的 UDP:53。
+2. **端口扫描直接用真 IP，禁止再解析**：
+   ```sh
+   python3 scripts/portscan.py <真实IP> --ports top100
+   nmap -n -Pn -sT -p- <真实IP>              # -n 不解析；-Pn 跳过主机发现
+   masscan <真实IP> -p1-65535 --rate=5000
+   ```
+   本仓库 `portscan.py` 已默认检测 fake-IP：`--resolve auto` 会自动换 DoH；`--resolve doh` 强制 DoH；只剩 fake 时直接拒绝扫描（exit 3）。
+3. **HTTP/HTTPS 探测用 `--resolve` 保持 SNI**：
+   ```sh
+   curl -sk --resolve target.com:443:<真实IP> https://target.com/
+   ```
+4. **代理侧绕开（需要可用配置时）**：
+   - 规则里把目标域名/网段设为 `DIRECT`（或代理组走直连）；
+   - `fake-ip-filter` 加入目标域名（Clash/mihomo：`fake-ip-filter: ['+.target.com']`）；
+   - DNS 模式改 `redir-host`（真实解析）而不是 `fake-ip`；
+   - 关闭「TUN 劫持 DNS」/「DNS 增强」开关；
+   - 扫描期间别开「全局 TUN」。
+5. **验证是不是真源站/真端口**：`curl -sk --resolve` 对比标题/favicon/响应头；扫到的端口再用协议 banner 复核（如 `nc -v ip 22`、`curl -k https://ip:8443`）。
+
+## 4. 端口扫描 SOP（fake-IP 环境）
+
+1. 用 DoH 拿真 IP（域名 → 真实 IP 列表）；
+2. 只对真实 IP 扫：先 `top100` 快扫，再全端口；iSH 并发 ≤200、超时 ≥3s；
+3. 扫到的开放端口用协议回连验证（不是只有 open TCP 就算）；
+4. 需要域名语义时：`curl --resolve` / `Host:` / SNI 手动指定；
+5. 报告里写清「解析方式（DoH/系统）+ 扫描目标 IP + 时间」，避免把 fake-IP 结果当证据。
+
+## 5. 爆破注意（TUN 会改变出口与限速语义）
+
+- **限速/锁定按什么算**：账号 vs IP vs 指纹。TUN 下出口 IP 可能是代理节点 IP（甚至多个），
+  锁定策略会跟着代理池变化——先小量探测锁定律（几次锁/锁多久/锁 IP 还是账号）。
+- **出口稳定优先**：爆破建议走**固定直连出口**（或固定代理节点）保持 IP 会话一致；
+  频繁轮换出口会触发风控/让锁定判断失真。绕限速顺序：换头 → 换账号 → 窗口对齐 → 出口轮换（最后）。
+- **别把扫描与爆破混在同一出口**：扫描流量特征明显，容易把同一出口的爆破流量一起喂给 WAF。
+- **iSH 约束**：hydra 走 apk 安装；legba 在 iSH 上不可用/不稳，改用 hydra 或 python paramiko；
+  并发降低（1–4），长任务 `nohup ... &` + 日志断点续跑。
+- 其它细节见 `references/bruteforce-playbook.md`。
+
+## 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 带偏；
+- 结论三档：直连一致 = 确认；仅历史解析 = 线索；只有 CDN 响应 = 未穿透。
+
+## 7. 卡住排查（iSH 重点）
+
+iSH 常见"一直卡住"的三个来源：DNS 解析挂起、TUN 拦截的 TCP 连接无响应、CT/HTTP 请求慢。
+
+```sh
+# ① DNS 卡住：用 DoH（硬超时），别等系统解析
+sh scripts/doh_resolve.sh example.com          # curl --max-time 4
+python3 scripts/netdns.py example.com --doh    # 守护线程 + DoH 总时限
+
+# ② 端口扫描卡住：加总时限，到点返回部分结果
+python3 scripts/portscan.py <真实IP> --ports top100 --deadline 180
+
+# ③ 溯源卡住：跳过 CT、缩小候选、限总预算
+python3 scripts/origin_trace.py example.com --no-ct --max-candidates 8 --budget 60
+
+# ④ 长任务别前台干等（iSH 无 GNU timeout）
+nohup python3 scripts/portscan.py <ip> --ports 1-65535 --deadline 300 > scan.log 2>&1 &
+# 看进度/停止
+tail -f scan.log ; kill %1
+```
+
+- iSH 上并发/超时已自动降档（portscan：并发 ≤200、超时 ≥3s）。
+- 所有脚本都有内部硬超时，不允许无限等待；卡住时先降载重跑，不要同一命令反复硬等。
+- 代理侧卡住：把目标加 DIRECT/fake-ip-filter，或临时关 TUN DNS 劫持再试。
+
+## 8. 自检清单
+
+- [ ] `netdns.py`/`doh_resolve.sh` 能拿到非 fake 的真实 IP
+- [ ] 扫描目标是真实 IP（不是 198.18.x）
+- [ ] 开放端口有协议级验证，不只是 TCP connect 成功
+- [ ] HTTP 验证用 `--resolve` 保持正确 SNI/Host
+- [ ] 报告记录了「解析方式 + 目标 IP + 时间」

package/references/tool-selection.md

@@ -1,6 +1,14 @@
 # 工具选型与原包脚本对照（只读能力发现）
 
-本表依据原始 `scripts/`、`module 13–33` 和参考项目的能力划分整理。它不是命令执行清单。`scripts/tool_inventory.py` 用于发现工具，**不会**下载依赖、扫描目标或调用下列渗透脚本。
+本表依据原始 `scripts/`、`module 00–34` 和参考项目的能力划分整理。它不是命令执行清单。`scripts/tool_inventory.py` 用于发现工具，**不会**下载依赖、扫描目标或调用下列渗透脚本。
+
+## 默认工具策略（先看这个）
+
+- **文本检索 / 日志过滤 / 代码搜索 / 查配置：默认一律 `rg`（ripgrep）**；`grep` 仅在 rg 不可用且装不上时兜底。
+- 安装：macOS `brew install ripgrep`；Debian/Ubuntu `apt install ripgrep`；Alpine/iSH `apk add ripgrep`；Termux `pkg install ripgrep`；Windows `winget install BurntSushi.ripgrep.MSVC`（或 scoop/choco）。
+- 常用：`rg -n 关键词 路径`（行号）· `rg -l`（只列文件）· `rg -i`（忽略大小写）· `rg -S`（智能大小写）· `rg --hidden -g '!node_modules'` · `rg -A/-B/-C`（上下文）· `rg -f patterns.txt`（模式文件）。
+- **fake-IP / TUN 环境**：`scripts/netdns.py`（DoH 真 IP）、`scripts/doh_resolve.sh`、`scripts/origin_trace.py`（源站溯源）；细节见 `references/fake-ip-tun.md`。
+- **爆破**：字典/锁定/验证细节见 `references/bruteforce-playbook.md`。
 
 ## A. 按文件类型和任务选工具
 

package/scripts/doh_resolve.sh

@@ -1,7 +1,112 @@
 #!/bin/sh
-# Resolve via DoH, bypassing the sandbox's fake DNS
-for d in "$@"; do
-  ans=$(curl -s --noproxy '*' "https://1.1.1.1/dns-query?name=$d&type=A" -H 'accept: application/dns-json' \
-        | tr ',' '\n' | grep '"data"' | sed 's/.*"data":"//;s/".*//' | grep -E '^[0-9]+\.' | tr '\n' ' ')
-  echo "$d => $ans"
+# DoH 解析：绕过 TUN / fake-IP（Clash/mihomo 默认 198.18.0.0/15），拿真实 IP。
+#
+# 用法:
+#   sh doh_resolve.sh example.com            # A 记录
+#   sh doh_resolve.sh example.com --aaaa     # 同时查 AAAA
+#   sh doh_resolve.sh a.com b.com --json     # JSON 输出
+#   sh doh_resolve.sh example.com -q         # 只输出 IP（便于管道）
+#   DOH_PROVIDERS="https://1.1.1.1/dns-query https://dns.google/resolve" sh doh_resolve.sh example.com
+#
+# 说明：走 HTTPS/443 的 DoH，不经过被 TUN 劫持的 UDP:53；
+#       fake-IP 段（198.18/15、198.51.100/24、203.0.113/24、240/4）会标注告警。
+set -u
+
+AAAA=0; JSON=0; QUIET=0; DOMAINS=""
+for a in "$@"; do
+  case "$a" in
+    --aaaa) AAAA=1 ;;
+    --json) JSON=1 ;;
+    -q|--quiet) QUIET=1 ;;
+    -h|--help)
+      sed -n '2,14p' "$0" | sed 's/^# \{0,1\}//'
+      exit 0 ;;
+    -*) echo "未知参数: $a" >&2; exit 2 ;;
+    *) DOMAINS="$DOMAINS $a" ;;
+  esac
 done
+[ -z "${DOMAINS# }" ] && { echo "用法: sh doh_resolve.sh <domain>... [--aaaa] [--json] [-q]" >&2; exit 2; }
+
+PROVIDERS="${DOH_PROVIDERS:-https://1.1.1.1/dns-query https://dns.google/resolve https://223.5.5.5/resolve}"
+DOH_TIMEOUT="${DOH_TIMEOUT:-4}"
+
+command -v curl >/dev/null 2>&1 || { echo "[错误] 缺 curl（iSH: apk add curl）" >&2; exit 2; }
+
+is_fake() {
+  case "$1" in
+    198.18.*|198.19.*|240.*|198.51.100.*|203.0.113.*) return 0 ;;
+  esac
+  return 1
+}
+
+doh_raw() { # name qtype provider
+  curl -s --max-time "$DOH_TIMEOUT" -H 'accept: application/dns-json' "$3?name=$1&type=$2" 2>/dev/null
+}
+
+extract_ips() { # json qtype
+  if command -v python3 >/dev/null 2>&1; then
+    printf '%s' "$1" | python3 -c '
+import json,sys
+try:
+    d=json.load(sys.stdin)
+except Exception:
+    sys.exit(0)
+want=1 if sys.argv[1]=="A" else 28
+seen=[]
+for a in (d.get("Answer") or []):
+    if a.get("type")==want:
+        v=str(a.get("data") or "").strip()
+        if v and v not in seen:
+            seen.append(v)
+print(" ".join(seen))
+' "$2"
+  else
+    printf '%s' "$1" | tr ',' '\n' | sed -n 's/.*"data":"\([0-9a-fA-F.:]*\)".*/\1/p' | tr '\n' ' '
+  fi
+}
+
+lookup() { # name qtype -> ips (空格分隔)
+  _n=$1; _t=$2; _out=""
+  for _p in $PROVIDERS; do
+    _j=$(doh_raw "$_n" "$_t" "$_p")
+    [ -z "$_j" ] && continue
+    _out=$(extract_ips "$_j" "$_t")
+    [ -n "$_out" ] && break
+  done
+  echo "$_out"
+}
+
+json_rows=""
+for d in $DOMAINS; do
+  a_ips=$(lookup "$d" A)
+  a4=""; fake=""
+  for ip in $a_ips; do
+    if is_fake "$ip"; then fake="$fake $ip"; else a4="$a4 $ip"; fi
+  done
+  a4=$(printf '%s' "$a4" | tr ' ' '\n' | sed '/^$/d' | tr '\n' ' ' | sed 's/ $//')
+  fake=$(printf '%s' "$fake" | sed 's/^ //')
+  aaaa=""
+  if [ "$AAAA" = "1" ]; then
+    aaaa=$(lookup "$d" AAAA | sed 's/ *$//')
+  fi
+
+  if [ "$JSON" = "1" ]; then
+    esc_a=$(printf '%s' "$a4" | tr ' ' ',')
+    esc_aaaa=$(printf '%s' "$aaaa" | tr ' ' ',')
+    esc_fake=$(printf '%s' "$fake" | tr ' ' ',')
+    json_rows="$json_rows{\"domain\":\"$d\",\"a\":\"$esc_a\",\"aaaa\":\"$esc_aaaa\",\"fake\":\"$esc_fake\"},"
+  else
+    if [ "$QUIET" = "1" ]; then
+      [ -n "$a4" ] && echo "$a4"
+      [ "$AAAA" = "1" ] && [ -n "$aaaa" ] && echo "$aaaa"
+    else
+      echo "$d => ${a4:--}${aaaa:+ | AAAA: $aaaa}"
+    fi
+    [ -n "$fake" ] && echo "  [告警] 结果含 fake-IP（$fake）：TUN 劫持了 DNS，该地址不可信" >&2
+  fi
+  [ -z "$a4" ] && [ -z "$aaaa" ] && echo "  [失败] $d DoH 无结果（检查出网/DoH 端点）" >&2
+done
+
+if [ "$JSON" = "1" ]; then
+  printf '[%s]\n' "$(printf '%s' "$json_rows" | sed 's/,$//')"
+fi

package/scripts/fastrecon.py

@@ -10,6 +10,7 @@
 用法：
   fastrecon.py dns example.com github.com          # 批量解析（UDP 并发 + 缓存）
   fastrecon.py dns subs.txt -w 50                  # 文件批量（每行一个域名）
+  fastrecon.py dns example.com --doh               # 强制 DoH（绕 TUN/fake-IP 真 IP）
   fastrecon.py scan 192.168.1.1 -p top100          # 端口扫描（selectors 并发）
   fastrecon.py scan 10.0.0.0/24 -p 22,80,443 -t 0.6
   fastrecon.py http urls.txt -b 48                 # HTTP 批量探测（curl -Z 并行）
@@ -36,6 +37,11 @@ import argsmini as argparse
 import ipaddress, os, random, re, selectors, socket, struct, sys, time
 import platf
 
+try:                       # 共享 DNS 工具（同目录 netdns.py）：fake-IP 判定 + DoH 真 IP
+    import netdns
+except Exception:
+    netdns = None
+
 # 懒加载：iSH 上 concurrent.futures/subprocess import 各耗 2-3s，仅首次使用时载入
 _cf_mod = None
 def _get_cf():
@@ -197,8 +203,23 @@ def load_resolvers(override=None):
 
 
 def _is_fakeip(ip):
-    """fake-ip 段判定：RFC 2544 198.18.0.0/15（Clash/mihomo 默认）与 240.0.0.0/4"""
-    return ip.startswith('198.18.') or ip.startswith('198.19.') or ip.startswith('240.')
+    """fake-IP / 伪造段判定（优先共享 netdns；单文件场景退化）。"""
+    if netdns is not None:
+        try:
+            return netdns.is_fake_ip(ip)
+        except Exception:
+            pass
+    return str(ip).startswith(('198.18.', '198.19.', '240.', '198.51.100.', '203.0.113.'))
+
+
+def _doh_lookup(name, timeout=6.0):
+    """DoH 拿真实 IP（绕 TUN/fake-IP）；无共享模块或失败返回 []。"""
+    if netdns is None:
+        return []
+    try:
+        return netdns.doh_query(name, 'A', timeout)
+    except Exception:
+        return []
 
 
 _PROBE_NAME = 'www.apple.com'
@@ -645,7 +666,14 @@ def cmd_dns(args):
 
     def one(n):
         try:
-            return n, dns_query(n, servers, timeout=timeout, via=args.via)
+            if getattr(args, 'doh', False):        # 强制 DoH（TUN/fake-IP 环境）
+                return n, _doh_lookup(n, timeout)
+            ips = dns_query(n, servers, timeout=timeout, via=args.via)
+            if not ips or all(_is_fakeip(x) for x in ips):
+                d = _doh_lookup(n, timeout)        # 系统 DNS 被劫持 → 走 DoH 拿真 IP
+                if d:
+                    return n, d
+            return n, ips
         except Exception as e:              # 单点失败不影响整批
             print(f'[警告] {n} 解析异常: {e}', file=sys.stderr)
             return n, []
@@ -661,6 +689,15 @@ def cmd_dns(args):
         for n, ips in _run_pool(failed, _getent_one, _clamp_int(workers, 1, 20, 20)):
             if ips:
                 results[n] = ips
+    # DoH 兜底：系统解析为空或全 fake-IP（TUN 劫持 UDP:53）→ HTTPS DoH 拿真 IP
+    doh_todo = [n for n in todo
+                if not [x for x in (results.get(n) or []) if not _is_fakeip(x)]]
+    if doh_todo:
+        print(f'[DoH] {len(doh_todo)} 个域名系统结果为空/fake-IP，改走 DoH 真 IP', file=sys.stderr)
+        for n, ips in _run_pool(doh_todo, lambda x: (x, _doh_lookup(x, timeout)),
+                                  _clamp_int(workers, 1, 10, 10)):
+            if ips:
+                results[n] = ips
     new_cache, written = [], set()
     for n in todo:
         ips = results.get(n)
@@ -923,10 +960,20 @@ def cmd_scan(args):
         except ValueError:
             try:
                 ip = socket.gethostbyname(h)
+                if _is_fakeip(ip) and netdns is not None:
+                    real, src = netdns.resolve_real(h)
+                    if [x for x in real if not _is_fakeip(x)]:
+                        _warn(f'{h} 系统解析为 fake-IP（{ip}），已用 DoH 真 IP: {real[0]}')
+                        ip = real[0]
             except (OSError, UnicodeError):
-                print(f'{h}\tDNS 解析失败或非法地址')
-                rc = rc or 1
-                continue
+                real = _doh_lookup(h) if netdns is not None else []
+                if real:
+                    _warn(f'{h} 系统解析失败，已用 DoH 真 IP: {real[0]}')
+                    ip = real[0]
+                else:
+                    print(f'{h}\tDNS 解析失败或非法地址（TUN/fake-IP？试 dns {h} --doh）')
+                    rc = rc or 1
+                    continue
         t0 = time.time()
         try:
             found, banners, skipped = scan_host(ip, ports, timeout, workers, args.banner)
@@ -1383,6 +1430,8 @@ def main():
                     help='解析通道: udp(默认) / dot(DoT 853) / auto(UDP 失败自动 DoT)')
     d.add_argument('-t', '--timeout', type=float, default=4)
     d.add_argument('--no-cache', action='store_true')
+    d.add_argument('--doh', action='store_true',
+                    help='强制 DoH 解析（绕 TUN/fake-IP；iSH/TUN 环境下推荐）')
 
     s = sub.add_parser('scan', help='端口扫描（selectors 并发）')
     s.add_argument('target', help='主机 / CIDR / 文件')

package/scripts/netdns.py

@@ -0,0 +1,192 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""共享 DNS 工具：fake-IP 判定 + DoH 真 IP 解析 + 系统解析兜底（纯标准库）。
+
+为什么需要：iSH / iOS 或桌面开了 TUN（Clash / mihomo / sing-box 等）时，
+DNS 常被劫持成 fake-IP（默认 198.18.0.0/15）。此时：
+  · 端口扫描（nmap/masscan/本脚本 connect 扫）拿到的是不可路由假地址 → 全部超时/误判；
+  · 源站溯源 / 爆破 / 证书探测同样拿不到真 IP。
+解法：用 DoH（DNS over HTTPS，走 443，不经过被劫持的 UDP:53）拿真实 A/AAAA。
+
+用法（供 portscan / fastrecon / origin_trace 复用）：
+    import netdns
+    ips, source = netdns.resolve_real('example.com')      # auto: 系统 → DoH
+    ips, source = netdns.resolve_real('example.com', prefer='doh')
+    netdns.is_fake_ip('198.18.0.5')  # True
+
+CLI 自检：
+    python3 netdns.py example.com [--doh] [--json]
+"""
+import ipaddress
+import json
+import socket
+import sys
+import threading
+import time
+import urllib.parse
+import urllib.request
+
+# fake-IP 常见伪造段（Clash/mihomo/sing-box 默认 198.18.0.0/15；其它代理软件另有实现）
+FAKE_NETS = tuple(ipaddress.ip_network(n) for n in (
+    "198.18.0.0/15",      # RFC 2544 基准测试段：Clash / mihomo / sing-box 默认 fake-ip
+    "198.51.100.0/24",    # TEST-NET-2：部分代理软件伪造段
+    "203.0.113.0/24",     # TEST-NET-3
+    "240.0.0.0/4",        # 保留段：部分 fake-ip 实现
+))
+
+# DoH JSON 端点（走 HTTPS/443，TUN 劫持不到 UDP:53）
+DOH_PROVIDERS = (
+    "https://1.1.1.1/dns-query",    # Cloudflare（需 accept: application/dns-json）
+    "https://dns.google/resolve",   # Google
+    "https://223.5.5.5/resolve",    # AliDNS
+)
+UA = "agent-bypass-netdns/1.0"
+DEFAULT_TIMEOUT = 6.0
+
+
+def is_ipv4(s):
+    try:
+        ipaddress.IPv4Address(str(s).strip())
+        return True
+    except (ValueError, TypeError):
+        return False
+
+
+def is_fake_ip(ip):
+    """fake-IP / 不可路由伪造段判定。"""
+    if not is_ipv4(ip):
+        return False
+    a = ipaddress.IPv4Address(str(ip).strip())
+    return any(a in n for n in FAKE_NETS)
+
+
+def _system_resolve_impl(name):
+    """实际解析；可能被 TUN 劫持成 fake-IP。"""
+    infos = socket.getaddrinfo(name, None, socket.AF_INET, socket.SOCK_STREAM)
+    out = []
+    for info in infos:
+        ip = info[4][0]
+        if is_ipv4(ip) and ip not in out:
+            out.append(ip)
+    return out
+
+
+def system_resolve(name, timeout=5.0):
+    """系统解析 + 硬超时：getaddrinfo 在部分环境（iSH/TUN）会长时间卡住，
+    用守护线程 + join(timeout) 兜底，确保调用方最多等 timeout 秒。"""
+    box = {"ips": []}
+
+    def work():
+        try:
+            box["ips"] = _system_resolve_impl(name)
+        except Exception:
+            box["ips"] = []
+
+    th = threading.Thread(target=work, daemon=True)
+    th.start()
+    th.join(timeout)
+    return list(box["ips"])
+
+
+def _parse_dns_json(text, qtype):
+    try:
+        data = json.loads(text)
+    except (ValueError, TypeError):
+        return []
+    want = 1 if qtype == "A" else 28
+    ips = []
+    for ans in (data.get("Answer") or []):
+        if ans.get("type") != want:
+            continue
+        d = str(ans.get("data") or "").strip()
+        if qtype == "A" and is_ipv4(d) and d not in ips:
+            ips.append(d)
+        elif qtype == "AAAA" and ":" in d and d not in ips:
+            ips.append(d)
+    return ips
+
+
+def doh_query(name, qtype="A", timeout=DEFAULT_TIMEOUT, providers=None, fake_ok=False,
+              deadline=None):
+    """DoH 查询：按顺序尝试多个端点；默认过滤 fake-IP 结果。
+    deadline（time.monotonic 秒）用于总时限，避免多端点叠加导致长时间卡住。"""
+    deadline = deadline if deadline is not None else time.monotonic() + max(timeout, 1.0) * 3
+    for base in (providers or DOH_PROVIDERS):
+        remain = deadline - time.monotonic()
+        if remain <= 0.2:
+            break
+        sep = "&" if "?" in base else "?"
+        url = "%s%sname=%s&type=%s" % (
+            base, sep, urllib.parse.quote(str(name), safe=""), qtype)
+        try:
+            req = urllib.request.Request(url, headers={
+                "accept": "application/dns-json",
+                "user-agent": UA,
+            })
+            with urllib.request.urlopen(req, timeout=min(timeout, remain)) as r:
+                ips = _parse_dns_json(r.read(1 << 20).decode("utf-8", "ignore"), qtype)
+        except Exception:
+            continue
+        if not fake_ok:
+            ips = [x for x in ips if not is_fake_ip(x)]
+        if ips:
+            return ips
+    return []
+
+
+def resolve_real(name, prefer="auto", timeout=DEFAULT_TIMEOUT):
+    """解析真实 IP。prefer: auto（系统→DoH）/ system / doh。
+    返回 (ips, source)：source ∈ ip / system / doh / system-fake / fail。
+    """
+    name = str(name or "").strip().rstrip(".")
+    if is_ipv4(name):
+        return [name], "ip"
+    if prefer == "system":
+        ips = system_resolve(name, timeout)
+        return ips, ("system" if ips else "fail")
+    t0 = time.monotonic()
+    sys_ips = system_resolve(name, min(timeout, 5.0)) if prefer == "auto" else []
+    real = [x for x in sys_ips if not is_fake_ip(x)]
+    if real:
+        return real, "system"
+    budget = max(2.0, timeout - (time.monotonic() - t0))
+    doh_ips = doh_query(name, "A", timeout=min(4.0, budget),
+                        deadline=time.monotonic() + budget + 1.0)
+    if doh_ips:
+        return doh_ips, "doh"
+    if sys_ips:
+        return sys_ips, "system-fake"
+    return [], "fail"
+
+
+def fmt_ips(ips):
+    return ",".join(ips) if ips else "-"
+
+
+def _main(argv):
+    args = [a for a in argv[1:] if not a.startswith("-")]
+    flags = [a for a in argv[1:] if a.startswith("-")]
+    if not args:
+        print("用法: python3 netdns.py <domain>... [--doh] [--json]", file=sys.stderr)
+        return 2
+    prefer = "doh" if "--doh" in flags else "auto"
+    rc = 0
+    out = {}
+    for name in args:
+        ips, source = resolve_real(name, prefer=prefer)
+        out[name] = {"ips": ips, "source": source}
+        if not ips:
+            rc = 1
+            print("%s\t-\t[解析失败：TUN/fake-IP？换 DoH 或检查出网]" % name, file=sys.stderr)
+        elif source == "system-fake":
+            rc = 1
+            print("%s\t%s\t[fake-IP：不可信，换 DoH]" % (name, fmt_ips(ips)), file=sys.stderr)
+        else:
+            print("%s\t%s\t[%s]" % (name, fmt_ips(ips), source))
+    if "--json" in flags:
+        print(json.dumps(out, ensure_ascii=False))
+    return rc
+
+
+if __name__ == "__main__":
+    sys.exit(_main(sys.argv))