openhop

srcSource code

Source code

Every file of openhop's latest version, exactly as published. Read anything, or download it all as a zip.

Commit
c8cfb4c
Date
16 Nov 2026
Files
62 files
Download the source (zip)

zip · 758 KB · SHA-256 6ce65b028777bf92…

clean_endpoint.py

147 lines · 5.3 KB · Python

"""Clean Cloudflare WARP endpoint switcher for restricted countries."""
from __future__ import annotations
import platform
import re
import socket
import subprocess
import time
from ouc_common import find_warp_cli, run_warp, warp_status
KNOWN_CLEAN_ENDPOINTS = (
# Standard Cloudflare WireGuard (Port 2408)
"162.159.192.1:2408",
"162.159.192.2:2408",
"162.159.193.1:2408",
"162.159.193.5:2408",
"162.159.195.1:2408",
"188.114.96.1:2408",
"188.114.97.1:2408",
"188.114.98.1:2408",
"188.114.99.1:2408",
# Alternative Port 500 (IPsec IKE — universally unblocked by ISPs)
"162.159.192.1:500",
"162.159.193.1:500",
"188.114.96.1:500",
"188.114.97.1:500",
# Alternative Port 4500 (IPsec NAT-T — bypasses UDP 2408 filtering)
"162.159.192.1:4500",
"162.159.193.1:4500",
"188.114.96.1:4500",
"188.114.97.1:4500",
# Alternative Port 1701 (L2TP / Anycast bypass)
"162.159.192.1:1701",
"162.159.193.1:1701",
# High-port Cloudflare WireGuard endpoints
"162.159.192.1:854",
"162.159.193.1:854",
"162.159.192.1:880",
"162.159.193.1:880",
)
def test_endpoint_latency(endpoint: str, timeout: float = 1.5) -> float | None:
"""Measure round-trip latency to a Cloudflare WireGuard endpoint in milliseconds."""
host, _, _ = endpoint.rpartition(":")
host = (host or endpoint).strip()
is_win = platform.system().lower() == "windows"
timeout_ms = max(500, int(timeout * 1000))
cmd = (
["ping", "-n", "1", "-w", str(timeout_ms), host]
if is_win
else ["ping", "-c", "1", "-W", str(max(1, int(timeout))), host]
)
try:
proc = subprocess.run(cmd, capture_output=True, text=True, errors="replace", timeout=timeout + 0.5)
if proc.returncode == 0:
m = re.search(r"time[=<](\d+(?:\.\d+)?)\s*ms", proc.stdout, re.IGNORECASE)
if m:
return round(float(m.group(1)), 1)
return 1.0
except Exception:
pass
# Fallback to TCP ping if ICMP is dropped by local policy
t0 = time.perf_counter()
try:
with socket.create_connection((host, 80), timeout=timeout):
return round((time.perf_counter() - t0) * 1000.0, 1)
except Exception:
return None
def set_custom_endpoint(endpoint: str) -> tuple[bool, str]:
"""Force Cloudflare WARP client to connect via a specific endpoint IP:PORT."""
warp_bin = find_warp_cli()
if not warp_bin:
return False, "Cloudflare warp-cli.exe not found."
# Ensure WireGuard protocol is active to avoid MASQUE HTTP/3 MITM errors (CF_HAPPY_EYEBALLS_MITM_FAILURE).
# Only set protocol if not already WireGuard, to prevent unnecessary tunnel teardown.
try:
from ouc_common import ensure_warp_protocol, preferred_warp_protocol
ensure_warp_protocol(preferred_warp_protocol(), warp_bin=warp_bin)
except Exception:
pass
rc, msg = run_warp(["tunnel", "endpoint", "set", endpoint.strip()], warp_bin=warp_bin)
if rc == 0:
run_warp(["tunnel", "rotate-keys"], warp_bin=warp_bin)
run_warp(["connect"], warp_bin=warp_bin)
for _ in range(6):
time.sleep(0.8)
conn, _, raw = warp_status(warp_bin)
raw_low = raw.lower()
# "unstable" simply means ping latency is elevated; traffic still flows normally!
if conn and "unable" not in raw_low and "mitm" not in raw_low:
return True, f"Cloudflare WARP endpoint connected to {endpoint} (WireGuard)."
return True, f"Cloudflare WARP endpoint set to {endpoint} (handshake establishing...)."
return False, f"Failed to set endpoint: {msg}"
def reset_custom_endpoint() -> tuple[bool, str]:
"""Reset Cloudflare WARP endpoint to official default with WireGuard protocol."""
warp_bin = find_warp_cli()
if not warp_bin:
return False, "Cloudflare warp-cli.exe not found."
run_warp(["tunnel", "endpoint", "reset"], warp_bin=warp_bin)
try:
from ouc_common import ensure_warp_protocol, preferred_warp_protocol
ensure_warp_protocol(preferred_warp_protocol(), warp_bin=warp_bin)
except Exception:
pass
run_warp(["tunnel", "rotate-keys"], warp_bin=warp_bin)
run_warp(["connect"], warp_bin=warp_bin)
return True, "Cloudflare WARP endpoint reset to official default (WireGuard protocol)."
def auto_heal_warp_endpoint(timeout: float = 1.0) -> tuple[bool, str]:
"""Benchmark clean endpoints concurrently and connect to the fastest available one."""
from concurrent.futures import ThreadPoolExecutor
results: list[tuple[float, str]] = []
with ThreadPoolExecutor(max_workers=10) as executor:
future_map = {
executor.submit(test_endpoint_latency, ep, timeout): ep
for ep in KNOWN_CLEAN_ENDPOINTS
}
for fut in future_map:
ep = future_map[fut]
try:
lat = fut.result()
if lat is not None:
results.append((lat, ep))
except Exception:
pass
if not results:
return False, "No responsive clean endpoints found."
results.sort(key=lambda x: x[0])
fastest_lat, fastest_ep = results[0]
ok, msg = set_custom_endpoint(fastest_ep)
if ok:
return True, f"Auto-healed connection using {fastest_ep} ({fastest_lat}ms)"
return False, msg