""" Proxy God — GUI Tabs: Live | Chain Builder | Browser | Privacy | Settings """ from __future__ import annotations import logging import queue import sys import threading import time from dataclasses import asdict from datetime import datetime from typing import Any, Literal from tkinter import filedialog import customtkinter as ctk from .config import ( LISTEN_HOST, OBFUSCATION_LABELS, OBFUSCATION_MODES, Settings, load_settings, merge_proxy_credentials, normalize_proxy_url, redact_proxy_url, save_settings, split_proxy_for_edit, ) from .firewall import ( disengage as fw_disengage, is_admin, is_engaged as fw_is_engaged, request_admin_relaunch, ) from .dns_leak import check_dns_leak_hint, flush_dns_cache from .browser_launcher import ( BrowserConfig, BrowserSession, default_firefox_path, default_profile_dir, ) from .fingerprint import audit_device from .gui_validate import run_validate_each_sync from .paths import app_data_dir from .proxy_picker import show_proxy_picker from .service import ChainService from .sysproxy import clear_system_proxy, is_system_proxy_set from .tray import TrayIcon from .vpn_detect import detect_vpn from .windows_task import install_logon_task, task_exists, uninstall_logon_task LOG_PATH = app_data_dir() / "proxy_chain_manager.log" logging.basicConfig( level=logging.INFO, format="%(asctime)s %(levelname)s %(name)s: %(message)s", handlers=[ logging.FileHandler(LOG_PATH, encoding="utf-8"), logging.StreamHandler(sys.stdout), ], ) class UILogHandler(logging.Handler): """Forward ``proxy_chain_manager`` log records to the Live tab (via ``ui_q``). Thread-safe.""" def __init__(self, q: queue.Queue[dict[str, Any]]) -> None: super().__init__(level=logging.DEBUG) self._q = q def emit(self, record: logging.LogRecord) -> None: try: text = self.format(record) self._q.put_nowait({"type": "log", "text": text}) except Exception: self.handleError(record) # ── palette ────────────────────────────────────────────────────────────────── BG = "#0d0d1a" CARD = "#12122a" PANEL = "#1a1a3e" ACCENT = "#1e3a8a" ACCENT2 = "#2563eb" GREEN = "#00e676" RED = "#ff1744" YELLOW = "#ffab00" ORANGE = "#ff6d00" PURPLE = "#bb86fc" BLUE = "#448aff" CYAN = "#00bcd4" DIM = "#4a5568" TEXT = "#e2e8f0" TEXT2 = "#94a3b8" FONT = "Segoe UI" def _ts() -> str: return datetime.now().strftime("%H:%M:%S") def main() -> None: ctk.set_appearance_mode("dark") ctk.set_default_color_theme("dark-blue") root = ctk.CTk() root.title("Proxy God v2") root.geometry("1080x740") root.minsize(900, 620) root.configure(fg_color=BG) ui_q: queue.Queue[dict[str, Any]] = queue.Queue() svc = ChainService(notify=lambda m: ui_q.put(m)) s = load_settings() browser = BrowserSession() browser_should_run = [False] browser_last_launch_ts = [0.0] # ── tray ───────────────────────────────────────────────────────────────── tray = TrayIcon( on_show=lambda: root.after(0, lambda: (root.deiconify(), root.lift())), on_quit=lambda: root.after(0, _close), on_rotate=svc.rotate_now, ) tray.start() pulse_job: dict[str, str | None] = {"id": None} HopState = Literal["untested", "testing", "ok", "fail"] def _cancel_pulse() -> None: if pulse_job["id"]: try: root.after_cancel(pulse_job["id"]) # type: ignore[arg-type] except Exception: pass pulse_job["id"] = None def _short(u: str) -> str: u = redact_proxy_url(u) u = u.replace("http://", "").replace("socks5://", "s5://").replace("socks4://", "s4://").replace("https://", "") return u[:28] + "…" if len(u) > 30 else u # ───────────────────────────────────────────────────────────────────────── # HELPERS # ───────────────────────────────────────────────────────────────────────── def _btn(parent: Any, label: str, cmd: Any, w: int = 80, h: int = 28, **kw: Any) -> ctk.CTkButton: # Pull known keys out first so **kw never duplicates CTkButton parameters (font, width, …). kw.pop("text", None) kw.pop("command", None) font = kw.pop("font", (FONT, 11)) fg_color = kw.pop("fg_color", ACCENT) hover_color = kw.pop("hover_color", ACCENT2) text_color = kw.pop("text_color", TEXT) corner_radius = kw.pop("corner_radius", 6) width = kw.pop("width", w) height = kw.pop("height", h) return ctk.CTkButton( parent, text=label, command=cmd, width=width, height=height, font=font, fg_color=fg_color, hover_color=hover_color, text_color=text_color, corner_radius=corner_radius, **kw, ) # ───────────────────────────────────────────────────────────────────────── # TOP BAR # ───────────────────────────────────────────────────────────────────────── topbar = ctk.CTkFrame(root, fg_color=CARD, corner_radius=0, height=48) topbar.pack(fill="x", side="top") topbar.pack_propagate(False) # Status status_dot = ctk.CTkLabel(topbar, text="●", font=(FONT, 20), text_color=RED) status_dot.pack(side="left", padx=(10, 2)) status_txt = ctk.CTkLabel(topbar, text="STOPPED", font=(FONT, 12, "bold"), text_color=TEXT) status_txt.pack(side="left", padx=(0, 8)) def _start() -> None: _save_settings() svc.start() start_btn = _btn(topbar, "▶ Start", _start, w=86) start_btn.pack(side="left", padx=2) stop_btn = _btn(topbar, "■ Stop", svc.stop, w=76) stop_btn.pack(side="left", padx=2) rotate_btn = _btn(topbar, "↻ Rotate", svc.rotate_now, w=76) rotate_btn.pack(side="left", padx=2) _btn(topbar, "Quit", lambda: root.after(0, _close), w=52, fg_color="#7f1d1d", hover_color="#991b1b").pack(side="left", padx=(10, 2)) # Boot buttons ctk.CTkLabel(topbar, text="│", text_color=DIM).pack(side="left", padx=4) boot_lbl = ctk.CTkLabel(topbar, text="Boot:?", font=(FONT, 10), text_color=TEXT2) boot_lbl.pack(side="left", padx=2) def _refresh_boot() -> None: on = task_exists() boot_lbl.configure(text="Boot:ON" if on else "Boot:OFF", text_color=GREEN if on else DIM) def _inst_boot() -> None: ok, msg = install_logon_task() _log("Boot task installed." if ok else f"Boot install: {msg}") _refresh_boot() def _rm_boot() -> None: ok, msg = uninstall_logon_task() _log("Boot task removed." if ok else f"Boot remove: {msg}") _refresh_boot() _btn(topbar, "Boot+", _inst_boot, w=54).pack(side="left", padx=2) _btn(topbar, "Boot−", _rm_boot, w=54).pack(side="left", padx=2) # Right side indicators rotation_lbl = ctk.CTkLabel(topbar, text="rot: 0", font=(FONT, 10), text_color=TEXT2) rotation_lbl.pack(side="right", padx=(4, 12)) countdown_lbl = ctk.CTkLabel(topbar, text="next: —", font=(FONT, 10), text_color=TEXT2) countdown_lbl.pack(side="right", padx=4) proxy_lbl = ctk.CTkLabel(topbar, text=f"{LISTEN_HOST}:{s.local_port}", font=(FONT, 11, "bold"), text_color=BLUE) proxy_lbl.pack(side="right", padx=(4, 4)) ctk.CTkLabel(topbar, text="proxy:", font=(FONT, 10), text_color=TEXT2).pack(side="right") fw_lbl = ctk.CTkLabel(topbar, text="FW:—", font=(FONT, 10), text_color=DIM) fw_lbl.pack(side="right", padx=6) sys_lbl = ctk.CTkLabel(topbar, text="SYS:—", font=(FONT, 10), text_color=DIM) sys_lbl.pack(side="right", padx=4) admin_badge = ctk.CTkLabel( topbar, text="⚡ ADMIN" if is_admin() else "👤 USER", font=(FONT, 10, "bold"), text_color=GREEN if is_admin() else YELLOW, ) admin_badge.pack(side="right", padx=4) if not is_admin(): def _elevate() -> None: if request_admin_relaunch(): _close() _btn(topbar, "Run as Admin", _elevate, w=104, fg_color="#7f1d1d", hover_color="#991b1b").pack(side="right", padx=4) # ───────────────────────────────────────────────────────────────────────── # CHAIN VIZ BAR # ───────────────────────────────────────────────────────────────────────── viz_bar = ctk.CTkFrame(root, fg_color=PANEL, corner_radius=0, height=52) viz_bar.pack(fill="x") viz_bar.pack_propagate(False) your_ip_lbl = ctk.CTkLabel(viz_bar, text="Your IP: —", font=(FONT, 10), text_color=TEXT2) your_ip_lbl.pack(side="left", padx=(12, 8)) chain_canvas = ctk.CTkFrame(viz_bar, fg_color="transparent") chain_canvas.pack(side="left", fill="both", expand=True) exit_ip_lbl = ctk.CTkLabel(viz_bar, text="Exit: —", font=(FONT, 13, "bold"), text_color=YELLOW) exit_ip_lbl.pack(side="right", padx=(8, 14)) hop_dot_labels: list[ctk.CTkLabel] = [] outer_hop_label = "VPN" # updated when VPN detected; "Direct" if no tunnel def _pulse(step: int = 0) -> None: if not hop_dot_labels: pulse_job["id"] = None return c = YELLOW if step % 2 == 0 else DIM for d in hop_dot_labels: d.configure(text_color=c) pulse_job["id"] = root.after(380, lambda s=step: _pulse(s + 1)) # type: ignore[arg-type] def _render_chain( hops: list[str], status: str, exit_ip: str | None, fixed_last: bool = False ) -> None: _cancel_pulse() for w in list(chain_canvas.winfo_children()): w.destroy() hop_dot_labels.clear() hop_c = {"healthy": GREEN, "dead": RED, "connecting": YELLOW}.get(status, DIM) def _node(text: str, color: str, bold: bool = False) -> None: ctk.CTkLabel( chain_canvas, text=text, font=(FONT, 11, "bold") if bold else (FONT, 10), text_color=color, ).pack(side="left", padx=1) def _arr() -> None: ctk.CTkLabel(chain_canvas, text="→", font=(FONT, 11), text_color=DIM).pack(side="left", padx=2) _node("YOU", GREEN, bold=True) _arr() _node(outer_hop_label[:12], PURPLE, bold=True) _arr() last_i = len(hops) - 1 for i, h in enumerate(hops): is_fixed = fixed_last and i == last_i and last_i >= 0 lbl_c = ORANGE if is_fixed else hop_c dot = ctk.CTkLabel(chain_canvas, text="●", font=(FONT, 12), text_color=lbl_c) dot.pack(side="left", padx=1) hop_dot_labels.append(dot) label = _short(h) + (" ★" if is_fixed else "") ctk.CTkLabel(chain_canvas, text=label, font=(FONT, 10), text_color=lbl_c).pack(side="left", padx=1) if i < len(hops) - 1: _arr() _arr() _node("WEB", BLUE, bold=True) exit_ip_lbl.configure( text=f"Exit: {exit_ip}" if exit_ip else "Exit: —", text_color=GREEN if status == "healthy" else (RED if exit_ip else YELLOW), ) if status == "connecting" and hop_dot_labels: _pulse() # ───────────────────────────────────────────────────────────────────────── # PROGRESS STRIP # ───────────────────────────────────────────────────────────────────────── prog_strip = ctk.CTkFrame(root, fg_color=BG, height=22) prog_strip.pack(fill="x", padx=8, pady=(4, 0)) prog_strip.pack_propagate(False) phase_lbl = ctk.CTkLabel(prog_strip, text="idle", font=(FONT, 10), text_color=TEXT2, width=70) phase_lbl.pack(side="left", padx=4) prog_bar = ctk.CTkProgressBar(prog_strip, height=8, corner_radius=4, fg_color=CARD, progress_color=BLUE) prog_bar.pack(side="left", fill="x", expand=True, padx=4) prog_bar.set(0) pool_lbl = ctk.CTkLabel(prog_strip, text="pool: 0", font=(FONT, 10), text_color=TEXT2, width=70) pool_lbl.pack(side="right", padx=4) # ───────────────────────────────────────────────────────────────────────── # TABVIEW # ───────────────────────────────────────────────────────────────────────── tabs = ctk.CTkTabview( root, fg_color=BG, segmented_button_fg_color=CARD, segmented_button_selected_color=ACCENT2, segmented_button_unselected_color=CARD, segmented_button_selected_hover_color=ACCENT, border_width=0, ) tabs.pack(fill="both", expand=True, padx=8, pady=(4, 8)) tab_live = tabs.add(" Live ") tab_chain = tabs.add(" Chain Builder ") tab_browser = tabs.add(" Browser ") tab_privacy = tabs.add(" Privacy ") tab_settings = tabs.add(" Settings ") for tab in (tab_live, tab_chain, tab_browser, tab_privacy, tab_settings): tab.configure(fg_color=BG) # ─── TAB: LIVE ─────────────────────────────────────────────────────────── # Stats cards row stats_row = ctk.CTkFrame(tab_live, fg_color="transparent") stats_row.pack(fill="x", pady=(4, 6)) def _stat_card(parent: Any, title: str, var: ctk.StringVar, color: str = TEXT) -> None: f = ctk.CTkFrame(parent, fg_color=CARD, corner_radius=8) f.pack(side="left", fill="x", expand=True, padx=4) ctk.CTkLabel(f, text=title, font=(FONT, 9), text_color=TEXT2).pack( anchor="w", padx=8, pady=(6, 0)) ctk.CTkLabel(f, textvariable=var, font=(FONT, 14, "bold"), text_color=color).pack( anchor="w", padx=8, pady=(0, 6)) v_real_ip = ctk.StringVar(value="—") v_exit_ip = ctk.StringVar(value="—") v_pool = ctk.StringVar(value="0") v_rotation = ctk.StringVar(value="0") _stat_card(stats_row, "Direct / VPN IP", v_real_ip) _stat_card(stats_row, "Exit IP (last hop)", v_exit_ip) _stat_card(stats_row, "Valid pool size", v_pool) _stat_card(stats_row, "Rotations this session", v_rotation) # Log box log_frame = ctk.CTkFrame(tab_live, fg_color=CARD, corner_radius=8) log_frame.pack(fill="both", expand=True) log_box = ctk.CTkTextbox( log_frame, font=("Consolas", 10), fg_color=BG, text_color=TEXT, scrollbar_button_color=ACCENT, ) log_box.pack(fill="both", expand=True, padx=4, pady=(0, 4)) def _log(line: str) -> None: log_box.insert("end", f"[{_ts()}] {line}\n") log_box.see("end") log_tool = ctk.CTkFrame(log_frame, fg_color="transparent") log_tool.pack(fill="x", padx=8, pady=(6, 0), before=log_box) verbose_logs_var = ctk.BooleanVar(value=True) _pcm_logger = logging.getLogger("proxy_chain_manager") _ui_log_handler: UILogHandler | None = None for _h in _pcm_logger.handlers: if isinstance(_h, UILogHandler): _ui_log_handler = _h break if _ui_log_handler is None: _ui_log_handler = UILogHandler(ui_q) _ui_log_handler.setFormatter( logging.Formatter("%(levelname)-5s [%(name)s] %(message)s") ) _pcm_logger.addHandler(_ui_log_handler) logging.getLogger("httpx").setLevel(logging.WARNING) logging.getLogger("httpcore").setLevel(logging.WARNING) def _sync_ui_log_level() -> None: on = bool(verbose_logs_var.get()) lvl = logging.DEBUG if on else logging.INFO _pcm_logger.setLevel(lvl) if _ui_log_handler is not None: _ui_log_handler.setLevel(lvl) _log(f"UI log level: {'DEBUG (verbose)' if on else 'INFO'}") ctk.CTkCheckBox( log_tool, text="Verbose logs (DEBUG in UI — file stays INFO)", variable=verbose_logs_var, command=_sync_ui_log_level, font=(FONT, 11), fg_color=ACCENT2, hover_color=ACCENT, text_color=TEXT, ).pack(side="left", padx=(0, 12)) _btn(log_tool, "Clear log", lambda: log_box.delete("1.0", "end"), w=88, h=26, fg_color=DIM, hover_color=ACCENT).pack(side="left", padx=(0, 6)) _sync_ui_log_level() # ─── TAB: CHAIN BUILDER ────────────────────────────────────────────────── cb_split = ctk.CTkFrame(tab_chain, fg_color="transparent") cb_split.pack(fill="x", pady=(4, 8)) # Left — mode + hop slider cb_left = ctk.CTkFrame(cb_split, fg_color=CARD, corner_radius=8) cb_left.pack(side="left", fill="both", expand=True, padx=(0, 6)) ctk.CTkLabel(cb_left, text="Obfuscation Mode", font=(FONT, 12, "bold"), text_color=TEXT).pack(anchor="w", padx=12, pady=(12, 4)) mode_var = ctk.StringVar(value=s.obfuscation_mode) for mk in OBFUSCATION_MODES: ctk.CTkRadioButton( cb_left, text=OBFUSCATION_LABELS[mk], variable=mode_var, value=mk, font=(FONT, 11), fg_color=ACCENT2, hover_color=ACCENT, text_color=TEXT, ).pack(anchor="w", padx=16, pady=3) elite_var = ctk.BooleanVar(value=s.prefer_elite) ctk.CTkCheckBox( cb_left, text="Elite proxies only (slower but more anonymous)", variable=elite_var, font=(FONT, 11), fg_color=ACCENT2, hover_color=ACCENT, text_color=TEXT, ).pack(anchor="w", padx=16, pady=(0, 8)) exit_fix_frame = ctk.CTkFrame(cb_left, fg_color=PANEL, corner_radius=8) exit_fix_frame.pack(fill="x", padx=12, pady=(0, 12)) exit_hdr = ctk.CTkFrame(exit_fix_frame, fg_color="transparent") exit_hdr.pack(fill="x", padx=10, pady=(8, 2)) ctk.CTkLabel( exit_hdr, text="Exit node (optional final hop)", font=(FONT, 11, "bold"), text_color=ORANGE, ).pack(side="left") exit_test_dot = ctk.CTkLabel(exit_hdr, text="●", font=(FONT, 14), text_color=RED) exit_test_dot.pack(side="left", padx=(8, 4)) exit_proxy_entry = ctk.CTkEntry( exit_fix_frame, placeholder_text="http://host:port or socks5://host:port (optional)", font=("Consolas", 10), fg_color=BG, border_color=ACCENT, height=28, ) exit_proxy_entry.pack(fill="x", padx=10, pady=(0, 4)) exit_auth_row = ctk.CTkFrame(exit_fix_frame, fg_color="transparent") exit_auth_row.pack(fill="x", padx=10, pady=(0, 4)) ctk.CTkLabel(exit_auth_row, text="User", font=(FONT, 10), text_color=TEXT2, width=36).pack( side="left", padx=(0, 4) ) exit_user_entry = ctk.CTkEntry( exit_auth_row, width=120, height=26, font=("Consolas", 10), fg_color=BG, border_color=ACCENT, placeholder_text="optional", ) exit_user_entry.pack(side="left", padx=(0, 10)) ctk.CTkLabel(exit_auth_row, text="Pass", font=(FONT, 10), text_color=TEXT2, width=36).pack( side="left", padx=(0, 4) ) exit_pass_entry = ctk.CTkEntry( exit_auth_row, width=120, height=26, font=("Consolas", 10), fg_color=BG, border_color=ACCENT, placeholder_text="optional", show="*", ) exit_pass_entry.pack(side="left", padx=(0, 0)) _eb, _eu, _epw = split_proxy_for_edit(s.manual_exit_proxy) if _eb: exit_proxy_entry.insert(0, _eb) if _eu: exit_user_entry.insert(0, _eu) if _epw: exit_pass_entry.insert(0, _epw) exit_btn_row = ctk.CTkFrame(exit_fix_frame, fg_color="transparent") exit_btn_row.pack(fill="x", padx=10, pady=(0, 4)) def _exit_url() -> str: raw = exit_proxy_entry.get().strip() if not raw: return "" if "://" not in raw: raw = "http://" + raw return merge_proxy_credentials(raw, exit_user_entry.get(), exit_pass_entry.get()) def _test_exit() -> None: url = _exit_url() if not url: _log("Exit node: enter a proxy URL first.") return exit_test_dot.configure(text_color=YELLOW) test_exit_btn.configure(state="disabled") def work() -> None: def on_result(_u: str, ok: bool) -> None: root.after(0, lambda: exit_test_dot.configure(text_color=GREEN if ok else RED)) root.after(0, lambda: _log( f"Exit node: {'OK' if ok else 'FAILED'} — {_short(url)}" )) run_validate_each_sync( [url], svc.settings.ip_check_url, min(12.0, svc.settings.validation_timeout_seconds), on_result, concurrency=1, ) root.after(0, lambda: test_exit_btn.configure(state="normal")) threading.Thread(target=work, daemon=True).start() test_exit_btn = _btn(exit_btn_row, "Test exit", _test_exit, w=88, h=26, fg_color=ACCENT2, hover_color=ACCENT) test_exit_btn.pack(side="left") ctk.CTkLabel( exit_fix_frame, text="Appended after your chain hops when running. Leave empty to use last chain hop as exit.\n" "Auth: User/Pass fields or user:pass@host in the URL.", font=(FONT, 9), text_color=TEXT2, justify="left", ).pack(anchor="w", padx=10, pady=(0, 8)) # Right — your chain cb_right = ctk.CTkFrame(cb_split, fg_color=CARD, corner_radius=8, width=400) cb_right.pack(side="left", fill="both", expand=True) hdr_row = ctk.CTkFrame(cb_right, fg_color="transparent") hdr_row.pack(fill="x", padx=12, pady=(12, 2)) ctk.CTkLabel( hdr_row, text="Your chain", font=(FONT, 12, "bold"), text_color=TEXT, ).pack(side="left") chain_count_lbl = ctk.CTkLabel(hdr_row, text="", font=(FONT, 10), text_color=TEXT2) chain_count_lbl.pack(side="left", padx=(8, 0)) use_manual_var = ctk.BooleanVar(value=True if s.pinned_chain else s.use_pinned_chain) use_chain_cb = ctk.CTkCheckBox( hdr_row, text="Use this chain on Start", variable=use_manual_var, font=(FONT, 10), fg_color=ACCENT2, hover_color=ACCENT, text_color=TEXT2, ) use_chain_cb.pack(side="right") ctk.CTkLabel( cb_right, text="Traffic flows top → bottom. ● red = not tested ● green = live", font=(FONT, 9), text_color=TEXT2, ).pack(anchor="w", padx=12, pady=(0, 4)) manual_chain: list[str] = list(s.pinned_chain) hop_status: dict[str, HopState] = {u: "untested" for u in manual_chain} status_dots: dict[str, ctk.CTkLabel] = {} _HOP_COLOR = {"untested": RED, "testing": YELLOW, "ok": GREEN, "fail": RED} chain_list_frame = ctk.CTkScrollableFrame( cb_right, fg_color=BG, height=200, corner_radius=6, scrollbar_button_color=ACCENT, ) chain_list_frame.pack(fill="x", padx=12, pady=(0, 4)) def _update_chain_count() -> None: n = len(manual_chain) chain_count_lbl.configure(text=f"({n} hop{'s' if n != 1 else ''})") def _rebuild_chain_ui() -> None: status_dots.clear() for w in list(chain_list_frame.winfo_children()): w.destroy() for i, hop in enumerate(manual_chain): if hop not in hop_status: hop_status[hop] = "untested" _chain_row(i, hop) _update_chain_count() def _chain_row(idx: int, hop: str) -> None: fr = ctk.CTkFrame(chain_list_frame, fg_color=PANEL, corner_radius=6, height=32) fr.pack(fill="x", pady=2) fr.pack_propagate(False) st = hop_status.get(hop, "untested") dot = ctk.CTkLabel(fr, text="●", font=(FONT, 12), text_color=_HOP_COLOR[st], width=18) dot.pack(side="left", padx=(4, 0)) status_dots[hop] = dot ctk.CTkLabel(fr, text=f"{idx+1}", font=(FONT, 10, "bold"), text_color=CYAN, width=22).pack(side="left") proto = hop.split("://")[0].upper() if "://" in hop else "HTTP" badge_c = {"HTTP": "#1e3a8a", "SOCKS5": "#064e3b", "SOCKS4": "#3b1a64"}.get(proto, DIM) ctk.CTkLabel(fr, text=proto, font=(FONT, 9, "bold"), fg_color=badge_c, corner_radius=4, padx=4, text_color=TEXT).pack(side="left", padx=2) ctk.CTkLabel(fr, text=_short(hop), font=("Consolas", 10), text_color=TEXT, anchor="w").pack(side="left", fill="x", expand=True, padx=4) def _up(i: int = idx) -> None: if i > 0: manual_chain[i], manual_chain[i-1] = manual_chain[i-1], manual_chain[i] _rebuild_chain_ui() def _dn(i: int = idx) -> None: if i < len(manual_chain) - 1: manual_chain[i], manual_chain[i+1] = manual_chain[i+1], manual_chain[i] _rebuild_chain_ui() def _rm(i: int = idx) -> None: removed = manual_chain[i] del manual_chain[i] hop_status.pop(removed, None) _rebuild_chain_ui() _btn(fr, "↑", _up, w=26, h=24, fg_color=DIM, hover_color=ACCENT).pack(side="right", padx=1) _btn(fr, "↓", _dn, w=26, h=24, fg_color=DIM, hover_color=ACCENT).pack(side="right", padx=1) _btn(fr, "✕", _rm, w=26, h=24, fg_color="#7f1d1d", hover_color=RED).pack(side="right", padx=(1, 6)) _rebuild_chain_ui() test_row = ctk.CTkFrame(cb_right, fg_color="transparent") test_row.pack(fill="x", padx=12, pady=(0, 6)) def _set_all_status(state: HopState) -> None: for u in manual_chain: hop_status[u] = state if u in status_dots: status_dots[u].configure(text_color=_HOP_COLOR[state]) def _test_chain() -> None: if not manual_chain: _log("Add proxies to your chain first.") return test_chain_btn.configure(state="disabled") _set_all_status("testing") check_url = svc.settings.ip_check_url timeout = min(12.0, svc.settings.validation_timeout_seconds) ok_count = [0] def on_result(url: str, ok: bool) -> None: hop_status[url] = "ok" if ok else "fail" if ok: ok_count[0] += 1 def ui() -> None: if url in status_dots: status_dots[url].configure(text_color=GREEN if ok else RED) root.after(0, ui) def work() -> None: run_validate_each_sync(manual_chain, check_url, timeout, on_result) n_ok, n_tot = ok_count[0], len(manual_chain) def done() -> None: test_chain_btn.configure(state="normal") _log(f"Chain test: {n_ok}/{n_tot} proxies responded OK.") root.after(0, done) threading.Thread(target=work, daemon=True).start() test_chain_btn = _btn(test_row, "▶ Test entire chain", _test_chain, w=150, h=28, fg_color=ACCENT2, hover_color=ACCENT) test_chain_btn.pack(side="left", padx=(0, 8)) # Add proxy input add_row = ctk.CTkFrame(cb_right, fg_color="transparent") add_row.pack(fill="x", padx=12, pady=(0, 4)) add_entry = ctk.CTkEntry( add_row, placeholder_text="http://host:port or user:pass@host:port", font=(FONT, 10), fg_color=BG, border_color=ACCENT, height=28, ) add_entry.pack(side="left", fill="x", expand=True, padx=(0, 4)) add_user_entry = ctk.CTkEntry( add_row, width=88, height=28, font=("Consolas", 10), fg_color=BG, border_color=ACCENT, placeholder_text="user", ) add_user_entry.pack(side="left", padx=(0, 2)) add_pass_entry = ctk.CTkEntry( add_row, width=88, height=28, font=("Consolas", 10), fg_color=BG, border_color=ACCENT, placeholder_text="pass", show="*", ) add_pass_entry.pack(side="left", padx=(0, 4)) def _add_proxy() -> None: v = add_entry.get().strip() if not v: return if "://" not in v: v = "http://" + v au = add_user_entry.get().strip() ap = add_pass_entry.get().strip() if au or ap: v = merge_proxy_credentials(v, au, ap) else: v = normalize_proxy_url(v) manual_chain.append(v) hop_status[v] = "untested" _rebuild_chain_ui() add_entry.delete(0, "end") add_user_entry.delete(0, "end") add_pass_entry.delete(0, "end") _btn(add_row, "+ Add", _add_proxy, w=68, h=28).pack(side="left") chain_btn_row = ctk.CTkFrame(cb_right, fg_color="transparent") chain_btn_row.pack(pady=(0, 10)) def _on_picker_done(urls: list[str], mode: str) -> None: if mode == "replace": manual_chain.clear() hop_status.clear() for u in urls: if u not in manual_chain: manual_chain.append(u) hop_status[u] = "untested" _rebuild_chain_ui() _log(f"{'Replaced' if mode == 'replace' else 'Added'} {len(urls)} proxies to your chain.") def _open_picker() -> None: _save_settings() show_proxy_picker(root, svc.settings, bool(elite_var.get()), _on_picker_done) browse_btn = _btn(chain_btn_row, "Browse proxy lists…", _open_picker, w=150, h=26, fg_color=ACCENT2, hover_color=ACCENT) browse_btn.pack(side="left") # Sources src_frame = ctk.CTkFrame(tab_chain, fg_color=CARD, corner_radius=8) src_frame.pack(fill="x", pady=(0, 6)) ctk.CTkLabel(src_frame, text="Proxy Sources (one JSON URL per line)", font=(FONT, 11, "bold"), text_color=TEXT).pack( anchor="w", padx=12, pady=(8, 4)) sources_box = ctk.CTkTextbox( src_frame, height=72, font=("Consolas", 10), fg_color=BG, text_color=TEXT, scrollbar_button_color=ACCENT, ) sources_box.pack(fill="x", padx=12, pady=(0, 8)) sources_box.insert("end", "\n".join(s.sources)) # ─── TAB: BROWSER ───────────────────────────────────────────────────────── br_scroll = ctk.CTkScrollableFrame(tab_browser, fg_color=BG, scrollbar_button_color=ACCENT) br_scroll.pack(fill="both", expand=True, padx=4, pady=4) def _br_section(title: str, subtitle: str = "") -> ctk.CTkFrame: ctk.CTkLabel(br_scroll, text=title, font=(FONT, 13, "bold"), text_color=CYAN).pack( anchor="w", padx=8, pady=(12, 0) ) if subtitle: ctk.CTkLabel( br_scroll, text=subtitle, font=(FONT, 10), text_color=TEXT2, wraplength=900, justify="left" ).pack(anchor="w", padx=8, pady=(0, 4)) f = ctk.CTkFrame(br_scroll, fg_color=CARD, corner_radius=8) f.pack(fill="x", padx=8, pady=(4, 8)) return f browser_status_card = _br_section( "Hardened Firefox", "Launches Firefox in an app-controlled profile that enforces proxy/hardening prefs on every launch.", ) browser_status_lbl = ctk.CTkLabel( browser_status_card, text="Browser status: stopped", font=(FONT, 12, "bold"), text_color=TEXT2 ) browser_status_lbl.pack(anchor="w", padx=12, pady=(10, 2)) browser_hint_lbl = ctk.CTkLabel( browser_status_card, text="Exit IP on hover in tray while chain is healthy.", font=(FONT, 10), text_color=TEXT2 ) browser_hint_lbl.pack(anchor="w", padx=12, pady=(0, 10)) browser_path_card = _br_section("Executable and profile", "Set your Firefox path once; profile is kept isolated.") path_row = ctk.CTkFrame(browser_path_card, fg_color="transparent") path_row.pack(fill="x", padx=12, pady=(10, 4)) ctk.CTkLabel(path_row, text="Firefox exe", width=90, anchor="w", font=(FONT, 10), text_color=TEXT2).pack(side="left") firefox_path_var = ctk.StringVar(value=s.firefox_path or default_firefox_path()) firefox_path_entry = ctk.CTkEntry(path_row, textvariable=firefox_path_var, height=28, fg_color=BG, border_color=ACCENT) firefox_path_entry.pack(side="left", fill="x", expand=True, padx=(0, 6)) def _pick_firefox_path() -> None: p = filedialog.askopenfilename( title="Select firefox.exe", filetypes=[("Firefox", "firefox.exe"), ("Executable", "*.exe"), ("All files", "*.*")], ) if p: firefox_path_var.set(p) _btn(path_row, "Browse", _pick_firefox_path, w=72, h=28, fg_color=DIM, hover_color=ACCENT).pack(side="left") profile_row = ctk.CTkFrame(browser_path_card, fg_color="transparent") profile_row.pack(fill="x", padx=12, pady=(0, 10)) ctk.CTkLabel(profile_row, text="Profile dir", width=90, anchor="w", font=(FONT, 10), text_color=TEXT2).pack(side="left") firefox_profile_var = ctk.StringVar(value=s.firefox_profile_dir or default_profile_dir()) firefox_profile_entry = ctk.CTkEntry( profile_row, textvariable=firefox_profile_var, height=28, fg_color=BG, border_color=ACCENT ) firefox_profile_entry.pack(side="left", fill="x", expand=True) browser_toggles_card = _br_section( "Browser controls", "These settings are applied each time you launch from this tab.", ) br_force_proxy_var = ctk.BooleanVar(value=s.browser_force_proxy) br_disable_webrtc_var = ctk.BooleanVar(value=s.browser_disable_webrtc) br_rfp_var = ctk.BooleanVar(value=s.browser_resist_fingerprinting) br_telemetry_var = ctk.BooleanVar(value=s.browser_disable_telemetry) br_fpi_var = ctk.BooleanVar(value=s.browser_first_party_isolation) br_strict_tp_var = ctk.BooleanVar(value=s.browser_strict_tracking_protection) br_tz_utc_var = ctk.BooleanVar(value=s.browser_timezone_utc) br_clear_var = ctk.BooleanVar(value=s.browser_clear_on_close) br_disposable_var = ctk.BooleanVar(value=s.browser_disposable_profile) br_kill_drop_var = ctk.BooleanVar(value=s.browser_kill_on_chain_drop) br_auto_relaunch_var = ctk.BooleanVar(value=s.browser_auto_relaunch) br_lock_profile_var = ctk.BooleanVar(value=s.browser_lock_managed_profile) def _br_toggle(parent: Any, text: str, var: ctk.BooleanVar, tip: str = "") -> ctk.CTkCheckBox: cb = ctk.CTkCheckBox( parent, text=text, variable=var, font=(FONT, 11), fg_color=ACCENT2, hover_color=ACCENT, text_color=TEXT, ) cb.pack(anchor="w", padx=12, pady=5) return cb _br_toggle( browser_toggles_card, "Force browser proxy to local chain", br_force_proxy_var, "Forces Firefox traffic through Proxy God listener. Prevents direct bypass.", ) _br_toggle( browser_toggles_card, "Disable WebRTC peer connections", br_disable_webrtc_var, "Stops common WebRTC local-IP leaks in browser calls.", ) _br_toggle( browser_toggles_card, "Enable Resist Fingerprinting", br_rfp_var, "Turns on Firefox anti-fingerprinting mode (slightly changes site behavior).", ) _br_toggle( browser_toggles_card, "Disable telemetry and studies", br_telemetry_var, "Disables browser diagnostics/study pings.", ) _br_toggle( browser_toggles_card, "Enable First-Party Isolation", br_fpi_var, "Separates site storage per domain to reduce cross-site tracking.", ) _br_toggle( browser_toggles_card, "Strict tracking protection", br_strict_tp_var, "Uses stronger tracker/cookie blocking in Firefox.", ) _br_toggle( browser_toggles_card, "Timezone hardening (UTC-friendly timer precision)", br_tz_utc_var, "Reduces timing precision used in fingerprinting.", ) _br_toggle( browser_toggles_card, "Clear cookies/cache/history on close", br_clear_var, "Wipes session traces from the managed profile when browser closes.", ) _br_toggle( browser_toggles_card, "Disposable profile (delete on close)", br_disposable_var, "Deletes the entire managed profile folder on stop/close.", ) _br_toggle( browser_toggles_card, "Kill browser if chain drops", br_kill_drop_var, "Stops browser immediately if chain becomes unhealthy.", ) _br_toggle( browser_toggles_card, "Auto-relaunch browser while chain is healthy", br_auto_relaunch_var, "If browser exits unexpectedly, relaunch it automatically while chain stays up.", ) _br_toggle( browser_toggles_card, "Lock to managed profile (recommended)", br_lock_profile_var, "Launches Firefox only with Proxy God profile and re-applies settings each launch.", ) browser_action_row = ctk.CTkFrame(br_scroll, fg_color="transparent") browser_action_row.pack(fill="x", padx=8, pady=(2, 14)) def _browser_cfg() -> BrowserConfig: return BrowserConfig( firefox_path=firefox_path_var.get().strip(), profile_dir=firefox_profile_var.get().strip(), clear_on_close=bool(br_clear_var.get()), disposable_profile=bool(br_disposable_var.get()), kill_on_chain_drop=bool(br_kill_drop_var.get()), auto_relaunch=bool(br_auto_relaunch_var.get()), lock_managed_profile=bool(br_lock_profile_var.get()), force_proxy=bool(br_force_proxy_var.get()), disable_webrtc=bool(br_disable_webrtc_var.get()), resist_fingerprinting=bool(br_rfp_var.get()), disable_telemetry=bool(br_telemetry_var.get()), first_party_isolation=bool(br_fpi_var.get()), strict_tracking_protection=bool(br_strict_tp_var.get()), timezone_utc=bool(br_tz_utc_var.get()), ) def _refresh_browser_status() -> None: if browser.is_running(): browser_status_lbl.configure( text=f"Browser status: running (pid {browser.pid()})", text_color=GREEN, ) else: if browser_should_run[0]: browser_status_lbl.configure(text="Browser status: waiting/restarting", text_color=YELLOW) else: browser_status_lbl.configure(text="Browser status: stopped", text_color=TEXT2) def _launch_browser_with_cfg(cfg: BrowserConfig) -> bool: if not svc.current_chain: _log("Chain not ready yet — starting chain and launching browser now.") _start() ok, msg = browser.launch(cfg, LISTEN_HOST, svc.settings.local_port) _log(msg) _refresh_browser_status() return bool(ok) def _launch_browser() -> None: _save_settings() cfg = _browser_cfg() browser_should_run[0] = True if _launch_browser_with_cfg(cfg): browser_last_launch_ts[0] = time.monotonic() def _stop_browser() -> None: cfg = _browser_cfg() browser_should_run[0] = False ok, msg = browser.stop(dispose=cfg.disposable_profile) _log(msg) _refresh_browser_status() launch_browser_btn = _btn( browser_action_row, "Launch Hardened Firefox", _launch_browser, w=190, h=34, font=(FONT, 12) ) launch_browser_btn.pack(side="left", padx=(0, 8)) stop_browser_btn = _btn( browser_action_row, "Stop Browser", _stop_browser, w=110, h=34, fg_color="#7f1d1d", hover_color="#991b1b", ) stop_browser_btn.pack(side="left") # ─── TAB: PRIVACY ────────────────────────────────────────────────────────── priv_scroll = ctk.CTkScrollableFrame(tab_privacy, fg_color=BG, scrollbar_button_color=ACCENT) priv_scroll.pack(fill="both", expand=True, padx=4, pady=4) def _priv_section(title: str, subtitle: str = "") -> ctk.CTkFrame: ctk.CTkLabel(priv_scroll, text=title, font=(FONT, 13, "bold"), text_color=CYAN).pack(anchor="w", padx=8, pady=(12, 0)) if subtitle: ctk.CTkLabel(priv_scroll, text=subtitle, font=(FONT, 10), text_color=TEXT2, wraplength=900, justify="left").pack( anchor="w", padx=8, pady=(0, 4)) f = ctk.CTkFrame(priv_scroll, fg_color=CARD, corner_radius=8) f.pack(fill="x", padx=8, pady=(4, 8)) return f status_card = _priv_section( "Network identity", "VPN detection drives leak checks: strict without VPN, subnet-aware with VPN.", ) status_row = ctk.CTkFrame(status_card, fg_color="transparent") status_row.pack(fill="x", padx=12, pady=10) vpn_status_lbl = ctk.CTkLabel(status_row, text="VPN: scanning…", font=(FONT, 12, "bold"), text_color=TEXT) vpn_status_lbl.pack(anchor="w") leak_mode_lbl = ctk.CTkLabel(status_row, text="Leak check: —", font=(FONT, 11), text_color=TEXT2) leak_mode_lbl.pack(anchor="w", pady=(4, 0)) def _refresh_vpn_ui() -> None: vs = detect_vpn() nonlocal outer_hop_label if vs.active: outer_hop_label = vs.short_label()[:12] vpn_status_lbl.configure( text=f"VPN: {vs.label}" + (f" ({vs.adapter})" if vs.adapter else ""), text_color=GREEN, ) leak_mode_lbl.configure(text="Leak check: VPN-aware (/16 subnet)") else: outer_hop_label = "Direct" vpn_status_lbl.configure(text="VPN: not detected (direct connection)", text_color=YELLOW) leak_mode_lbl.configure(text="Leak check: strict (exit must differ from your IP)") _btn(status_card, "Refresh VPN status", _refresh_vpn_ui, w=140, h=28).pack( anchor="w", padx=12, pady=(0, 10)) toggles_card = _priv_section( "Protections while chain is running", "Applied on Start, restored on Stop. Admin required for MAC, hostname, IPv6, and WebRTC.", ) mac_var = ctk.BooleanVar(value=s.mac_spoof_enabled) host_var = ctk.BooleanVar(value=s.spoof_hostname_enabled) dns_flush_var = ctk.BooleanVar(value=s.flush_dns_on_rotate) ipv6_var = ctk.BooleanVar(value=s.disable_ipv6_while_active) webrtc_var = ctk.BooleanVar(value=s.harden_webrtc_enabled) def _priv_toggle(parent: Any, text: str, var: ctk.BooleanVar, tip: str = "") -> ctk.CTkCheckBox: cb = ctk.CTkCheckBox( parent, text=text, variable=var, font=(FONT, 11), fg_color=ACCENT2, hover_color=ACCENT, text_color=TEXT, ) cb.pack(anchor="w", padx=12, pady=6) return cb _priv_toggle( toggles_card, "Randomize MAC addresses on physical adapters", mac_var, "Changes NIC MAC values while chain runs (admin required).", ) _priv_toggle( toggles_card, "Spoof computer / NetBIOS hostname", host_var, "Temporarily renames machine identity while active (admin required).", ) _priv_toggle( toggles_card, "Flush DNS cache when starting or rotating chains", dns_flush_var, "Clears cached resolver results to reduce stale direct routes.", ) _priv_toggle( toggles_card, "Disable IPv6 on active adapters", ipv6_var, "Turns off IPv6 bindings while active to reduce IPv6 leak paths.", ) _priv_toggle( toggles_card, "Harden WebRTC in Chrome / Edge (block non-proxied UDP)", webrtc_var, "Applies Windows policy to block direct WebRTC UDP bypass in Chromium browsers.", ) fp_card = _priv_section( "Device fingerprint", "OS-level identifiers. Browsers still fingerprint Canvas, fonts, and WebGL separately.", ) fp_box = ctk.CTkTextbox(fp_card, height=140, font=("Consolas", 10), fg_color=BG, text_color=TEXT, scrollbar_button_color=ACCENT) fp_box.pack(fill="x", padx=12, pady=(4, 8)) def _refresh_fingerprint() -> None: fp_box.delete("1.0", "end") audit = audit_device() fp_box.insert("end", "\n".join(audit.lines)) _btn(fp_card, "Refresh fingerprint audit", _refresh_fingerprint, w=180, h=28).pack( anchor="w", padx=12, pady=(0, 10)) dns_card = _priv_section("DNS", "Checks whether public resolvers may bypass your chain.") dns_result_lbl = ctk.CTkLabel(dns_card, text="Run a check to see DNS configuration.", font=(FONT, 11), text_color=TEXT2, wraplength=880, justify="left") dns_result_lbl.pack(anchor="w", padx=12, pady=8) def _run_dns_check() -> None: listen = f"http://{svc.settings.listen_addr()}" if svc.current_chain else None r = check_dns_leak_hint(listen) color = GREEN if r.ok else RED dns_result_lbl.configure( text=r.message + (f"\nResolvers: {', '.join(r.system_resolvers)}" if r.system_resolvers else ""), text_color=color, ) dns_btn_row = ctk.CTkFrame(dns_card, fg_color="transparent") dns_btn_row.pack(fill="x", padx=12, pady=(0, 10)) _btn(dns_btn_row, "DNS leak check", _run_dns_check, w=120, h=28).pack(side="left", padx=(0, 8)) def _manual_dns_flush() -> None: ok, msg = flush_dns_cache() dns_result_lbl.configure( text=msg, text_color=GREEN if ok else RED, ) _btn(dns_btn_row, "Flush DNS now", _manual_dns_flush, w=110, h=28, fg_color=DIM).pack(side="left") _btn(priv_scroll, "Save privacy settings", lambda: _save_settings(verbose=True), w=200, h=34, font=(FONT, 12)).pack(anchor="w", padx=8, pady=12) # ─── TAB: SETTINGS ─────────────────────────────────────────────────────── sf_outer = ctk.CTkScrollableFrame(tab_settings, fg_color=BG, scrollbar_button_color=ACCENT) sf_outer.pack(fill="both", expand=True) def _section(title: str) -> ctk.CTkFrame: ctk.CTkLabel(sf_outer, text=title, font=(FONT, 12, "bold"), text_color=CYAN).pack(anchor="w", padx=6, pady=(14, 4)) f = ctk.CTkFrame(sf_outer, fg_color=CARD, corner_radius=8) f.pack(fill="x", padx=6, pady=(0, 4)) return f entries: dict[str, ctk.CTkEntry] = {} def _fld(parent: Any, label: str, key: str, val: str, tip: str = "") -> None: row = ctk.CTkFrame(parent, fg_color="transparent") row.pack(fill="x", padx=12, pady=5) ctk.CTkLabel(row, text=label, font=(FONT, 11), text_color=TEXT, width=230, anchor="w").pack(side="left") e = ctk.CTkEntry(row, height=26, font=(FONT, 11), fg_color=BG, border_color=ACCENT, width=130) e.insert(0, val) e.pack(side="left") if tip: ctk.CTkLabel(row, text=f" {tip}", font=(FONT, 10), text_color=TEXT2).pack(side="left") entries[key] = e net = _section("Network") _fld(net, "Local listener port", "port", str(s.local_port), "(point apps here)") _fld(net, "Proxy bypass list", "bypass", s.proxy_bypass, "(semicolons)") _fld(net, "IP check URL", "check_url", s.ip_check_url) timing = _section("Timing") _fld(timing, "Health check interval (sec)", "health", str(s.health_check_seconds), "(how often exit IP is re-verified)") _fld(timing, "Full pool refresh (sec)", "refresh", str(s.full_refresh_seconds), "(re-fetch + re-validate)") val_sec = _section("Validation") _fld(val_sec, "Concurrent validators", "conc", str(s.validation_concurrency)) _fld(val_sec, "Stop after N valid proxies found", "minpool", str(s.min_pool_size), "(early-exit — stop testing once enough found)") _fld(val_sec, "Max candidates to test per cycle", "maxc", str(s.max_candidates), "(shuffled random sample from fetch)") _fld(val_sec, "Per-proxy timeout (sec)", "timeout", str(s.validation_timeout_seconds)) sec_sec = _section("Security") ks_row = ctk.CTkFrame(sec_sec, fg_color="transparent") ks_row.pack(fill="x", padx=12, pady=8) ks_var = ctk.BooleanVar(value=s.kill_switch_enabled) ctk.CTkCheckBox( ks_row, text="Firewall kill-switch (block ALL traffic if chain is down — requires Admin)", variable=ks_var, font=(FONT, 11), fg_color=ACCENT2, hover_color=ACCENT, text_color=TEXT, ).pack(side="left") def _apply_point_and_shoot() -> None: """Simple safe defaults: secure + low-friction launch profile.""" use_manual_var.set(True) mode_var.set("auto") elite_var.set(False) ks_var.set(True) dns_flush_var.set(True) mac_var.set(False) host_var.set(False) ipv6_var.set(False) webrtc_var.set(True) br_force_proxy_var.set(True) br_disable_webrtc_var.set(True) br_rfp_var.set(True) br_telemetry_var.set(True) br_fpi_var.set(True) br_strict_tp_var.set(True) br_tz_utc_var.set(True) br_clear_var.set(True) br_disposable_var.set(False) br_kill_drop_var.set(True) br_auto_relaunch_var.set(False) br_lock_profile_var.set(True) if not firefox_path_var.get().strip(): firefox_path_var.set(default_firefox_path()) if not firefox_profile_var.get().strip(): firefox_profile_var.set(default_profile_dir()) _save_settings(verbose=False) _log("⚡ Point-and-shoot preset applied.") ready_btn = _btn( topbar, "⚡ Ready", _apply_point_and_shoot, w=78, fg_color="#0f766e", hover_color="#0d9488", ) ready_btn.pack(side="left", padx=(8, 2)) ctk.CTkFrame(sf_outer, fg_color="transparent", height=4).pack() _btn(sf_outer, "Save All Settings", lambda: _save_settings(verbose=True), w=220, h=36, font=(FONT, 13)).pack(anchor="w", padx=6, pady=8) # ───────────────────────────────────────────────────────────────────────── # SAVE SETTINGS # ───────────────────────────────────────────────────────────────────────── def _save_settings(verbose: bool = False) -> None: try: src_raw = sources_box.get("1.0", "end").strip() src_list = [ln.strip() for ln in src_raw.splitlines() if ln.strip().startswith("http")] n_hops = max(1, len(manual_chain)) if manual_chain else 1 ns = Settings( local_host=LISTEN_HOST, local_port=int(entries["port"].get().strip()), chain_length=n_hops, obfuscation_mode=mode_var.get(), use_pinned_chain=bool(use_manual_var.get()), pinned_chain=list(manual_chain), manual_exit_proxy=merge_proxy_credentials( exit_proxy_entry.get(), exit_user_entry.get(), exit_pass_entry.get(), ), health_check_seconds=min(3600, max(10, int(entries["health"].get().strip()))), full_refresh_seconds=min(86400, max(60, int(entries["refresh"].get().strip()))), validation_concurrency=max(1, int(entries["conc"].get().strip())), min_pool_size=max(3, int(entries["minpool"].get().strip())), max_candidates=max(10, int(entries["maxc"].get().strip())), validation_timeout_seconds=min(120.0, max(2.0, float(entries["timeout"].get().strip()))), prefer_elite=bool(elite_var.get()), kill_switch_enabled=bool(ks_var.get()), proxy_bypass=entries["bypass"].get().strip() or Settings().proxy_bypass, sources=src_list or Settings().sources, ip_check_url=entries["check_url"].get().strip() or Settings().ip_check_url, mac_spoof_enabled=bool(mac_var.get()), spoof_hostname_enabled=bool(host_var.get()), flush_dns_on_rotate=bool(dns_flush_var.get()), disable_ipv6_while_active=bool(ipv6_var.get()), harden_webrtc_enabled=bool(webrtc_var.get()), firefox_path=firefox_path_var.get().strip(), firefox_profile_dir=firefox_profile_var.get().strip(), browser_clear_on_close=bool(br_clear_var.get()), browser_disposable_profile=bool(br_disposable_var.get()), browser_kill_on_chain_drop=bool(br_kill_drop_var.get()), browser_auto_relaunch=bool(br_auto_relaunch_var.get()), browser_lock_managed_profile=bool(br_lock_profile_var.get()), browser_force_proxy=bool(br_force_proxy_var.get()), browser_disable_webrtc=bool(br_disable_webrtc_var.get()), browser_resist_fingerprinting=bool(br_rfp_var.get()), browser_disable_telemetry=bool(br_telemetry_var.get()), browser_first_party_isolation=bool(br_fpi_var.get()), browser_strict_tracking_protection=bool(br_strict_tp_var.get()), browser_timezone_utc=bool(br_tz_utc_var.get()), ) if not (1 <= ns.local_port <= 65535): raise ValueError("Port must be 1-65535") svc.update_settings(ns) save_settings(ns) proxy_lbl.configure(text=f"{LISTEN_HOST}:{ns.local_port}") if verbose: _log("✓ Settings saved.") except Exception as e: _log(f"⚠ Settings error: {e!s}") # ───────────────────────────────────────────────────────────────────────── # STATUS REFRESHERS # ───────────────────────────────────────────────────────────────────────── def _refresh_sysproxy() -> None: on = is_system_proxy_set() sys_lbl.configure(text="SYS:ON" if on else "SYS:OFF", text_color=GREEN if on else DIM) def _refresh_fw(engaged: bool | None = None) -> None: if engaged is None: engaged = fw_is_engaged() fw_lbl.configure(text="FW:ON" if engaged else "FW:OFF", text_color=GREEN if engaged else DIM) # ───────────────────────────────────────────────────────────────────────── # MESSAGE PUMP # ───────────────────────────────────────────────────────────────────────── def _handle(m: dict[str, Any]) -> None: t = m.get("type") if t == "log": _log(str(m.get("text", ""))) elif t == "state": running = bool(m.get("running")) status_dot.configure(text_color=GREEN if running else RED) status_txt.configure(text="RUNNING" if running else "STOPPED") _refresh_sysproxy() if running: tray.set_state("yellow", exit_ip=None) if not running: prog_bar.set(0) phase_lbl.configure(text="idle") countdown_lbl.configure(text="next: —", text_color=TEXT2) tray.set_state("gray", exit_ip=None) v_exit_ip.set("—") v_rotation.set("0") elif t == "phase": ph = str(m.get("phase", "")) phase_labels = { "validate": "validate", "fetch": "fetch", "running": "running", "exit_check": "fixed exit", "verify_chain": "verify chain", "gost_start": "starting chain", } phase_lbl.configure(text=phase_labels.get(ph, ph or "idle")) if ph == "validate": prog_bar.configure(progress_color=YELLOW) elif ph == "fetch": prog_bar.configure(progress_color=ORANGE) prog_bar.set(0.15) elif ph == "exit_check": prog_bar.configure(progress_color=YELLOW) prog_bar.set(0.96) elif ph == "gost_start": prog_bar.configure(progress_color=GREEN) prog_bar.set(0.985) elif ph == "verify_chain": prog_bar.configure(progress_color=GREEN) prog_bar.set(0.98) elif ph == "running": prog_bar.configure(progress_color=GREEN) prog_bar.set(1.0) elif ph in ("idle", ""): prog_bar.set(0) elif t == "validate_progress": d, tot = int(m.get("done", 0)), max(1, int(m.get("total", 1))) prog_bar.set(d / tot) elif t == "pool": cnt = int(m.get("count", 0)) pool_lbl.configure(text=f"pool: {cnt}") v_pool.set(str(cnt)) elif t == "real_ip": ip = str(m.get("ip", "—")) your_ip_lbl.configure(text=f"Direct IP: {ip}") v_real_ip.set(ip) elif t == "vpn": nonlocal outer_hop_label if m.get("active"): outer_hop_label = str(m.get("label", "VPN"))[:12] vpn_status_lbl.configure( text=f"VPN: {m.get('label', 'Active')}" + (f" ({m.get('adapter')})" if m.get("adapter") else ""), text_color=GREEN, ) leak_mode_lbl.configure( text=f"Leak check: {m.get('leak_mode', 'VPN-aware')}", text_color=TEXT2, ) else: outer_hop_label = "Direct" vpn_status_lbl.configure( text="VPN: not detected (direct connection)", text_color=YELLOW, ) leak_mode_lbl.configure( text=f"Leak check: {m.get('leak_mode', 'strict')}", text_color=TEXT2, ) elif t == "firewall": _refresh_fw(bool(m.get("engaged"))) elif t == "rotation": n = str(m.get("n", 0)) rotation_lbl.configure(text=f"rot: {n}") v_rotation.set(n) elif t == "countdown": secs = int(m.get("secs", 0)) if secs > 0: m_s, s_s = divmod(secs, 60) countdown_lbl.configure( text=f"next: {m_s}m{s_s:02d}s", text_color=YELLOW if secs < 30 else TEXT2, ) else: countdown_lbl.configure(text="next: checking…", text_color=YELLOW) elif t == "hops": hops = [str(x) for x in (m.get("hops") or [])] status = str(m.get("status", "connecting")) exit_ip = m.get("exit_ip") exit_s = str(exit_ip) if exit_ip else None fix = normalize_proxy_url(svc.settings.manual_exit_proxy) fixed_last = bool(fix) and not svc.settings.use_pinned_chain _render_chain(hops, status, exit_ip, fixed_last=fixed_last) _refresh_sysproxy() tray_color = {"healthy": "green", "dead": "red", "connecting": "yellow"}.get( status, "yellow" ) tray.set_state(tray_color, exit_ip=exit_s) v_exit_ip.set(exit_s if exit_s else "—") if status == "dead" and browser.is_running() and bool(br_kill_drop_var.get()): browser.stop(dispose=bool(br_disposable_var.get())) _refresh_browser_status() _log("Browser stopped because chain dropped (Kill-on-drop enabled).") def _pump() -> None: try: while True: _handle(ui_q.get_nowait()) except queue.Empty: pass if browser_should_run[0] and not browser.is_running(): cfg = _browser_cfg() now = time.monotonic() if cfg.auto_relaunch and (now - browser_last_launch_ts[0]) >= 3.0: if _launch_browser_with_cfg(cfg): browser_last_launch_ts[0] = now root.after(80, _pump) # ───────────────────────────────────────────────────────────────────────── # CLOSE / MINIMIZE # ───────────────────────────────────────────────────────────────────────── def _close() -> None: _cancel_pulse() browser_should_run[0] = False browser.stop(dispose=bool(br_disposable_var.get())) tray.stop() svc.stop() clear_system_proxy() if is_admin() and fw_is_engaged(): fw_disengage() root.destroy() root.protocol("WM_DELETE_WINDOW", lambda: root.withdraw()) # ───────────────────────────────────────────────────────────────────────── # INIT # ───────────────────────────────────────────────────────────────────────── _refresh_boot() _refresh_sysproxy() _refresh_fw() _refresh_vpn_ui() _refresh_browser_status() _refresh_fingerprint() _log("─" * 60) _log("Proxy God v2 — ready.") _log(f"Admin: {'YES — kill-switch + privacy hardening available' if is_admin() else 'NO — run as Admin for full privacy tools'}") _log(f"Log file: {LOG_PATH}") _log("Press START to fetch, validate and chain proxies.") _log("Chain Builder → build your chain, Test entire chain, then Start.") _log("Browser tab → launch hardened Firefox profile that follows your chain.") _log("Privacy tab → MAC, hostname, IPv6, WebRTC, fingerprint audit, DNS checks.") _log("Works with or without VPN — leak detection adapts automatically.") _log("─" * 60) _pump() root.mainloop() if __name__ == "__main__": main()