argo-search 2.9.8 → 2.9.9

package/scripts/url_safety.py

@@ -23,6 +23,8 @@ import ipaddress
 import os
 import re
 import socket
+import time
+import urllib.parse
 from urllib.parse import urlparse
 
 
@@ -184,9 +186,10 @@ def host_is_private(host: str) -> bool:
     if host_is_private_name(host):
         return True
     norm = _normalize_numeric_host(host)
-    if norm is not None and norm != host:
-        # 数字字面量变体：直接按规范化结果查表，不依赖各系统对
-        # 八进制/十六进制/单段整数解析行为的一致性
+    if norm is not None:
+        # 数字字面量：直接按规范化结果查表，不依赖 getaddrinfo。
+        # 标准点分形式（norm == host）此前会落到 getaddrinfo——既多一次系统
+        # 调用，又让「被 mock/劫持的解析器」能影响 SSRF 判定。
         return is_private_ip(norm)
     try:
         infos = socket.getaddrinfo(host, None, proto=socket.IPPROTO_TCP)
@@ -234,3 +237,123 @@ def is_safe_fetch_url(url: str) -> bool:
     """便捷布尔封装：仅 http/https 且目标非私有地址。"""
     ok, _ = check_url(url)
     return ok
+
+
+def max_redirects() -> int:
+    """最大重定向跳数（默认 5，合法 1-20，越界回落默认）。"""
+    try:
+        from engine_env import get_env
+        val = int(str(get_env(["ARGO_MAX_REDIRECTS"])).strip())
+    except (TypeError, ValueError):
+        return 5
+    return val if 0 < val <= 20 else 5
+
+
+def check_redirect_target(url: str, start: float) -> dict | None:
+    """校验重定向目标是否可安全请求；被拦截返回统一错误 dict，放行返回 None。
+
+    与 resolve_redirect_chain 的逐跳校验对齐——此前 _do_get/_do_post 的
+    内联重定向循环只校验首跳，重定向到内网即可绕过 SSRF。
+    """
+    ok, reason = check_url(url)
+    if ok:
+        return None
+    return {
+        "status": 0, "headers": {}, "text": "",
+        "url": url,
+        "elapsed_ms": int((time.time() - start) * 1000),
+        "error": f"重定向目标被 SSRF 防护拦截: {reason}",
+    }
+
+
+def resolve_redirect_chain(url: str, headers: dict, timeout: float,
+                           limit: int | None = None) -> str | None:
+    """逐跳安全跟随重定向：每跳目标都过 SSRF 校验（curl 通道用）。
+
+    返回最终 URL；任一跳被拦截或超过跳数返回 None。
+    """
+    if limit is None:
+        limit = max_redirects()
+    current = url
+    for _ in range(limit):
+        ok, _reason = check_url(current)
+        if not ok:
+            return None
+        parsed = urlparse(current)
+        if parsed.scheme not in ("http", "https"):
+            return None
+        try:
+            from net_proxy import open_connection, request_selector, resolve_proxy
+            proxy_url = resolve_proxy(current)
+            conn, via_proxy = open_connection(parsed, timeout, proxy_url)
+            path = parsed.path or "/"
+            if parsed.query:
+                path += "?" + parsed.query
+            conn.request("HEAD", request_selector(parsed, path, via_proxy),
+                         headers=headers)
+            resp = conn.getresponse()
+            status = resp.status
+            location = resp.getheader("Location")
+            conn.close()
+        except Exception:
+            return None
+        if status not in (301, 302, 303, 307, 308) or not location:
+            return current
+        current = urllib.parse.urljoin(current, location)
+    return None
+
+
+# ── 解析即锁定（DNS rebinding / TOCTOU 防护）─────────────────────────────────
+#
+# check_url() 在请求前解析一次 DNS，http.client 在 connect() 时再解析一次——
+# 两次之间域名可改指内网（DNS rebinding）。下面两个连接类在 connect() 里
+# 解析一次、过滤私网、把结果钉给本次 TCP 连接，窗口关闭；SNI/Host 仍用原域名。
+
+
+def _is_ip_literal(host: str) -> bool:
+    """主机名是否为 IP 字面量（v4 / v6，含 [v6] 与 IPv4-mapped）。"""
+    h = (host or "").strip().strip("[]")
+    if not h:
+        return False
+    if ":" in h:            # IPv6（含 ::ffff:a.b.c.d）
+        return True
+    parts = h.split(".")
+    return len(parts) == 4 and all(p.isdigit() for p in parts)
+
+
+def resolve_public_addresses(host: str) -> list[str]:
+    """解析主机名 → 公网地址名单（过滤私网/保留段；fake-ip 占位段放行）。
+
+    返回空列表表示「无可连的公网地址」——调用方应拒绝连接（fail-closed）。
+    """
+    try:
+        infos = socket.getaddrinfo(host, None, proto=socket.IPPROTO_TCP)
+    except OSError:
+        return []
+    out: list[str] = []
+    seen: set[str] = set()
+    for info in infos:
+        ip = info[4][0]
+        if ip in seen:
+            continue
+        seen.add(ip)
+        if is_fake_ip_address(ip):      # 代理接管域名（占位段），不可直达内网
+            out.append(ip)
+            continue
+        if is_private_ip(ip):
+            continue
+        out.append(ip)
+    return out
+
+
+def pin_host(host: str) -> str | None:
+    """返回要钉扎的公网 IP；IP 字面量或显式放行私网时返回 None。
+
+    无可连的公网地址则抛错（fail-closed）。供 safe_conn 的连接类使用。
+    """
+    if allow_private() or _is_ip_literal(host):
+        return None
+    addrs = resolve_public_addresses(host)
+    if not addrs:
+        raise OSError(f"SSRF 防护：{host} 无可连的公网地址")
+    return addrs[0]

package/scripts/usage_log.py

@@ -6,6 +6,7 @@
   - 失败静默：任何异常都吞掉返回 False，绝不拖累搜索主路径
   - 目录可注入：ARGO_USAGE_LOG_DIR 覆盖（测试隔离），默认 <状态目录>/usage_log/
   - 总开关：ARGO_USAGE_LOG=0 / false 完全关闭
+  - 夹具守卫：query 流 engines_used 出现注册表外引擎名即判测试夹具，整条拒写
   - 脱敏：query 等敏感字段由调用方截断，本模块不放大
 
 Schema（每条一行 JSON，UTF-8）：
@@ -68,6 +69,40 @@ def _enabled() -> bool:
     return env_flag("ARGO_USAGE_LOG")
 
 
+# 引擎改名前的历史别名（表外但真实）：与 usage_log_clean._ALIAS_KEEP 同一账。
+_RENAMED_ALIAS_KEEP = frozenset({"openlibrary", "bing"})
+
+
+def _canonical_engines() -> frozenset[str]:
+    """注册表引擎名全集（含历史别名豁免）。注册表加载失败返回空集——
+    守卫随之失效放行（fail-open）：守卫是防脏数据的，不能反过来丢真日志。
+
+    不做外层缓存：available_engines 走 get_registry 的 mtime 指纹自愈，每次
+    现取才能看见「daemon 常驻期间新增的本地引擎」；外层冻结只会把新引擎的
+    真日志误杀成夹具。每次构建 frozenset 是微秒级，query 流每搜索只写一条。
+    """
+    try:
+        from engines import available_engines
+        return frozenset(available_engines()) | _RENAMED_ALIAS_KEEP
+    except Exception:
+        return frozenset()
+
+
+def _fixture_engines(record: dict[str, Any]) -> list[str]:
+    """query 记录里的注册表外引擎名（别名豁免后）。
+
+    engines_used 缺失/非列表/为空一律视为无夹具信号：真实搜索的该字段
+    永远是引擎 id 列表，守卫只对「有列表且含表外名」的形态做判定。
+    """
+    used = record.get("engines_used")
+    if not isinstance(used, list) or not used:
+        return []
+    canon = _canonical_engines()
+    if not canon:
+        return []
+    return [e for e in used if not isinstance(e, str) or e not in canon]
+
+
 def emit(stream: str, record: dict[str, Any]) -> bool:
     """追加一条日志记录到 <usage_log_dir>/<stream>.jsonl。
 
@@ -75,6 +110,16 @@ def emit(stream: str, record: dict[str, Any]) -> bool:
     """
     if not _enabled():
         return False
+    if stream == "query" and _fixture_engines(record):
+        # 夹具守卫（2026-10-25）：测试夹具引擎名（fast / slow / quick_primary
+        # 这类注册表外名）屡次写进生产 query.jsonl（conftest 的
+        # ARGO_USAGE_LOG=0 与 is_synthetic_run 的黑名单各漏过一批，最近一次
+        # 2026-10-24），stats 的均值与最慢/高频引擎榜随之失真。黑名单永远
+        # 追不全新夹具名，这里在唯一落盘口用注册表白名单反向判定：表外名
+        # 即夹具，整条拒写。存量清理走 usage_log_clean.py（隔离不删除）。
+        # 只拦 query 流：route/recovery 的字段形态与测试惯例不同（route 的
+        # 格式测试本身用 e0..e14 假名），且实测污染只发生在 query 流。
+        return False
     try:
         line = json.dumps(
             {