procproxy 0.1.0__py3-none-any.whl

proxycore/backend/windivert/filter.py

@@ -0,0 +1,123 @@
+"""路线 A 的 WinDivert 过滤器表达式构造。
+
+一条表达式要同时满足四件事，漏一条就会成环或卡死：
+
+* 抓所有出向 TCP，不只 SYN。整条连接两个方向都要改写，只抓 SYN 会在握手第二包断。
+* 排除回环。改道后应用连的是 127.0.0.1:<sink>，不排除会自我循环。
+* 排除 sink 端口，回环之外再加一道。
+* 排除上游代理和本地 DNS 的 IP。拦截器自己连上游会被再次捕获，同样成环。
+
+地址族：ip.DstAddr 只匹配 IPv4，ipv6.DstAddr 才匹配 IPv6（没有 ipv4. 前缀）。
+官方文档明确"字段与报文不相关时该 test 判为 false"，所以含 ip.DstAddr 的表达式
+永远不匹配 IPv6 报文。要覆盖 v6 必须另开一个句柄、用 ipv6.* 写第二条表达式，
+本函数不试图在一条表达式里同时管两个族。
+
+上游地址如果是域名，解析结果会变，而改过滤表达式要重开句柄。所以静态场景由
+build_filter() 排除，用户态在每次 redirect() 前再判一次。
+"""
+
+from __future__ import annotations
+
+import ipaddress
+from collections.abc import Iterable
+
+LOOPBACK_V4 = "127.0.0.1"
+LOOPBACK_V6 = "::1"
+
+
+def _normalize_ips(values: Iterable[str], *, version: int | None = None) -> list[str]:
+    """过滤出合法的 IP 字面量。
+
+    `version` 给出时只保留该地址族：WinDivert 的字段命名空间是按族分的
+    （`ip.*` 对 IPv4、`ipv6.*` 对 IPv6），把 v4 地址写进 v6 表达式等于没写。
+    """
+    out: list[str] = []
+    for value in values:
+        value = str(value).strip()
+        if not value:
+            continue
+        # 只接受 IP 字面量；域名不能出现在 WinDivert 表达式里
+        try:
+            parsed = ipaddress.ip_address(value)
+        except ValueError:
+            continue
+        if version is not None and parsed.version != version:
+            continue
+        if value not in out:
+            out.append(value)
+    return out
+
+
+def build_filter(
+    *,
+    sink_addr: str = "",
+    sink_port: int = 19080,
+    exclude_ips: Iterable[str] = (),
+    ipv6: bool = False,
+    sniffer: bool = False,
+) -> str:
+    """构造过滤器表达式。
+
+    `sink_addr` 留空时按 `ipv6` 取默认回环地址（v4 用 `127.0.0.1`、v6 用 `::1`）。
+    `sniffer=True` 加 `sniff`：只观察不拦截，`--dry-run` 用。
+
+    `ipv6=True` 产出的是给第二个句柄用的那条表达式（见模块 docstring 的地址族说明）。
+    两个分支互不排除对方的回环：v4 表达式里写 `ipv6.DstAddr != ::1` 恒真，没有意义，
+    反过来同理。代价是 `ipv6=False` 时 v6 流量整体静默漏过，调用方必须明确这一点。
+    """
+    family = 6 if ipv6 else 4
+    ns = "ipv6" if ipv6 else "ip"
+    loopback = LOOPBACK_V6 if ipv6 else LOOPBACK_V4
+
+    sink_addr = sink_addr or loopback
+    clauses: list[str] = ["tcp", f"(outbound or tcp.SrcPort == {int(sink_port)})"]
+    clauses.append(f"tcp.DstPort != {int(sink_port)}")
+
+    # 本族回环地址永不代理，但 sink 的应答必须放行。
+    #
+    # 改道后整条连接都在回环里流动：
+    #   正向  127.0.0.1:客户端端口 → 127.0.0.1:<sink>
+    #   反向  127.0.0.1:<sink>     → 127.0.0.1:客户端端口
+    # 反向包的目的地址也是回环，整段排除会连 sink 的应答一起丢掉。症状是改道日志
+    # 正常、sink 也 accept 了，客户端却收不到响应而超时。
+    # 所以只放行源端口等于 sink 端口的那一类：那一定是 sink 的应答，
+    # 不可能是应用自己发起的回环连接。
+    clauses.append(f"({ns}.DstAddr != {loopback} or tcp.SrcPort == {int(sink_port)})")
+
+    # sink 自己也要排除（sink 不在回环上时上面那条盖不住）
+    if sink_addr and sink_addr != loopback:
+        clauses.append(f"{ns}.DstAddr != {sink_addr}")
+
+    for addr in _normalize_ips(exclude_ips, version=family):
+        if addr in (sink_addr, loopback):
+            continue  # 上面已写过，再写一遍会重复
+        clauses.append(f"{ns}.DstAddr != {addr}")
+
+    expr = " and ".join(clauses)
+    if sniffer:
+        expr += " and sniff"
+    return expr
+
+
+def upstream_ips_from_config(config: object) -> list[str]:
+    """从配置里取上游地址（用于过滤器排除与用户态二次校验）。"""
+    profile = getattr(config, "profile", None)
+    upstreams = getattr(profile, "upstreams", {}) or {}
+    out: list[str] = []
+    for upstream in upstreams.values():
+        host = str(getattr(upstream, "host", "")).strip()
+        if not host:
+            continue
+        try:
+            ipaddress.ip_address(host)
+        except ValueError:
+            continue  # 域名：需要先解析，交给用户态判断
+        if host not in out:
+            out.append(host)
+    dns = str(getattr(profile, "dns_local_server", "") or "").strip()
+    if dns and dns not in out:
+        out.append(dns)
+    return out
+
+
+__all__ = ["build_filter", "upstream_ips_from_config"]

proxycore/backend/windivert/pidmap.py

@@ -0,0 +1,289 @@
+"""路线 A · `local_port → PID` 查表（等价于内核 ALE 层拿到的 `PROCESS_ID`）。
+
+`GetExtendedTcpTable(TCP_TABLE_OWNER_PID_ALL)` 在 SYN 发出后通常能查到
+该连接（状态 `SYN_SENT=3`），但存在窗口。工程处理：
+
+1. 先按 `local_port` 精确匹配（并校验 remote 一致）；
+2. 不中 → 最多 3 次、每次 3ms 后刷新重试；
+3. 仍不中 → 按 `(raddr, rport)` 反查兜底（同机同目标并发少时可用）；
+4. 返回 0 表示未知 → 核心按 `on_unknown_pid` 策略处理并记 WARN。
+
+禁止用 `GetTcpTable`（不带 PID 的版本）， 明令禁止项。
+"""
+
+from __future__ import annotations
+
+import socket
+import struct
+import threading
+import time
+from dataclasses import dataclass
+from typing import Any
+
+from ...log import EventLogger, get_logger
+
+LOG = EventLogger(get_logger("proxycore.backend.windivert.pidmap"))
+
+AF_INET = 2
+AF_INET6 = 23
+TCP_TABLE_OWNER_PID_ALL = 5
+UDP_TABLE_OWNER_PID = 1
+
+# MIB_TCPROW_OWNER_PID: state, localAddr, localPort, remoteAddr, remotePort, pid (每项 4 字节)
+TCP_ROW_SIZE = 24
+TCP6_ROW_SIZE = 56  # + scope ids 与 16 字节地址
+UDP_ROW_SIZE = 12
+UDP6_ROW_SIZE = 28
+
+STATE_SYN_SENT = 3
+STATE_ESTABLISHED = 5
+
+DEFAULT_RETRIES = 3
+DEFAULT_RETRY_DELAY_S = 0.003
+DEFAULT_TTL_S = 0.25
+
+_UNKNOWN_PID = 0
+
+
+@dataclass(frozen=True, slots=True)
+class TcpRow:
+    state: int
+    local_port: int
+    local_addr: str
+    remote_addr: str
+    remote_port: int
+    pid: int
+    is_v6: bool = False
+
+
+class PortPidTable:
+    """带 TTL 的 `local_port → TcpRow` 快照表。
+
+    只用于首次建表与兜底反查；热点路径是"命中即返回"。
+    """
+
+    def __init__(self, *, ttl_s: float = DEFAULT_TTL_S) -> None:
+        self.ttl_s = ttl_s
+        self._lock = threading.RLock()
+        self._by_port: dict[tuple[bool, int], TcpRow] = {}
+        self._rows: list[TcpRow] = []
+        self._refreshed_at = 0.0
+        self.refresh_count = 0
+        self.last_error = ""
+
+    # ------------------------------------------------------------ 刷新 -----
+    def refresh(self, *, force: bool = False) -> None:
+        with self._lock:
+            now = time.monotonic()
+            if not force and self._rows and now - self._refreshed_at < self.ttl_s:
+                return
+            rows: list[TcpRow] = []
+            try:
+                rows.extend(_read_tcp_table(AF_INET))
+                rows.extend(_read_tcp_table(AF_INET6))
+            except OSError as exc:
+                self.last_error = str(exc)
+                LOG.warn(
+                    "pidmap_refresh_failed",
+                    error=str(exc),
+                    hint="需要管理员权限；路线 A 必须有管理员才能查全表",
+                )
+                return
+            self._rows = rows
+            self._by_port = {(row.is_v6, row.local_port): row for row in rows}
+            self._refreshed_at = now
+            self.refresh_count += 1
+
+    # ------------------------------------------------------------ 查询 -----
+    def lookup(
+        self,
+        local_port: int,
+        remote_addr: str | None = None,
+        remote_port: int | None = None,
+        *,
+        is_v6: bool = False,
+        retries: int = DEFAULT_RETRIES,
+        retry_delay_s: float = DEFAULT_RETRY_DELAY_S,
+    ) -> int:
+        """返回 PID；查不到返回 0（未知），绝不猜。"""
+        for attempt in range(max(1, retries)):
+            self.refresh(force=attempt > 0)
+            row = self._match_local(local_port, remote_addr, remote_port, is_v6)
+            if row is not None:
+                return row.pid
+            if attempt < retries - 1:
+                time.sleep(retry_delay_s)
+        # 兜底：按 (raddr, rport) 反查
+        row = self._match_remote(remote_addr, remote_port)
+        if row is not None:
+            return row.pid
+        return _UNKNOWN_PID
+
+    def all_rows(self) -> list[TcpRow]:
+        self.refresh()
+        with self._lock:
+            return list(self._rows)
+
+    def stats(self) -> dict[str, Any]:
+        with self._lock:
+            return {
+                "rows": len(self._rows),
+                "refreshes": self.refresh_count,
+                "last_error": self.last_error,
+                "ttl_s": self.ttl_s,
+            }
+
+    # ------------------------------------------------------------ 匹配 -----
+    def _match_local(
+        self, local_port: int, remote_addr: str | None, remote_port: int | None, is_v6: bool
+    ) -> TcpRow | None:
+        with self._lock:
+            row = self._by_port.get((is_v6, local_port)) or self._by_port.get((not is_v6, local_port))
+        if row is None:
+            return None
+        if remote_addr and remote_port:
+            if row.remote_addr == remote_addr and row.remote_port == remote_port:
+                return row
+            # 端口撞车（TIME_WAIT 复用）→ 继续找同端口里 remote 匹配的那条
+            with self._lock:
+                for candidate in self._rows:
+                    if (
+                        candidate.local_port == local_port
+                        and candidate.remote_addr == remote_addr
+                        and candidate.remote_port == remote_port
+                    ):
+                        return candidate
+            return None
+        return row
+
+    def _match_remote(self, remote_addr: str | None, remote_port: int | None) -> TcpRow | None:
+        if not remote_addr or not remote_port:
+            return None
+        with self._lock:
+            for row in self._rows:
+                if row.remote_addr == remote_addr and row.remote_port == remote_port:
+                    return row
+        return None
+
+
+# ---------------------------------------------------------- 系统调用 -------
+def _iphlpapi() -> Any:
+    import ctypes
+    import ctypes.wintypes as wintypes
+
+    lib = ctypes.WinDLL("iphlpapi", use_last_error=True)
+    lib.GetExtendedTcpTable.argtypes = [
+        wintypes.LPVOID,
+        ctypes.POINTER(wintypes.DWORD),
+        wintypes.BOOL,
+        wintypes.ULONG,
+        wintypes.ULONG,
+        wintypes.ULONG,
+    ]
+    lib.GetExtendedTcpTable.restype = wintypes.DWORD
+    return lib
+
+
+def _read_tcp_table(family: int) -> list[TcpRow]:
+    """读 `GetExtendedTcpTable(TCP_TABLE_OWNER_PID_ALL)`；失败抛 OSError。"""
+    import ctypes
+    import ctypes.wintypes as wintypes
+
+    lib = _iphlpapi()
+    size = wintypes.DWORD(0)
+    rc = lib.GetExtendedTcpTable(None, ctypes.byref(size), False, family, TCP_TABLE_OWNER_PID_ALL, 0)
+    if rc not in (0, 122):  # 122 = ERROR_INSUFFICIENT_BUFFER
+        raise OSError(rc, f"GetExtendedTcpTable(size) 失败 rc={rc}")
+    if size.value == 0:
+        return []
+
+    buf = ctypes.create_string_buffer(size.value)
+    rc = lib.GetExtendedTcpTable(buf, ctypes.byref(size), False, family, TCP_TABLE_OWNER_PID_ALL, 0)
+    if rc != 0:
+        raise OSError(rc, f"GetExtendedTcpTable(data) 失败 rc={rc}")
+
+    raw = bytes(buf.raw[: size.value])
+    count = struct.unpack_from("<I", raw, 0)[0]
+    return _decode_rows(raw, count, family)
+
+
+def _decode_rows(raw: bytes, count: int, family: int) -> list[TcpRow]:
+    """解析 `MIB_TCPTABLE_OWNER_PID` / `MIB_TCP6TABLE_OWNER_PID` 的裸字节。
+
+    Windows 结构一律是小端（不要用 `!`）。两个结构的字段顺序不一样，
+    这是最容易写错的地方：
+
+    v4 `MIB_TCPROW_OWNER_PID`（每项 24 字节）， `dwState` 在最前：
+        0 state / 4 localAddr(4) / 8 localPort / 12 remoteAddr(4) / 16 remotePort / 20 pid
+
+    v6 `MIB_TCP6ROW_OWNER_PID`（每项 56 字节）， `dwState` 在第 7 位，地址在最前：
+        0 localAddr(16) / 16 localScopeId / 20 localPort /
+        24 remoteAddr(16) / 40 remoteScopeId / 44 remotePort / 48 state / 52 pid
+
+    > 2026-10-01 真机实测：v6 分支早期照搬了 v4 的"state 在前"，于是整行错位
+    > 解出来的 `local_port` 恒为 0、`remote_port` 其实读的是 `dwState`（监听的套接字
+    > 解出 `state=2`）。后果是所有 v6 连接都查不到 PID，按 `on_unknown_pid=direct`
+    > 直接放行 = 真实 IP 泄漏。单测当时和实现犯了同一个错，所以两边都"通过"；
+    > 是 `pidmap_v6_probe.py` 对着真表才暴露出来。
+
+    `dwLocalPort`/`dwRemotePort` 的低 16 位是网络序端口（用 `socket.ntohs` 还原）。
+    """
+    rows: list[TcpRow] = []
+    is_v6 = family == AF_INET6
+    row_size = TCP6_ROW_SIZE if is_v6 else TCP_ROW_SIZE
+    offset = 4  # 跳过 dwNumEntries
+    for _ in range(count):
+        if offset + row_size > len(raw):
+            break
+        if is_v6:
+            local_addr = socket.inet_ntop(socket.AF_INET6, raw[offset : offset + 16])
+            local_port = _ntoh_port(struct.unpack_from("<I", raw, offset + 20)[0])
+            remote_addr = socket.inet_ntop(socket.AF_INET6, raw[offset + 24 : offset + 40])
+            remote_port = _ntoh_port(struct.unpack_from("<I", raw, offset + 44)[0])
+            state = struct.unpack_from("<I", raw, offset + 48)[0]
+            pid = struct.unpack_from("<I", raw, offset + 52)[0]
+        else:
+            state = struct.unpack_from("<I", raw, offset)[0]
+            local_addr = socket.inet_ntoa(raw[offset + 4 : offset + 8])
+            local_port = _ntoh_port(struct.unpack_from("<I", raw, offset + 8)[0])
+            remote_addr = socket.inet_ntoa(raw[offset + 12 : offset + 16])
+            remote_port = _ntoh_port(struct.unpack_from("<I", raw, offset + 16)[0])
+            pid = struct.unpack_from("<I", raw, offset + 20)[0]
+        rows.append(
+            TcpRow(
+                state=state,
+                local_port=local_port,
+                local_addr=local_addr,
+                remote_addr=remote_addr,
+                remote_port=remote_port,
+                pid=pid,
+                is_v6=is_v6,
+            )
+        )
+        offset += row_size
+    return rows
+
+
+def _ntoh_port(dw_port: int) -> int:
+    """`dwLocalPort` 的低 16 位是网络序端口。"""
+    return socket.ntohs(dw_port & 0xFFFF)
+
+
+def is_supported() -> bool:
+    import os
+
+    return os.name == "nt"
+
+
+__all__ = [
+    "AF_INET",
+    "AF_INET6",
+    "DEFAULT_RETRIES",
+    "STATE_ESTABLISHED",
+    "STATE_SYN_SENT",
+    "TCP_TABLE_OWNER_PID_ALL",
+    "UDP_TABLE_OWNER_PID",
+    "PortPidTable",
+    "TcpRow",
+    "is_supported",
+]