| """Windows WARP keeper: enforces TUN mode and auto-repairs WARP connections.""" |
| |
| from __future__ import annotations |
| |
| import os |
| import socket |
| import sys |
| import threading |
| import time |
| |
| from ouc_common import ( |
| apply_warp_mode, |
| current_warp_scope, |
| ensure_warp_protocol, |
| KEEPER_LOG_FILE, |
| MUTEX_KEEPER, |
| SERVICE_PROXY_PORT, |
| acquire_mutex, |
| append_log, |
| ensure_dirs, |
| find_warp_cli, |
| get_warp_local_v6, |
| is_admin, |
| is_keeper_paused, |
| record_warp_path, |
| run_warp, |
| trace_warp_path, |
| warp_status, |
| ) |
| from ouc_firewall import install_killswitch, is_killswitch_installed |
| from zen_proxy import start_proxy_server |
| |
| TICK_SECONDS = 45 |
| PROXY_WATCH_SECONDS = 3.0 |
| |
| PATH_CHECK_SECONDS = 20 |
| PATH_REPAIR_GAP = 120 |
| HEARTBEAT_FILE = KEEPER_LOG_FILE.parent / "heartbeat.txt" |
| |
| |
| def _heartbeat() -> None: |
| """Cheap liveness signal the app checks: a running but hung keeper stops writing this.""" |
| try: |
| HEARTBEAT_FILE.write_text(str(int(time.time())), encoding="utf-8") |
| except Exception: |
| pass |
| |
| |
| def _port_listening(port: int) -> bool: |
| try: |
| with socket.create_connection(("127.0.0.1", port), timeout=0.8): |
| return True |
| except OSError: |
| return False |
| |
| |
| def _proxy_watchdog() -> None: |
| """Keep 127.0.0.1:SERVICE_PROXY_PORT served; restart the proxy whenever it disappears.""" |
| servers = [] |
| bind_failing = False |
| while True: |
| try: |
| if not _port_listening(SERVICE_PROXY_PORT): |
| try: |
| srv, bound_port, edge = start_proxy_server(SERVICE_PROXY_PORT) |
| servers.append(srv) |
| append_log(KEEPER_LOG_FILE, f"desktop/service proxy listening on 127.0.0.1:{bound_port} (edge={edge})") |
| bind_failing = False |
| except Exception as exc: |
| if not bind_failing: |
| append_log(KEEPER_LOG_FILE, f"service proxy bind failed on port {SERVICE_PROXY_PORT}: {exc} (retrying)") |
| bind_failing = True |
| except Exception: |
| pass |
| time.sleep(PROXY_WATCH_SECONDS) |
| |
| |
| def _desktop_brand_loop() -> None: |
| """Keep OpenCode Desktop's start screen in line with the openhop.cfd setting (only while it's closed).""" |
| time.sleep(20) |
| last = "" |
| while True: |
| try: |
| import desktop_brand |
| res = desktop_brand.sync() |
| if res not in ("ok", "skip") and res != last: |
| append_log(KEEPER_LOG_FILE, f"desktop wordmark: {res}") |
| last = res |
| except Exception as exc: |
| append_log(KEEPER_LOG_FILE, f"desktop wordmark error: {exc}") |
| time.sleep(120) |
| |
| |
| def _egress_mode() -> str: |
| try: |
| from proxy_chain import get_egress_config |
| return get_egress_config().get("mode", "warp") |
| except Exception: |
| return "warp" |
| |
| |
| def _repair_leaking_warp(warp_bin: str) -> bool: |
| """WARP says Connected but sends traffic out with the real IP: reconnect, then reset the tunnel.""" |
| steps = ( |
| ("reconnecting WARP", [["disconnect"], ["connect"]]), |
| ("resetting the WARP tunnel", [["disconnect"], ["tunnel", "endpoint", "reset"], |
| ["tunnel", "rotate-keys"], ["connect"]]), |
| ) |
| for label, cmds in steps: |
| append_log(KEEPER_LOG_FILE, f"WARP leak repair: {label}") |
| for cmd in cmds: |
| run_warp(cmd, warp_bin=warp_bin) |
| if cmd == ["disconnect"]: |
| time.sleep(1.0) |
| if current_warp_scope() == "isolated": |
| apply_warp_mode("isolated", warp_bin=warp_bin) |
| for _ in range(10): |
| time.sleep(1.5) |
| connected, _, _ = warp_status(warp_bin) |
| if not connected: |
| continue |
| info = trace_warp_path(timeout=6.0) |
| if info: |
| record_warp_path(info) |
| if info.get("warp") in ("on", "plus"): |
| append_log(KEEPER_LOG_FILE, "WARP leak repair: fixed, traffic goes through WARP again") |
| return True |
| if info.get("warp") == "off": |
| break |
| append_log( |
| KEEPER_LOG_FILE, |
| "WARP leak repair: still not fixed. OpenCode is blocked instead of using your own IP. " |
| "Try 'Repair WARP' or restart Cloudflare WARP.", |
| ) |
| return False |
| |
| |
| def _warp_path_watch(warp_bin: str) -> None: |
| """Catch WARP's silent leak: 'Connected', but its proxy sends traffic outside the tunnel.""" |
| time.sleep(10) |
| leaks = 0 |
| last_repair = 0.0 |
| reported = False |
| while True: |
| try: |
| if _egress_mode() in ("warp", "clean") and not is_keeper_paused(): |
| connected, _, _ = warp_status(warp_bin) |
| info = trace_warp_path(timeout=6.0) if connected else {} |
| if info: |
| record_warp_path(info) |
| if info.get("warp") == "off": |
| leaks += 1 |
| if not reported: |
| reported = True |
| append_log( |
| KEEPER_LOG_FILE, |
| "WARP says Connected, but traffic is leaving with your own IP (warp=off). " |
| "Blocking OpenCode traffic and repairing WARP.", |
| ) |
| if leaks >= 2 and time.time() - last_repair >= PATH_REPAIR_GAP and not is_keeper_paused(): |
| last_repair = time.time() |
| if _repair_leaking_warp(warp_bin): |
| leaks = 0 |
| reported = False |
| elif info.get("warp") in ("on", "plus"): |
| if reported: |
| append_log(KEEPER_LOG_FILE, "traffic goes through WARP again") |
| leaks = 0 |
| reported = False |
| except Exception as exc: |
| append_log(KEEPER_LOG_FILE, f"WARP path check error: {exc}") |
| time.sleep(PATH_CHECK_SECONDS) |
| |
| |
| def ensure_connected(warp_bin: str | None = None) -> bool: |
| """Verify WARP connection based on active scope (isolated proxy or full TUN).""" |
| if not warp_bin: |
| warp_bin = find_warp_cli() |
| if not warp_bin: |
| return False |
| |
| scope = current_warp_scope() |
| |
| connected, mode, raw = warp_status(warp_bin) |
| |
| |
| |
| if connected: |
| return True |
| |
| raw_lower = (raw or "").lower() |
| |
| |
| |
| if "connecting" in raw_lower: |
| for _ in range(8): |
| time.sleep(1.0) |
| connected, mode, raw = warp_status(warp_bin) |
| if connected: |
| return True |
| if "connecting" not in (raw or "").lower(): |
| break |
| |
| |
| if scope == "isolated": |
| if not mode or "proxy" not in mode.lower(): |
| apply_warp_mode("isolated", warp_bin=warp_bin) |
| else: |
| |
| ensure_warp_protocol("masque", warp_bin=warp_bin) |
| |
| run_warp(["connect"], warp_bin=warp_bin) |
| for _ in range(8): |
| time.sleep(1.0) |
| connected, _, raw = warp_status(warp_bin) |
| if connected: |
| return True |
| if "connecting" not in (raw or "").lower() and not connected: |
| pass |
| |
| |
| append_log(KEEPER_LOG_FILE, "isolated tunnel disconnected — rotating keys & reconnecting") |
| run_warp(["tunnel", "endpoint", "reset"], warp_bin=warp_bin) |
| run_warp(["tunnel", "rotate-keys"], warp_bin=warp_bin) |
| apply_warp_mode("isolated", warp_bin=warp_bin) |
| run_warp(["connect"], warp_bin=warp_bin) |
| |
| for _ in range(8): |
| time.sleep(1.0) |
| connected, _, _ = warp_status(warp_bin) |
| if connected: |
| return True |
| |
| |
| raw_check = (raw or "").lower() |
| if "registration missing" in raw_check or "not registered" in raw_check: |
| append_log(KEEPER_LOG_FILE, "registration missing — registering fresh WARP client") |
| run_warp(["registration", "new"], warp_bin=warp_bin) |
| apply_warp_mode("isolated", warp_bin=warp_bin) |
| run_warp(["connect"], warp_bin=warp_bin) |
| time.sleep(3) |
| connected, _, _ = warp_status(warp_bin) |
| |
| return connected |
| |
| |
| if not mode or "warp" not in mode.lower(): |
| run_warp(["mode", "warp"], warp_bin=warp_bin) |
| |
| run_warp(["connect"], warp_bin=warp_bin) |
| for _ in range(8): |
| time.sleep(1.0) |
| connected, _, raw = warp_status(warp_bin) |
| if connected: |
| return True |
| if "connecting" not in (raw or "").lower() and not connected: |
| pass |
| |
| append_log(KEEPER_LOG_FILE, "TUN tunnel disconnected — rotating keys & reconnecting") |
| run_warp(["tunnel", "endpoint", "reset"], warp_bin=warp_bin) |
| run_warp(["tunnel", "rotate-keys"], warp_bin=warp_bin) |
| run_warp(["mode", "warp"], warp_bin=warp_bin) |
| run_warp(["connect"], warp_bin=warp_bin) |
| |
| for _ in range(8): |
| time.sleep(1.0) |
| connected, _, _ = warp_status(warp_bin) |
| if connected: |
| return True |
| |
| raw_check = (raw or "").lower() |
| if "registration missing" in raw_check or "not registered" in raw_check: |
| append_log(KEEPER_LOG_FILE, "registration missing — registering fresh TUN client") |
| run_warp(["registration", "new"], warp_bin=warp_bin) |
| run_warp(["mode", "warp"], warp_bin=warp_bin) |
| run_warp(["connect"], warp_bin=warp_bin) |
| time.sleep(4) |
| connected, _, _ = warp_status(warp_bin) |
| |
| return connected |
| |
| |
| def main() -> int: |
| ensure_dirs() |
| mutex = acquire_mutex(MUTEX_KEEPER) |
| if mutex is None: |
| return 0 |
| |
| warp_bin = find_warp_cli() |
| append_log(KEEPER_LOG_FILE, f"keeper up (tick={TICK_SECONDS}s, warp={'found' if warp_bin else 'none'})") |
| _heartbeat() |
| |
| |
| |
| |
| threading.Thread(target=_proxy_watchdog, daemon=True).start() |
| threading.Thread(target=_desktop_brand_loop, daemon=True).start() |
| if warp_bin: |
| threading.Thread(target=_warp_path_watch, args=(warp_bin,), daemon=True).start() |
| for _ in range(40): |
| if _port_listening(SERVICE_PROXY_PORT): |
| break |
| time.sleep(0.25) |
| |
| |
| if warp_bin: |
| for _ in range(6): |
| rc, _ = run_warp(["status"], warp_bin=warp_bin, timeout=8.0) |
| if rc == 0: |
| break |
| time.sleep(8) |
| |
| while True: |
| try: |
| _heartbeat() |
| mode = "warp" |
| try: |
| from proxy_chain import get_egress_config |
| mode = get_egress_config().get("mode", "warp") |
| except Exception: |
| pass |
| |
| if mode in ("warp", "clean"): |
| if warp_bin and not is_keeper_paused(): |
| ensure_connected(warp_bin) |
| if is_admin() and ( |
| os.environ.get("OUC_FIREWALL_KILLSWITCH") == "1" |
| or is_killswitch_installed() |
| ): |
| if not is_killswitch_installed(): |
| install_killswitch() |
| elif mode == "tor": |
| |
| try: |
| from tor_manager import get_active_tor_target, is_portable_tor_running, start_portable_tor |
| if not get_active_tor_target() and is_portable_tor_running(): |
| start_portable_tor() |
| except Exception: |
| pass |
| except Exception as exc: |
| append_log(KEEPER_LOG_FILE, f"keeper error: {exc}") |
| time.sleep(TICK_SECONDS) |
| |
| |
| if __name__ == "__main__": |
| raise SystemExit(main()) |