#!/usr/bin/env python3 import argparse import base64 import datetime as dt import dataclasses import enum from email.parser import BytesParser from email.policy import default as email_policy_default import hmac import hashlib import html import http.client import json import os import re import secrets import select import signal import socket import ssl import sqlite3 import struct import subprocess import shutil import sys import tarfile import tempfile import threading import time import urllib.error import urllib.parse import urllib.request import uuid from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer from pathlib import Path try: from pywebpush import WebPushException, webpush except Exception: WebPushException = None webpush = None try: from fido2.server import Fido2Server from fido2.webauthn import ( AuthenticationResponse, AttestedCredentialData, PublicKeyCredentialDescriptor, PublicKeyCredentialRpEntity, PublicKeyCredentialType, PublicKeyCredentialUserEntity, ResidentKeyRequirement, UserVerificationRequirement, ) except Exception: Fido2Server = None AuthenticationResponse = None AttestedCredentialData = None PublicKeyCredentialDescriptor = None PublicKeyCredentialRpEntity = None PublicKeyCredentialType = None PublicKeyCredentialUserEntity = None ResidentKeyRequirement = None UserVerificationRequirement = None APP_NAME = "OpenWrt Remote Hub" RAW_REPO_BASE = "https://raw.githubusercontent.com/kzolotarev95/luci-app-owrt-remote/main" APP_DIR = Path(__file__).resolve().parent STATIC_DIR = APP_DIR / "static" BRAND_THEME_COLOR = "#24192f" FAVICON_ICO_FILE = STATIC_DIR / "favicon.ico" FAVICON_PNG_32_FILE = STATIC_DIR / "favicon-32.png" FAVICON_PNG_192_FILE = STATIC_DIR / "favicon-192.png" FAVICON_PNG_512_FILE = STATIC_DIR / "favicon-512.png" APPLE_TOUCH_ICON_FILE = STATIC_DIR / "apple-touch-icon.png" STATE_DIR = Path(os.environ.get("OWRT_REMOTE_STATE_DIR", "/var/lib/owrt-remote")) DB_PATH = Path(os.environ.get("OWRT_REMOTE_DB", str(STATE_DIR / "hub.db"))) AUTH_FILE = STATE_DIR / "hub-auth.json" SESSION_TOKEN_FILE = STATE_DIR / "hub-session.token" SESSIONS_FILE = STATE_DIR / "hub-sessions.json" NOTIFICATIONS_FILE = STATE_DIR / "hub-notifications.json" PUSH_SUBSCRIPTIONS_FILE = STATE_DIR / "hub-push-subscriptions.json" PUSH_DELIVERY_FILE = STATE_DIR / "hub-push-delivery.json" VAPID_PRIVATE_KEY_FILE = STATE_DIR / "hub-vapid-private.pem" VAPID_PUBLIC_KEY_FILE = STATE_DIR / "hub-vapid-public.txt" BOOT_ID_FILE = STATE_DIR / "hub-boot.id" AGENT_TOKEN_FILE = STATE_DIR / "agent.token" XRAY_WAN_RECONNECT_FILE = STATE_DIR / "xray-wan-reconnect-restart.json" TRAFFIC_COUNTERS_FILE = STATE_DIR / "hub-traffic-counters.json" ACME_WEBROOT = STATE_DIR / "acme-webroot" ONLINE_AFTER_SECONDS = int(os.environ.get("OWRT_REMOTE_ONLINE_AFTER", "75")) DEFAULT_VLESS_PORT = int(os.environ.get("OWRT_REMOTE_VLESS_PORT", "8443")) REQUEST_QUEUE_SIZE = int(os.environ.get("OWRT_REMOTE_REQUEST_QUEUE_SIZE", "128")) ROUTER_PROXY_LIMIT = max(1, int(os.environ.get("OWRT_REMOTE_ROUTER_PROXY_LIMIT", "4"))) PROXY_TIMEOUT = float(os.environ.get("OWRT_REMOTE_PROXY_TIMEOUT", "25")) STATIC_CACHE_TTL = int(os.environ.get("OWRT_REMOTE_STATIC_CACHE_TTL", "3600")) STATIC_CACHE_MAX_BYTES = int(os.environ.get("OWRT_REMOTE_STATIC_CACHE_MAX_BYTES", str(8 * 1024 * 1024))) try: SERVICE_WORKER_VERSION = str(int(Path(__file__).stat().st_mtime)) except Exception: SERVICE_WORKER_VERSION = "1" PBKDF2_ITERATIONS = 240000 MIN_PASSWORD_LENGTH = 4 SESSION_COOKIE = "owrt_remote_session" ROUTER_COOKIE = "owrt_remote_router" SESSION_TTL_SECONDS = int(os.environ.get("OWRT_REMOTE_SESSION_TTL", str(30 * 24 * 60 * 60))) CAPTCHA_TTL_SECONDS = 600 CAPTCHA_MODE_DIGITS = "digits" CAPTCHA_MODE_RECAPTCHA = "recaptcha" RECAPTCHA_FALLBACK_MARKER = "__OWRT_REMOTE_RECAPTCHA_FALLBACK__:" ROUTER_ACCESS_FLAGS = ("A", "B", "G") ROUTER_ACCESS_LABELS = { "A": "Web only", "B": "Web + SSH", "G": "Full router access", } RECAPTCHA_VERIFY_URL = "https://www.google.com/recaptcha/api/siteverify" try: RECAPTCHA_VERIFY_TIMEOUT_SECONDS = max(2.0, min(20.0, float(os.environ.get("OWRT_REMOTE_RECAPTCHA_TIMEOUT", "6")))) except ValueError: RECAPTCHA_VERIFY_TIMEOUT_SECONDS = 6.0 AUTH_CHALLENGE_TTL_SECONDS = 300 TOTP_PERIOD_SECONDS = 30 TOTP_DIGITS = 6 NOTIFICATIONS_MAX = 220 LUCI_ABSOLUTE_ROOTS = ("/ubus", "/cgi-bin/luci", "/luci-static") WS_GUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11" VPS_TERMINAL_ID = "__vps__" SSH_HTTP_SESSIONS = {} SSH_HTTP_LOCK = threading.Lock() ROUTER_PROXY_LOCK = threading.Lock() ROUTER_PROXY_LIMITERS = {} STATIC_CACHE_LOCK = threading.Lock() NOTIFICATIONS_LOCK = threading.Lock() NOTIFICATIONS_COND = threading.Condition() PUSH_LOCK = threading.Lock() TRAFFIC_COUNTERS_LOCK = threading.Lock() AUTH_STATE_LOCK = threading.Lock() AUTH_FLOW_LOCK = threading.Lock() STATIC_CACHE = {} STATIC_CACHE_BYTES = 0 AUTH_FLOW_STATE = {} BACKUP_VERSION = 1 BACKUP_STATE_FILES = ( AUTH_FILE, SESSION_TOKEN_FILE, SESSIONS_FILE, NOTIFICATIONS_FILE, PUSH_SUBSCRIPTIONS_FILE, VAPID_PRIVATE_KEY_FILE, VAPID_PUBLIC_KEY_FILE, BOOT_ID_FILE, AGENT_TOKEN_FILE, XRAY_WAN_RECONNECT_FILE, TRAFFIC_COUNTERS_FILE, ) SOCIAL_PROVIDERS = { "github": { "label": "GitHub", "authorize_url": "https://github.com/login/oauth/authorize", "token_url": "https://github.com/login/oauth/access_token", }, "vk": { "label": "VK ID", "authorize_url": "https://id.vk.ru/authorize", "token_url": "https://id.vk.ru/oauth2/auth", "api_url": "https://id.vk.ru/oauth2/user_info", }, } def now_ts(): return int(time.time()) def atomic_write_text(path, text, mode=None): path = Path(path) path.parent.mkdir(parents=True, exist_ok=True) tmp = path.with_name(f".{path.name}.{os.getpid()}.tmp") tmp.write_text(text, encoding="utf-8") if mode is not None: os.chmod(tmp, mode) os.replace(tmp, path) def iso_time(ts): if not ts: return "" return dt.datetime.fromtimestamp(int(ts), tz=dt.timezone.utc).isoformat() def format_router_note_time(ts): if not ts: return "Дата публикации неизвестна" return dt.datetime.fromtimestamp(int(ts), tz=dt.timezone.utc).strftime("%d.%m.%Y %H:%M UTC") def router_proxy_limiter(router_id): with ROUTER_PROXY_LOCK: limiter = ROUTER_PROXY_LIMITERS.get(router_id) if limiter is None: limiter = threading.BoundedSemaphore(ROUTER_PROXY_LIMIT) ROUTER_PROXY_LIMITERS[router_id] = limiter return limiter def is_luci_static_target(target): return target.split("?", 1)[0].startswith("/luci-static/") def static_cache_key(router_id, target): return f"{router_id}\0{target}" def static_cache_get(key): global STATIC_CACHE_BYTES if STATIC_CACHE_TTL <= 0 or STATIC_CACHE_MAX_BYTES <= 0: return None with STATIC_CACHE_LOCK: item = STATIC_CACHE.get(key) if not item: return None if time.time() - item["ts"] > STATIC_CACHE_TTL: STATIC_CACHE_BYTES -= len(item["body"]) STATIC_CACHE.pop(key, None) return None return ( item["status"], item["body"], item["content_type"], list(item["headers"]), ) def static_cache_put(key, status, body, content_type, headers): global STATIC_CACHE_BYTES if STATIC_CACHE_TTL <= 0 or STATIC_CACHE_MAX_BYTES <= 0: return if status != 200 or len(body) > STATIC_CACHE_MAX_BYTES: return with STATIC_CACHE_LOCK: old = STATIC_CACHE.get(key) if old: STATIC_CACHE_BYTES -= len(old["body"]) STATIC_CACHE[key] = { "ts": time.time(), "status": status, "body": body, "content_type": content_type, "headers": list(headers), } STATIC_CACHE_BYTES += len(body) while STATIC_CACHE_BYTES > STATIC_CACHE_MAX_BYTES and STATIC_CACHE: oldest_key = min(STATIC_CACHE, key=lambda item_key: STATIC_CACHE[item_key]["ts"]) oldest = STATIC_CACHE.pop(oldest_key) STATIC_CACHE_BYTES -= len(oldest["body"]) def static_cache_headers(headers): skip = { "cache-control", "connection", "content-length", "content-type", "keep-alive", "proxy-authenticate", "proxy-authorization", "set-cookie", "te", "trailers", "transfer-encoding", "upgrade", } return [(key, value) for key, value in headers if key.lower() not in skip] def ensure_state(): STATE_DIR.mkdir(parents=True, exist_ok=True) def read_or_make_token(path): ensure_state() if path.exists(): token = path.read_text(encoding="utf-8").strip() if token: return token token = secrets.token_urlsafe(32) path.write_text(token + "\n", encoding="utf-8") try: os.chmod(path, 0o600) except OSError: pass return token def agent_token(): return os.environ.get("OWRT_REMOTE_AGENT_TOKEN") or read_or_make_token(AGENT_TOKEN_FILE) def session_token(): return read_or_make_token(SESSION_TOKEN_FILE) def password_digest(password, salt=None, iterations=PBKDF2_ITERATIONS): salt = salt or secrets.token_hex(16) raw = hashlib.pbkdf2_hmac( "sha256", password.encode("utf-8"), bytes.fromhex(salt), int(iterations), ) return { "salt": salt, "hash": raw.hex(), "iterations": int(iterations), } def write_json_private(path, data): ensure_state() path.write_text(json.dumps(data, ensure_ascii=False, indent=2) + "\n", encoding="utf-8") try: os.chmod(path, 0o600) except OSError: pass def b64url_decode(raw): text = str(raw or "").strip() if not text: return b"" text += "=" * ((4 - len(text) % 4) % 4) return base64.urlsafe_b64decode(text.encode("ascii")) def normalize_totp_secret(value): text = re.sub(r"[^A-Z2-7]", "", str(value or "").upper()) if not text: return "" padded = text + ("=" * ((8 - len(text) % 8) % 8)) base64.b32decode(padded.encode("ascii"), casefold=True) return text def generate_totp_secret(): return base64.b32encode(secrets.token_bytes(20)).decode("ascii").rstrip("=") def totp_token(secret, counter, digits=TOTP_DIGITS): clean_secret = normalize_totp_secret(secret) padded = clean_secret + ("=" * ((8 - len(clean_secret) % 8) % 8)) key = base64.b32decode(padded.encode("ascii"), casefold=True) msg = struct.pack(">Q", int(counter)) digest = hmac.new(key, msg, hashlib.sha1).digest() offset = digest[-1] & 0x0F value = struct.unpack(">I", digest[offset : offset + 4])[0] & 0x7FFFFFFF return str(value % (10**digits)).zfill(digits) def verify_totp(secret, code, ts=None, window=1, digits=TOTP_DIGITS, period=TOTP_PERIOD_SECONDS): clean_secret = normalize_totp_secret(secret) clean_code = re.sub(r"\s+", "", str(code or "")) if not clean_secret or not clean_code.isdigit(): return False current_counter = int((ts or now_ts()) // max(1, int(period or TOTP_PERIOD_SECONDS))) for shift in range(-max(0, int(window)), max(0, int(window)) + 1): if secrets.compare_digest(totp_token(clean_secret, current_counter + shift, digits=digits), clean_code): return True return False def totp_otpauth_uri(username, secret, issuer=APP_NAME): safe_user = urllib.parse.quote(str(username or "admin")) safe_issuer = urllib.parse.quote(str(issuer or APP_NAME)) return f"otpauth://totp/{safe_issuer}:{safe_user}?secret={secret}&issuer={safe_issuer}&algorithm=SHA1&digits={TOTP_DIGITS}&period={TOTP_PERIOD_SECONDS}" def default_totp_state(): return { "enabled": False, "secret": "", "digits": TOTP_DIGITS, "period": TOTP_PERIOD_SECONDS, "updated_at": 0, } def normalize_ssh_public_key(value): text = " ".join(str(value or "").strip().split()) if not text: raise ValueError("SSH public key is empty") if not (text.startswith("ssh-ed25519 ") or text.startswith("sk-ssh-ed25519@openssh.com ")): raise ValueError("Only ED25519 SSH public keys are supported") parts = text.split(" ", 2) if len(parts) < 2: raise ValueError("SSH public key format is invalid") base64.b64decode(parts[1].encode("ascii"), validate=True) return text def sanitize_passkey_record(item): item = dict(item or {}) transports = item.get("transports", []) if not isinstance(transports, list): transports = [] return { "id": str(item.get("id") or "").strip(), "label": str(item.get("label") or "Passkey").strip()[:80] or "Passkey", "credential_data": str(item.get("credential_data") or "").strip(), "created_at": int(item.get("created_at") or 0), "last_used_at": int(item.get("last_used_at") or 0), "sign_count": int(item.get("sign_count") or 0), "transports": [str(value).strip() for value in transports if str(value).strip()], } def sanitize_ssh_key_record(item): item = dict(item or {}) public_key = str(item.get("public_key") or "").strip() if not public_key: return None try: public_key = normalize_ssh_public_key(public_key) except ValueError: return None return { "id": str(item.get("id") or "").strip() or secrets.token_hex(8), "label": str(item.get("label") or "SSH ED25519").strip()[:80] or "SSH ED25519", "public_key": public_key, "created_at": int(item.get("created_at") or now_ts()), "last_used_at": int(item.get("last_used_at") or 0), } def social_provider_label(provider): return SOCIAL_PROVIDERS.get(str(provider or "").strip().lower(), {}).get("label", "OAuth") def default_social_provider_state(provider=""): return { "client_id": "", "client_secret": "", "accounts": [], } def social_provider_secret_label(provider): provider = str(provider or "").strip().lower() if provider == "vk": return "Service Token" return "Client Secret" def social_provider_secret_required(provider): provider = str(provider or "").strip().lower() return provider != "vk" def social_provider_configured(provider, item): provider = str(provider or "").strip().lower() item = dict(item or {}) if not item.get("client_id"): return False if social_provider_secret_required(provider): return bool(item.get("client_secret")) return True def social_provider_setup_message(provider): label = social_provider_label(provider) if social_provider_secret_required(provider): return f"Сначала сохрани client_id и {social_provider_secret_label(provider).lower()} для {label}" return f"Сначала сохрани client_id для {label}" def sanitize_social_account_record(provider, item): item = dict(item or {}) account_id = str(item.get("id") or "").strip() if not account_id: return None login = str(item.get("login") or "").strip()[:120] name = str(item.get("name") or "").strip()[:160] email = str(item.get("email") or "").strip()[:160] label = str(item.get("label") or "").strip()[:160] if not label: label = name or login or email or f"{social_provider_label(provider)} #{account_id}" return { "id": account_id, "label": label, "login": login, "name": name, "email": email, "profile_url": str(item.get("profile_url") or "").strip()[:500], "avatar_url": str(item.get("avatar_url") or "").strip()[:500], "linked_at": int(item.get("linked_at") or now_ts()), "last_used_at": int(item.get("last_used_at") or 0), } def sanitize_social_provider_state(provider, item): clean = default_social_provider_state(provider) item = dict(item or {}) clean["client_id"] = str(item.get("client_id") or "").strip()[:240] clean["client_secret"] = str(item.get("client_secret") or "").strip()[:512] seen = set() accounts = [] for row in item.get("accounts", []) if isinstance(item.get("accounts"), list) else []: account = sanitize_social_account_record(provider, row) if not account or account["id"] in seen: continue seen.add(account["id"]) accounts.append(account) clean["accounts"] = accounts return clean def social_provider_enabled(provider, item): item = dict(item or {}) return bool(social_provider_configured(provider, item) and item.get("accounts")) def social_public_meta(auth=None): auth = normalize_auth_state(auth or load_auth()) social = auth.get("social", {}) result = {} for provider in SOCIAL_PROVIDERS: item = sanitize_social_provider_state(provider, social.get(provider)) result[provider] = { "label": social_provider_label(provider), "configured": social_provider_configured(provider, item), "linked_count": len(item.get("accounts", [])), "enabled": social_provider_enabled(provider, item), } return result def default_captcha_state(): return { "mode": CAPTCHA_MODE_DIGITS, "site_key": "", "secret_key": "", } def sanitize_captcha_mode(value): value = str(value or "").strip().lower() return CAPTCHA_MODE_RECAPTCHA if value == CAPTCHA_MODE_RECAPTCHA else CAPTCHA_MODE_DIGITS def sanitize_captcha_state(item): clean = default_captcha_state() item = dict(item or {}) clean["mode"] = sanitize_captcha_mode(item.get("mode")) clean["site_key"] = str(item.get("site_key") or "").strip()[:240] clean["secret_key"] = str(item.get("secret_key") or "").strip()[:512] return clean def effective_captcha_state(auth=None): auth = normalize_auth_state(auth or load_auth()) state = sanitize_captcha_state(auth.get("captcha")) configured = bool(state.get("site_key") and state.get("secret_key")) effective_mode = CAPTCHA_MODE_RECAPTCHA if state.get("mode") == CAPTCHA_MODE_RECAPTCHA and configured else CAPTCHA_MODE_DIGITS state["configured"] = configured state["effective_mode"] = effective_mode return state def normalize_auth_state(data): raw = dict(data or {}) state = { "version": max(2, int(raw.get("version") or 2)), "username": clean_username(raw.get("username", "admin")), "password": raw.get("password") if isinstance(raw.get("password"), dict) else {}, "updated_at": int(raw.get("updated_at") or now_ts()), } totp = default_totp_state() if isinstance(raw.get("totp"), dict): totp.update(raw.get("totp") or {}) try: totp["secret"] = normalize_totp_secret(totp.get("secret")) except ValueError: totp["secret"] = "" totp["enabled"] = bool(totp.get("enabled") and totp.get("secret")) totp["digits"] = TOTP_DIGITS totp["period"] = TOTP_PERIOD_SECONDS totp["updated_at"] = int(totp.get("updated_at") or 0) state["totp"] = totp seen_passkeys = set() passkeys = [] for item in raw.get("passkeys", []) if isinstance(raw.get("passkeys"), list) else []: clean = sanitize_passkey_record(item) if not clean["id"] or not clean["credential_data"] or clean["id"] in seen_passkeys: continue seen_passkeys.add(clean["id"]) passkeys.append(clean) seen_ssh_keys = set() ssh_keys = [] for item in raw.get("ssh_keys", []) if isinstance(raw.get("ssh_keys"), list) else []: clean = sanitize_ssh_key_record(item) if not clean or clean["id"] in seen_ssh_keys: continue seen_ssh_keys.add(clean["id"]) ssh_keys.append(clean) state["passkeys"] = passkeys state["ssh_keys"] = ssh_keys state["captcha"] = sanitize_captcha_state(raw.get("captcha")) delegated_users = [] seen_delegated_usernames = {state["username"]} for item in raw.get("delegated_users", []) if isinstance(raw.get("delegated_users"), list) else []: clean = sanitize_delegated_user_record(item) if not clean: continue username = clean.get("username", "") if not username or username in seen_delegated_usernames: continue seen_delegated_usernames.add(username) delegated_users.append(clean) delegated_users.sort(key=lambda item: str(item.get("username") or "").lower()) state["delegated_users"] = delegated_users social_state = {} raw_social = raw.get("social") if isinstance(raw.get("social"), dict) else {} for provider in SOCIAL_PROVIDERS: social_state[provider] = sanitize_social_provider_state(provider, raw_social.get(provider)) state["social"] = social_state return state def normalize_router_access_flags(value): flags = set() if isinstance(value, (list, tuple, set)): items = value else: items = re.findall(r"[ABG]", str(value or "").upper()) for item in items: token = str(item or "").strip().upper() if token in ROUTER_ACCESS_FLAGS: flags.add(token) if "G" in flags: return ["G"] if "B" in flags: return ["A", "B"] if "A" in flags: return ["A"] return [] def expand_router_access_flags(value): flags = normalize_router_access_flags(value) if "G" in flags: return {"A", "B", "G"} if "B" in flags: return {"A", "B"} if "A" in flags: return {"A"} return set() def sanitize_router_access_map(value): if not isinstance(value, dict): return {} clean = {} for router_id, flags in value.items(): try: router_key = clean_router_id(router_id) except Exception: continue normalized = normalize_router_access_flags(flags) if normalized: clean[router_key] = normalized return dict(sorted(clean.items(), key=lambda item: item[0].lower())) def sanitize_delegated_user_record(item): if not isinstance(item, dict): return None try: username = clean_username(item.get("username", "")) except Exception: return None password = item.get("password") if isinstance(item.get("password"), dict) else {} if not str(password.get("hash") or "").strip(): return None ts = now_ts() return { "id": str(item.get("id") or secrets.token_hex(8)).strip()[:64] or secrets.token_hex(8), "username": username, "password": password, "enabled": bool(item.get("enabled", True)), "router_flags": sanitize_router_access_map(item.get("router_flags")), "created_at": int(item.get("created_at") or ts), "updated_at": int(item.get("updated_at") or ts), } def auth_password_matches(stored, password): stored = stored if isinstance(stored, dict) else {} digest = password_digest(password or "", stored.get("salt"), stored.get("iterations", PBKDF2_ITERATIONS)) return secrets.compare_digest(digest["hash"], str(stored.get("hash") or "")) def find_delegated_user(auth, username): wanted = str(username or "").strip() if not wanted: return None for item in normalize_auth_state(auth).get("delegated_users", []): if secrets.compare_digest(item.get("username", ""), wanted): return item return None def effective_router_access_map(user): if not isinstance(user, dict): return {} result = {} for router_id, flags in (user.get("router_flags") or {}).items(): expanded = sorted(expand_router_access_flags(flags)) if expanded: result[str(router_id)] = expanded return result def account_profile(auth, username): auth = normalize_auth_state(auth or load_auth()) wanted = str(username or "").strip() owner_username = auth.get("username", "admin") if wanted and secrets.compare_digest(wanted, owner_username): return { "username": owner_username, "is_owner": True, "enabled": True, "router_flags": {}, "router_ids": [], } delegated = find_delegated_user(auth, wanted) if not delegated or not delegated.get("enabled"): return None router_map = effective_router_access_map(delegated) return { "id": delegated.get("id", ""), "username": delegated.get("username", ""), "is_owner": False, "enabled": True, "router_flags": router_map, "router_ids": sorted(router_map.keys()), } def router_flags_for_account(account, router_id): if not isinstance(account, dict): return set() if account.get("is_owner"): return {"A", "B", "G"} return set((account.get("router_flags") or {}).get(str(router_id or ""), [])) def account_has_router_flag(account, router_id, flag): token = str(flag or "").strip().upper() if token == "A": return bool(router_flags_for_account(account, router_id) & {"A", "B", "G"}) if token == "B": return bool(router_flags_for_account(account, router_id) & {"B", "G"}) if token == "G": return "G" in router_flags_for_account(account, router_id) return False def account_can_add_router(account): if not isinstance(account, dict): return False if account.get("is_owner"): return True for flags in (account.get("router_flags") or {}).values(): if "G" in set(flags or []): return True return False def grant_delegated_router_flag(auth, username, router_id, flag="G"): auth = normalize_auth_state(auth or load_auth()) wanted_user = str(username or "").strip() wanted_router = str(router_id or "").strip() token = str(flag or "").strip().upper() if not wanted_user or not wanted_router or token not in ROUTER_ACCESS_FLAGS: return auth updated_users = [] changed = False for item in auth.get("delegated_users", []): current_username = str(item.get("username") or "").strip() if not secrets.compare_digest(current_username, wanted_user): updated_users.append(item) continue router_flags = sanitize_router_access_map(item.get("router_flags")) next_flags = set(router_flags.get(wanted_router, [])) if token not in next_flags: next_flags.add(token) router_flags[wanted_router] = [candidate for candidate in ROUTER_ACCESS_FLAGS if candidate in next_flags] item = {**item, "router_flags": router_flags, "updated_at": now_ts()} changed = True updated_users.append(item) if not changed: return auth return save_auth_state({**auth, "delegated_users": updated_users}) def delegated_user_session_snapshot(session_rows=None): rows = [item for item in (session_rows or []) if isinstance(item, dict)] if not rows: return { "count": 0, "created_at": 0, "last_seen": 0, "ip": "", "client": "", "auth_method": "", } rows.sort(key=lambda item: (int(item.get("last_seen") or 0), int(item.get("created_at") or 0)), reverse=True) latest = rows[0] return { "count": len(rows), "created_at": int(latest.get("created_at") or 0), "last_seen": int(latest.get("last_seen") or 0), "ip": str(latest.get("ip") or ""), "client": str(latest.get("client") or ""), "auth_method": str(latest.get("auth_method") or ""), } def delegated_user_login_snapshot(login_rows=None): rows = [item for item in (login_rows or []) if isinstance(item, dict)] if not rows: return { "count": 0, "ts": 0, "ip": "", "client": "", "auth_method": "", } rows.sort(key=lambda item: int(item.get("ts") or 0), reverse=True) latest = rows[0] return { "count": len(rows), "ts": int(latest.get("ts") or 0), "ip": str(latest.get("ip") or ""), "client": str(latest.get("client") or ""), "auth_method": str(latest.get("auth_method") or ""), } def serialize_delegated_user(auth, user, router_rows=None, session_rows=None, login_rows=None): auth = normalize_auth_state(auth or load_auth()) user = sanitize_delegated_user_record(user) if not user: return None session = delegated_user_session_snapshot(session_rows) login = delegated_user_login_snapshot(login_rows) active_session_count = int(session.get("count") or 0) login_count = int(login.get("count") or 0) last_login_at = int(login.get("ts") or session.get("created_at") or 0) last_seen_at = int(session.get("last_seen") or login.get("ts") or 0) last_ip = session.get("ip") or login.get("ip") or "" last_client = session.get("client") or login.get("client") or "" last_auth_method = session.get("auth_method") or login.get("auth_method") or "" router_name_map = {} for row in router_rows or []: router = row_to_router(row) router_name_map[str(router.get("id") or "")] = str(router.get("name") or router.get("id") or "") router_access = [] for router_id, flags in effective_router_access_map(user).items(): label = "".join(flag for flag in ROUTER_ACCESS_FLAGS if flag in flags) router_access.append( { "id": router_id, "name": router_name_map.get(router_id, router_id), "flags": flags, "flag_label": label or "-", } ) router_access.sort(key=lambda item: str(item.get("name") or item.get("id") or "").lower()) return { "id": user.get("id", ""), "username": user.get("username", ""), "enabled": bool(user.get("enabled")), "created_at": int(user.get("created_at") or 0), "updated_at": int(user.get("updated_at") or 0), "router_flags": effective_router_access_map(user), "router_access": router_access, "router_count": len(router_access), "session_count": active_session_count, "login_count": login_count, "online": bool(active_session_count), "last_login_at": last_login_at, "last_seen_at": last_seen_at, "last_ip": last_ip, "last_client": last_client, "last_auth_method": last_auth_method, } def public_auth_meta(auth=None): auth = normalize_auth_state(auth or load_auth()) captcha = effective_captcha_state(auth) passkey_info = passkey_inventory(auth) return { "username": auth.get("username", "admin"), "totp_enabled": bool(auth.get("totp", {}).get("enabled")), "passkeys_supported": passkey_supported(), "passkey_count": len(passkey_info.get("credentials", [])), "passkey_invalid_count": int(passkey_info.get("invalid_count", 0)), "ssh_key_count": len(auth.get("ssh_keys", [])), "ed25519_enabled": bool(auth.get("ssh_keys", [])), "ssh_keys": [{"id": item.get("id", ""), "label": item.get("label", "SSH ED25519")} for item in auth.get("ssh_keys", [])], "captcha": { "mode": captcha.get("effective_mode", CAPTCHA_MODE_DIGITS), "configured": bool(captcha.get("configured")), "site_key": captcha.get("site_key", "") if captcha.get("configured") else "", }, "social": social_public_meta(auth), } def admin_auth_meta(auth=None): auth = normalize_auth_state(auth or load_auth()) captcha = effective_captcha_state(auth) return { **public_auth_meta(auth), "captcha": { "mode": sanitize_captcha_mode(auth.get("captcha", {}).get("mode")), "effective_mode": captcha.get("effective_mode", CAPTCHA_MODE_DIGITS), "configured": bool(captcha.get("configured")), "site_key": auth.get("captcha", {}).get("site_key", ""), "secret_key": auth.get("captcha", {}).get("secret_key", ""), }, "passkeys": [ { "id": item.get("id", ""), "label": item.get("label", "Passkey"), "created_at": int(item.get("created_at") or 0), "last_used_at": int(item.get("last_used_at") or 0), } for item in auth.get("passkeys", []) ], "ssh_keys": [ { "id": item.get("id", ""), "label": item.get("label", "SSH ED25519"), "created_at": int(item.get("created_at") or 0), "last_used_at": int(item.get("last_used_at") or 0), "public_key": item.get("public_key", ""), } for item in auth.get("ssh_keys", []) ], "social": { provider: { "label": social_provider_label(provider), "client_id": auth.get("social", {}).get(provider, {}).get("client_id", ""), "client_secret": auth.get("social", {}).get(provider, {}).get("client_secret", ""), "configured": social_provider_configured(provider, auth.get("social", {}).get(provider, {})), "linked_count": len(auth.get("social", {}).get(provider, {}).get("accounts", [])), "enabled": social_provider_enabled(provider, auth.get("social", {}).get(provider, {})), "accounts": list(auth.get("social", {}).get(provider, {}).get("accounts", [])), } for provider in SOCIAL_PROVIDERS }, } def auth_method_label(value): value = str(value or "").strip().lower() if value == "passkey": return "Passkey" if value == "ed25519": return "ED25519" if value == "password+totp": return "Password + 2FA" if value == "password": return "Password" if value == "github": return "GitHub" if value == "vk": return "VK ID" return "Auth" def passkey_supported(): return Fido2Server is not None and PublicKeyCredentialRpEntity is not None def webauthn_json(value): if dataclasses.is_dataclass(value): return {field.name: webauthn_json(getattr(value, field.name)) for field in dataclasses.fields(value)} if isinstance(value, enum.Enum): return value.value if isinstance(value, bytes): return b64url(value) if isinstance(value, dict): return {str(key): webauthn_json(item) for key, item in value.items() if item is not None} if isinstance(value, (list, tuple, set)): return [webauthn_json(item) for item in value if item is not None] return value def save_auth_state(data): clean = normalize_auth_state(data) clean["updated_at"] = now_ts() write_json_private(AUTH_FILE, clean) return clean def update_auth_state(mutator): with AUTH_STATE_LOCK: current = normalize_auth_state(load_auth()) result = mutator(current) return save_auth_state(result if isinstance(result, dict) else current) def passkey_inventory(auth=None): auth = normalize_auth_state(auth or load_auth()) credentials = [] invalid_count = 0 for item in auth.get("passkeys", []): try: credentials.append(AttestedCredentialData(b64url_decode(item.get("credential_data", "")))) except Exception: invalid_count += 1 return { "credentials": credentials, "stored_count": len(auth.get("passkeys", [])), "invalid_count": invalid_count, } def passkey_credentials(auth=None): return passkey_inventory(auth).get("credentials", []) def find_passkey_record(auth, credential_id): wanted = str(credential_id or "").strip() for item in normalize_auth_state(auth).get("passkeys", []): if item.get("id") == wanted: return item return None def find_ssh_key_record(auth, key_id): wanted = str(key_id or "").strip() for item in normalize_auth_state(auth).get("ssh_keys", []): if item.get("id") == wanted: return item return None def find_social_account_record(auth, provider, account_id): wanted = str(account_id or "").strip() if not wanted: return None social = normalize_auth_state(auth).get("social", {}) for item in social.get(str(provider or "").strip().lower(), {}).get("accounts", []): if item.get("id") == wanted: return item return None def upsert_social_account(auth, provider, account): clean = normalize_auth_state(auth) provider = str(provider or "").strip().lower() if provider not in SOCIAL_PROVIDERS: raise ValueError("unknown provider") account_row = sanitize_social_account_record(provider, account) if not account_row: raise ValueError("account is empty") items = [] replaced = False for current in clean.get("social", {}).get(provider, {}).get("accounts", []): if current.get("id") == account_row["id"]: merged = dict(current) merged.update(account_row) merged["linked_at"] = int(current.get("linked_at") or account_row.get("linked_at") or now_ts()) merged["last_used_at"] = int(current.get("last_used_at") or account_row.get("last_used_at") or 0) items.append(sanitize_social_account_record(provider, merged)) replaced = True else: items.append(current) if not replaced: items.append(account_row) clean["social"][provider]["accounts"] = [item for item in items if item] return clean def remove_social_account(auth, provider, account_id): clean = normalize_auth_state(auth) provider = str(provider or "").strip().lower() clean["social"][provider]["accounts"] = [ item for item in clean.get("social", {}).get(provider, {}).get("accounts", []) if item.get("id") != str(account_id or "").strip() ] return clean def touch_social_account_last_used(auth, provider, account_id): clean = normalize_auth_state(auth) provider = str(provider or "").strip().lower() now = now_ts() for item in clean.get("social", {}).get(provider, {}).get("accounts", []): if item.get("id") == str(account_id or "").strip(): item["last_used_at"] = now break return clean def oauth_fetch_json(url, method="GET", headers=None, data=None, timeout=15): payload = None header_map = {str(key): str(value) for key, value in dict(headers or {}).items()} if data is not None: if isinstance(data, (bytes, bytearray)): payload = bytes(data) elif isinstance(data, dict): payload = urllib.parse.urlencode(data).encode("utf-8") if not any(str(key).lower() == "content-type" for key in header_map): header_map["Content-Type"] = "application/x-www-form-urlencoded" else: payload = str(data).encode("utf-8") request = urllib.request.Request(url, data=payload, method=str(method or "GET").upper()) base_headers = {"User-Agent": f"{APP_NAME}/1.0", "Accept": "application/json"} for key, value in header_map.items(): request.add_header(str(key), str(value)) for key, value in base_headers.items(): if not request.has_header(key): request.add_header(key, value) try: with urllib.request.urlopen(request, timeout=float(timeout or 15)) as response: body = response.read().decode("utf-8", "replace") return json.loads(body or "{}") except urllib.error.HTTPError as exc: body = exc.read().decode("utf-8", "replace") try: detail = json.loads(body or "{}") except Exception: detail = {"error": body[:400] or exc.reason} message = detail.get("error_description") or detail.get("error") or detail.get("message") or exc.reason raise ValueError(str(message or "OAuth HTTP error")) except Exception as exc: raise ValueError(str(exc)) def origin_from_parts(scheme, host): scheme = str(scheme or "").strip().lower() host = str(host or "").strip() if not scheme or not host: return "" parts = urllib.parse.urlsplit(f"{scheme}://{host}") if not parts.scheme or not parts.hostname: return "" default_port = 443 if parts.scheme == "https" else 80 if parts.scheme == "http" else None netloc = parts.hostname if parts.port and parts.port != default_port: netloc = f"{netloc}:{parts.port}" return f"{parts.scheme}://{netloc}" def public_url_origin(public_url): value = str(public_url or "").strip() if not value: return "" parts = urllib.parse.urlsplit(value) if not parts.scheme or not parts.netloc: return "" return origin_from_parts(parts.scheme, parts.netloc) def append_forwarded_port(scheme, host, forwarded_port=""): scheme = str(scheme or "").strip().lower() host = str(host or "").strip() forwarded_port = str(forwarded_port or "").split(",", 1)[0].strip() if not host: return "" try: parts = urllib.parse.urlsplit(f"{scheme or 'http'}://{host}") except Exception: return host if not parts.hostname: return host if parts.port: return parts.netloc or host try: port = int(forwarded_port) except (TypeError, ValueError): return parts.netloc or host if not (0 < port < 65536): return parts.netloc or host default_port = 443 if scheme == "https" else 80 if scheme == "http" else None if default_port and port == default_port: return parts.netloc or host host_name = parts.hostname if ":" in host_name and not host_name.startswith("["): host_name = f"[{host_name}]" return f"{host_name}:{port}" def prefer_origin_with_explicit_port(primary="", secondary=""): primary = str(primary or "").strip() secondary = str(secondary or "").strip() if not primary: return secondary if not secondary: return primary try: primary_parts = urllib.parse.urlsplit(primary) secondary_parts = urllib.parse.urlsplit(secondary) if ( primary_parts.scheme == secondary_parts.scheme and (primary_parts.hostname or "") == (secondary_parts.hostname or "") and not primary_parts.port and secondary_parts.port ): return secondary except Exception: pass return primary def public_url_rp_id(public_url): value = str(public_url or "").strip() if not value: return "" try: return urllib.parse.urlsplit(value).hostname or "" except Exception: return "" def vps_host_name(value): raw = str(value or "").strip() if not raw: return "" try: parsed = urllib.parse.urlsplit(raw if "://" in raw else f"//{raw}") return parsed.hostname or "" except Exception: return "" def should_preserve_router_vps_fallback(vps_host="", public_url=""): next_vps_host = vps_host_name(vps_host) next_public_host = public_url_rp_id(public_url) return bool(next_vps_host and next_public_host and next_vps_host == next_public_host) def router_fallback_hub_url(router, fallback_host="", port=8088): host = str((router or {}).get("vps_host") or "").strip() host = vps_host_name(host) or vps_host_name(fallback_host) or "127.0.0.1" return f"http://{host}:{int(port or 8088)}" def row_str_value(row, key, default=""): try: value = row[key] except (TypeError, KeyError, IndexError): value = None if value in (None, ""): return default return str(value) def row_int_value(row, key, default=0): try: value = row[key] except (TypeError, KeyError, IndexError): value = None try: return int(value) except (TypeError, ValueError): return int(default) def canonical_router_hub_update(router, app_public_url="", request_origin=""): router = router or {} router_public_url = public_url_origin(router.get("public_url", "")) app_origin = public_url_origin(app_public_url) request_origin = public_url_origin(request_origin) public_url = prefer_origin_with_explicit_port(router_public_url, app_origin) public_url = prefer_origin_with_explicit_port(public_url, request_origin) hub_url = public_url or request_origin vps_host = str(router.get("vps_host") or "").strip() if not vps_host and hub_url: try: vps_host = urllib.parse.urlsplit(hub_url).hostname or "" except Exception: vps_host = "" return { "hub_url": hub_url, "public_url": public_url, "vps_host": vps_host, } def verify_password_login(username, password, otp=""): auth = load_auth() profile = account_profile(auth, username) if not profile: return False, "Неверный логин или пароль", {}, "password" if not verify_login(username, password): return False, "Неверный логин или пароль", auth, "password" if profile.get("is_owner"): totp = auth.get("totp", {}) else: totp = {} if totp.get("enabled"): if not verify_totp(totp.get("secret", ""), otp): return False, "Неверный или пустой код 2FA. Введи 6-значный код из приложения.", auth, "password+totp" return True, "", profile, "password+totp" return True, "", profile, "password" def ssh_auth_namespace(): return "owrt-remote-hub" def ssh_auth_principal(username=""): return (clean_username(username or current_username()) or "admin").replace(" ", "_") def build_ssh_auth_message(ticket, username="", host="", issued_at=0): lines = [ "OpenWrt Remote Hub ED25519 login", f"ticket={ticket}", f"user={clean_username(username or current_username())}", f"host={host or '-'}", f"issued_at={int(issued_at or now_ts())}", ] return "\n".join(lines) + "\n" def ssh_auth_message_variants(message): text = str(message or "") variants = [] seen = set() def add(value): if value not in seen: seen.add(value) variants.append(value) add(text) normalized = text.replace("\r\n", "\n").replace("\r", "\n") add(normalized) add(normalized.replace("\n", "\r\n")) trimmed = normalized.rstrip("\r\n") if trimmed: add(trimmed) add(trimmed + "\n") add(trimmed.replace("\n", "\r\n")) add(trimmed.replace("\n", "\r\n") + "\r\n") return variants def verify_ssh_auth_signature(ssh_keys, username, message, signature_text): signature_text = str(signature_text or "").strip() if "BEGIN SSH SIGNATURE" not in signature_text: raise ValueError("Вставь ASCII SSH signature целиком") namespace = ssh_auth_namespace() principal = ssh_auth_principal(username) message_variants = ssh_auth_message_variants(message) for item in [sanitize_ssh_key_record(row) for row in (ssh_keys or [])]: if not item: continue with tempfile.TemporaryDirectory(prefix="owrt-hub-ssh-auth-") as tmp_name: tmp_dir = Path(tmp_name) allowed = tmp_dir / "allowed_signers" sig_file = tmp_dir / "challenge.sig" allowed.write_text(f"{principal} {item['public_key']}\n", encoding="utf-8") sig_file.write_text(signature_text + "\n", encoding="utf-8") for candidate in message_variants: try: result = subprocess.run( [ "ssh-keygen", "-Y", "verify", "-f", str(allowed), "-I", principal, "-n", namespace, "-s", str(sig_file), ], input=candidate.encode("utf-8"), stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=10, ) except FileNotFoundError as exc: raise ValueError("ssh-keygen не найден на сервере") from exc except subprocess.TimeoutExpired as exc: raise ValueError("Проверка подписи ED25519 превысила таймаут") from exc if result.returncode == 0: return item raise ValueError("Подпись ED25519 не подошла ни к одному зарегистрированному ключу") def prune_auth_flows(): now = now_ts() expired = [ticket for ticket, item in AUTH_FLOW_STATE.items() if now - int(item.get("created_at") or 0) > AUTH_CHALLENGE_TTL_SECONDS] for ticket in expired: AUTH_FLOW_STATE.pop(ticket, None) def put_auth_flow(kind, payload): with AUTH_FLOW_LOCK: prune_auth_flows() ticket = secrets.token_urlsafe(24) AUTH_FLOW_STATE[ticket] = {"kind": str(kind or ""), "created_at": now_ts(), **dict(payload or {})} return ticket def get_auth_flow(ticket, kind=""): with AUTH_FLOW_LOCK: prune_auth_flows() item = AUTH_FLOW_STATE.get(str(ticket or "")) if not item: return None if kind and item.get("kind") != kind: return None return dict(item) def pop_auth_flow(ticket, kind=""): with AUTH_FLOW_LOCK: prune_auth_flows() item = AUTH_FLOW_STATE.get(str(ticket or "")) if not item: return None if kind and item.get("kind") != kind: return None return AUTH_FLOW_STATE.pop(str(ticket or ""), None) def clamp_nonnegative_int(value): try: return max(0, int(value)) except (TypeError, ValueError): return 0 def load_traffic_counters(): ensure_state() if not TRAFFIC_COUNTERS_FILE.exists(): return {"version": 1, "routers": {}} try: data = json.loads(TRAFFIC_COUNTERS_FILE.read_text(encoding="utf-8")) except Exception: return {"version": 1, "routers": {}} routers = data.get("routers") if not isinstance(routers, dict): routers = {} return {"version": 1, "routers": routers} def save_traffic_counters(data): payload = {"version": 1, "routers": data.get("routers") if isinstance(data, dict) else {}} atomic_write_text(TRAFFIC_COUNTERS_FILE, json.dumps(payload, ensure_ascii=False, indent=2) + "\n", mode=0o600) def accumulate_traffic_clients(router_id, clients): router_key = str(router_id or "").strip() if not router_key or not isinstance(clients, list): return clients now = now_ts() with TRAFFIC_COUNTERS_LOCK: state = load_traffic_counters() routers = state.setdefault("routers", {}) current_router_state = routers.get(router_key) if not isinstance(current_router_state, dict): current_router_state = {} router_state = {} for mac, item in current_router_state.items(): if not isinstance(item, dict): continue mac_key = str(mac or "").strip().upper() if mac_key: router_state[mac_key] = item changed = router_state != current_router_state for client in clients: mac_key = str(client.get("mac") or "").strip().upper() if not mac_key: continue raw_rx = clamp_nonnegative_int(client.get("rx_bytes")) raw_tx = clamp_nonnegative_int(client.get("tx_bytes")) saved = router_state.get(mac_key) if isinstance(saved, dict): prev_raw_rx = clamp_nonnegative_int(saved.get("raw_rx_bytes")) prev_raw_tx = clamp_nonnegative_int(saved.get("raw_tx_bytes")) total_rx = clamp_nonnegative_int(saved.get("rx_bytes")) + max(0, raw_rx - prev_raw_rx) total_tx = clamp_nonnegative_int(saved.get("tx_bytes")) + max(0, raw_tx - prev_raw_tx) else: total_rx = raw_rx total_tx = raw_tx client["rx_bytes"] = total_rx client["tx_bytes"] = total_tx client["total_bytes"] = total_rx + total_tx next_saved = { "raw_rx_bytes": raw_rx, "raw_tx_bytes": raw_tx, "rx_bytes": total_rx, "tx_bytes": total_tx, "updated_at": now, "ip": str(client.get("ip") or ""), "name": str(client.get("name") or ""), } if router_state.get(mac_key) != next_saved: router_state[mac_key] = next_saved changed = True if changed or routers.get(router_key) != router_state: routers[router_key] = router_state save_traffic_counters(state) return clients def clear_traffic_counters(router_id): router_key = str(router_id or "").strip() if not router_key: return with TRAFFIC_COUNTERS_LOCK: state = load_traffic_counters() routers = state.get("routers") if not isinstance(routers, dict) or router_key not in routers: return routers.pop(router_key, None) save_traffic_counters(state) def save_auth(username, password): username = clean_username(username) if len(password) < MIN_PASSWORD_LENGTH: raise ValueError(f"password must be at least {MIN_PASSWORD_LENGTH} characters") try: data = normalize_auth_state(load_auth()) except Exception: data = normalize_auth_state({"username": username}) data["username"] = username data["password"] = password_digest(password) data["updated_at"] = now_ts() write_json_private(AUTH_FILE, data) return data def load_auth(): ensure_state() if AUTH_FILE.exists(): raw = json.loads(AUTH_FILE.read_text(encoding="utf-8")) data = normalize_auth_state(raw) if data != raw: write_json_private(AUTH_FILE, data) return data username = os.environ.get("OWRT_REMOTE_ADMIN_USER", "admin") password = os.environ.get("OWRT_REMOTE_ADMIN_PASSWORD") or "admin" data = save_auth(username, password) login_hint = STATE_DIR / "hub-login.txt" login_hint.write_text( f"username: {data['username']}\npassword: {password}\n", encoding="utf-8", ) try: os.chmod(login_hint, 0o600) except OSError: pass return data def clean_username(value): value = (value or "").strip() if not (1 <= len(value) <= 64): raise ValueError("username length must be 1..64") for ch in value: if not (ch.isalnum() or ch in "._-@"): raise ValueError("username may contain only letters, digits, . _ - @") return value def verify_login(username, password): try: auth = load_auth() except Exception: return False wanted = str(username or "").strip() if not wanted: return False if secrets.compare_digest(wanted, auth.get("username", "")): return auth_password_matches(auth.get("password", {}), password) delegated = find_delegated_user(auth, wanted) if not delegated or not delegated.get("enabled"): return False return auth_password_matches(delegated.get("password", {}), password) def current_username(): try: return load_auth().get("username", "admin") except Exception: return "admin" def session_hash(token): return hashlib.sha256((token or "").encode("utf-8")).hexdigest() def load_sessions(): ensure_state() if not SESSIONS_FILE.exists(): return [] try: data = json.loads(SESSIONS_FILE.read_text(encoding="utf-8")) except Exception: return [] if isinstance(data, dict): data = data.get("sessions", []) if not isinstance(data, list): return [] now = now_ts() return [item for item in data if isinstance(item, dict) and int(item.get("expires_at") or 0) > now] def save_sessions(sessions): write_json_private(SESSIONS_FILE, {"sessions": sessions}) def short_user_agent(value): value = " ".join(str(value or "").split()) if not value: return "unknown" if len(value) > 160: return value[:157] + "..." return value def normalize_client_hint(value): hint = str(value or "").strip().lower() if hint in {"hub", "pwa", "standalone", "ios-home-screen", "home-screen"}: return "hub" return "" def client_label(user_agent, client_hint=""): ua = (user_agent or "").lower() if "iphone" in ua or "ipad" in ua: device = "iPhone/iPad" elif "android" in ua: device = "Android" elif "windows" in ua: device = "Windows" elif "mac os" in ua or "macintosh" in ua: device = "Mac" elif "linux" in ua: device = "Linux" else: device = "Устройство" if normalize_client_hint(client_hint) == "hub": return f"{device} · Hub" if "telegram" in ua: browser = "Telegram" elif "edg/" in ua: browser = "Edge" elif "chrome/" in ua and "chromium" not in ua: browser = "Chrome" elif "safari/" in ua and "chrome/" not in ua: browser = "Safari" elif "firefox/" in ua: browser = "Firefox" else: browser = "браузер" return f"{device} · {browser}" def make_hub_session(username, ip, user_agent, auth_method="password"): token = secrets.token_urlsafe(36) ts = now_ts() session = { "id": secrets.token_hex(8), "token_hash": session_hash(token), "username": username or current_username(), "ip": ip or "", "user_agent": short_user_agent(user_agent), "client": client_label(user_agent), "created_at": ts, "last_seen": ts, "expires_at": ts + SESSION_TTL_SECONDS, "auth_method": str(auth_method or "password"), } sessions = load_sessions() sessions.append(session) save_sessions(sessions[-60:]) return token, session def verify_hub_session(token, touch=True, ip="", user_agent=""): if not token: return None wanted = session_hash(token) sessions = load_sessions() changed = False result = None ts = now_ts() current_ip = str(ip or "").strip() current_user_agent = short_user_agent(user_agent or "") for session in sessions: if secrets.compare_digest(session.get("token_hash", ""), wanted): result = session if touch: current_client = client_label(user_agent or "", session.get("client_hint", "")) old_ip = str(session.get("ip") or "").strip() if current_ip and old_ip and current_ip != old_ip: known_ips = [str(item).strip() for item in session.get("known_ips", []) if str(item).strip()] for value in (old_ip, current_ip): if value not in known_ips: known_ips.append(value) session["known_ips"] = known_ips[-10:] session["ip"] = current_ip session["ip_changed_at"] = ts if current_user_agent: session["user_agent"] = current_user_agent if current_client: session["client"] = current_client add_notification( "session-ip", "Новый IP в активной сессии", f"{session.get('client', 'устройство')} · {old_ip} -> {current_ip}", "warn", [current_user_agent] if current_user_agent else [], {"session_id": session.get("id", ""), "old_ip": old_ip, "ip": current_ip}, dedupe_seconds=45, ) session["last_seen"] = ts session["expires_at"] = ts + SESSION_TTL_SECONDS changed = True elif current_ip and not old_ip: session["ip"] = current_ip changed = True old_user_agent = str(session.get("user_agent") or "").strip() if current_user_agent and old_user_agent and current_user_agent != old_user_agent: old_client = session.get("client") or client_label(old_user_agent, session.get("client_hint", "")) session["user_agent"] = current_user_agent session["client"] = current_client or client_label(current_user_agent, session.get("client_hint", "")) add_notification( "session-client", "Новое устройство в активной сессии", f"{old_client} -> {session.get('client', 'устройство')} · IP {current_ip or session.get('ip', 'unknown')}", "warn", [current_user_agent], {"session_id": session.get("id", ""), "ip": current_ip or session.get("ip", "")}, dedupe_seconds=60, ) changed = True if ts - int(session.get("last_seen") or 0) > 60: session["last_seen"] = ts session["expires_at"] = ts + SESSION_TTL_SECONDS changed = True elif changed: session["expires_at"] = ts + SESSION_TTL_SECONDS break if changed: save_sessions(sessions) return result def update_hub_session_client_hint(token, client_hint): token = str(token or "").strip() client_hint = normalize_client_hint(client_hint) if not token or not client_hint: return None wanted = session_hash(token) sessions = load_sessions() changed = False result = None ts = now_ts() for session in sessions: if not secrets.compare_digest(session.get("token_hash", ""), wanted): continue result = session old_hint = normalize_client_hint(session.get("client_hint", "")) if old_hint == client_hint: break session["client_hint"] = client_hint session["client"] = client_label(session.get("user_agent", ""), client_hint) session["last_seen"] = ts session["expires_at"] = ts + SESSION_TTL_SECONDS changed = True break if changed: save_sessions(sessions) return result def revoke_hub_session(session_id="", token=""): sessions = load_sessions() wanted_hash = session_hash(token) if token else "" kept = [] removed = 0 for session in sessions: if session_id and session.get("id") == session_id: removed += 1 continue if wanted_hash and secrets.compare_digest(session.get("token_hash", ""), wanted_hash): removed += 1 continue kept.append(session) if removed: save_sessions(kept) return removed def revoke_hub_sessions_for_username(username=""): wanted_user = str(username or "").strip() if not wanted_user: return 0 revoke_ids = { str(session.get("id") or "") for session in load_sessions() if str(session.get("username") or "").strip() == wanted_user } removed = 0 for session_id in revoke_ids: if not session_id: continue removed += revoke_hub_session(session_id=session_id) return removed def list_hub_sessions(current_token="", username=""): current_hash = session_hash(current_token) if current_token else "" wanted_user = str(username or "").strip() rows = [] for session in sorted(load_sessions(), key=lambda item: int(item.get("last_seen") or 0), reverse=True): session_username = str(session.get("username") or "") if wanted_user and not secrets.compare_digest(session_username, wanted_user): continue rows.append( { "id": session.get("id", ""), "username": session_username, "ip": session.get("ip", ""), "client": session.get("client") or client_label(session.get("user_agent", "")), "user_agent": session.get("user_agent", ""), "created_at": int(session.get("created_at") or 0), "last_seen": int(session.get("last_seen") or 0), "expires_at": int(session.get("expires_at") or 0), "auth_method": str(session.get("auth_method") or "password"), "current": bool(current_hash and secrets.compare_digest(session.get("token_hash", ""), current_hash)), } ) return rows def list_login_events(username=""): wanted_user = str(username or "").strip() rows = [] for item in load_notifications(): if str(item.get("kind") or "") != "login": continue data = item.get("data") if isinstance(item.get("data"), dict) else {} event_username = str(data.get("username") or "").strip() if wanted_user and not event_username: continue if wanted_user and not secrets.compare_digest(event_username, wanted_user): continue rows.append( { "id": item.get("id", ""), "username": event_username, "ip": str(data.get("ip") or ""), "client": str(data.get("client") or ""), "user_agent": str(data.get("user_agent") or ""), "ts": int(item.get("ts") or 0), "auth_method": str(data.get("auth_method") or "password"), } ) rows.sort(key=lambda item: int(item.get("ts") or 0), reverse=True) return rows def load_notifications(): ensure_state() if not NOTIFICATIONS_FILE.exists(): return [] try: data = json.loads(NOTIFICATIONS_FILE.read_text(encoding="utf-8")) except Exception: return [] if isinstance(data, dict): data = data.get("notifications", []) if not isinstance(data, list): return [] return normalize_notification_items([item for item in data if isinstance(item, dict)]) def save_notifications(items): items = normalize_notification_items(items) items = sorted( items, key=lambda item: (int(item.get("ts") or 0), int(item.get("serial") or 0)), reverse=True, )[:NOTIFICATIONS_MAX] write_json_private(NOTIFICATIONS_FILE, {"notifications": items}) def normalize_notification_items(items): rows = [dict(item) for item in (items or []) if isinstance(item, dict)] rows.sort(key=lambda item: (int(item.get("ts") or 0), int(item.get("serial") or 0), str(item.get("id") or ""))) serial = 0 for item in rows: current = int(item.get("serial") or 0) if current <= serial: serial += 1 item["serial"] = serial else: serial = current item["serial"] = current return rows def latest_notification_serial(items=None): rows = normalize_notification_items(items if items is not None else load_notifications()) return max((int(item.get("serial") or 0) for item in rows), default=0) def add_notification(kind, title, body="", level="info", details=None, data=None, dedupe_seconds=0): ts = now_ts() title = str(title or "").strip()[:120] body = str(body or "").strip()[:500] details = details or [] if isinstance(details, str): details = [details] details = [str(line).strip()[:260] for line in details if str(line).strip()][:12] item = { "id": secrets.token_hex(8), "kind": str(kind or "info")[:40], "level": str(level or "info")[:20], "title": title, "body": body, "details": details, "data": data if isinstance(data, dict) else {}, "ts": ts, "iso": iso_time(ts), } with NOTIFICATIONS_LOCK: items = load_notifications() next_serial = latest_notification_serial(items) + 1 item["serial"] = next_serial if dedupe_seconds: for old in items: if ( old.get("kind") == item["kind"] and old.get("title") == item["title"] and old.get("body") == item["body"] and ts - int(old.get("ts") or 0) <= int(dedupe_seconds) ): return old items.insert(0, item) save_notifications(items) with NOTIFICATIONS_COND: NOTIFICATIONS_COND.notify_all() queue_web_push_notification(item) return item def list_notifications(after=0, limit=60, after_serial=0): try: after = int(after or 0) except (TypeError, ValueError): after = 0 try: after_serial = int(after_serial or 0) except (TypeError, ValueError): after_serial = 0 try: limit = max(1, min(120, int(limit or 60))) except (TypeError, ValueError): limit = 60 items = load_notifications() latest_serial = max((int(item.get("serial") or 0) for item in items), default=0) if after_serial > latest_serial: after_serial = 0 if after_serial > 0: items = [item for item in items if int(item.get("serial") or 0) > after_serial] elif after > 0: items = [item for item in items if int(item.get("ts") or 0) >= after] return sorted( items, key=lambda item: (int(item.get("ts") or 0), int(item.get("serial") or 0)), reverse=True, )[:limit] def wait_for_notifications(after_serial=0, timeout=25, limit=60): try: after_serial = int(after_serial or 0) except (TypeError, ValueError): after_serial = 0 try: timeout = max(1, min(60, int(timeout or 25))) except (TypeError, ValueError): timeout = 25 deadline = time.time() + timeout while True: items = list_notifications(limit=limit, after_serial=after_serial) if items: return items remaining = deadline - time.time() if remaining <= 0: return [] with NOTIFICATIONS_COND: NOTIFICATIONS_COND.wait(timeout=remaining) def clear_notifications(): with NOTIFICATIONS_LOCK: save_notifications([]) with NOTIFICATIONS_COND: NOTIFICATIONS_COND.notify_all() def b64url(raw): return base64.urlsafe_b64encode(raw).decode("ascii").rstrip("=") def make_pkce_verifier(): verifier = secrets.token_urlsafe(64) return verifier[:96] def make_pkce_challenge(verifier): return b64url(hashlib.sha256(str(verifier or "").encode("utf-8")).digest()) def load_push_subscriptions(): ensure_state() if not PUSH_SUBSCRIPTIONS_FILE.exists(): return [] try: data = json.loads(PUSH_SUBSCRIPTIONS_FILE.read_text(encoding="utf-8")) except Exception: return [] if isinstance(data, dict): data = data.get("subscriptions", []) if not isinstance(data, list): return [] return [item for item in data if isinstance(item, dict) and item.get("endpoint")] def save_push_subscriptions(items): cleaned = [] seen = set() for item in items: endpoint = str(item.get("endpoint") or "").strip() keys = item.get("keys") if isinstance(item.get("keys"), dict) else {} client_hint = normalize_client_hint(item.get("client_hint", "")) if not endpoint or endpoint in seen: continue seen.add(endpoint) cleaned.append( { "id": item.get("id") or hashlib.sha256(endpoint.encode("utf-8")).hexdigest()[:16], "endpoint": endpoint, "keys": { "p256dh": str(keys.get("p256dh") or ""), "auth": str(keys.get("auth") or ""), }, "client": str(item.get("client") or "браузер")[:120], "client_hint": client_hint, "ip": str(item.get("ip") or "")[:80], "user_agent": str(item.get("user_agent") or "")[:260], "created_at": int(item.get("created_at") or now_ts()), "last_seen": int(item.get("last_seen") or now_ts()), } ) write_json_private(PUSH_SUBSCRIPTIONS_FILE, {"subscriptions": cleaned[-80:]}) def load_push_delivery_attempts(): ensure_state() if not PUSH_DELIVERY_FILE.exists(): return [] try: data = json.loads(PUSH_DELIVERY_FILE.read_text(encoding="utf-8")) except Exception: return [] if isinstance(data, dict): data = data.get("attempts", []) if not isinstance(data, list): return [] return [item for item in data if isinstance(item, dict)] def save_push_delivery_attempts(items): cleaned = [] for item in items: if not isinstance(item, dict): continue results = item.get("results") if isinstance(item.get("results"), list) else [] cleaned.append( { "ts": int(item.get("ts") or now_ts()), "title": str(item.get("title") or APP_NAME)[:160], "body": str(item.get("body") or "")[:260], "kind": str(item.get("kind") or "info")[:40], "summary": str(item.get("summary") or "")[:120], "results": [ { "client": str(result.get("client") or "браузер")[:120], "endpoint_host": str(result.get("endpoint_host") or "")[:120], "result": str(result.get("result") or "unknown")[:200], } for result in results if isinstance(result, dict) ][:20], } ) write_json_private(PUSH_DELIVERY_FILE, {"attempts": cleaned[-20:]}) def push_endpoint_host(endpoint): try: return (urllib.parse.urlparse(str(endpoint or "")).hostname or "")[:120] except Exception: return "" def remember_push_delivery(payload, results, summary=""): attempt = { "ts": int((payload or {}).get("ts") or now_ts()), "title": (payload or {}).get("title") or APP_NAME, "body": (payload or {}).get("body") or "", "kind": (payload or {}).get("kind") or "info", "summary": summary, "results": results, } with PUSH_LOCK: attempts = load_push_delivery_attempts() attempts.append(attempt) save_push_delivery_attempts(attempts) def web_push_backend_status(): status = { "ready": False, "reason": "", "error": "", "public_key": "", "subject": vapid_subject(), } if webpush is None or WebPushException is None: status["reason"] = "pywebpush_missing" status["error"] = "На VPS не установлен Web Push модуль. Запусти свежий install-vps.sh." return status try: public_key = vapid_public_key() except Exception as exc: detail = " ".join(str(exc).split())[:160] status["reason"] = "vapid_key_error" status["error"] = f"Не смог подготовить VAPID ключи на VPS. {detail}".strip() return status status["public_key"] = public_key if not public_key: status["reason"] = "vapid_key_missing" status["error"] = "Не смог создать VAPID ключи на VPS" return status status["ready"] = True return status def push_status_snapshot(): backend = web_push_backend_status() subscriptions = sorted( load_push_subscriptions(), key=lambda item: int(item.get("last_seen") or 0), reverse=True, ) attempts = load_push_delivery_attempts() last_attempt = attempts[-1] if attempts else None return { "ok": True, "ready": backend.get("ready", False), "ready_reason": backend.get("reason", ""), "ready_error": backend.get("error", ""), "subscription_count": len(subscriptions), "subject": backend.get("subject", vapid_subject(subscriptions[0] if subscriptions else None)), "subscriptions": [ { "id": item.get("id", ""), "client": item.get("client", "браузер"), "client_hint": item.get("client_hint", ""), "endpoint_host": push_endpoint_host(item.get("endpoint", "")), "last_seen": int(item.get("last_seen") or 0), "last_seen_iso": iso_time(int(item.get("last_seen") or 0)), } for item in subscriptions[:8] ], "last_attempt": last_attempt, } def vapid_public_key(): ensure_state() if VAPID_PUBLIC_KEY_FILE.exists() and VAPID_PRIVATE_KEY_FILE.exists(): value = VAPID_PUBLIC_KEY_FILE.read_text(encoding="utf-8").strip() if value: return value try: from cryptography.hazmat.primitives import serialization from cryptography.hazmat.primitives.asymmetric import ec except Exception: return "" private_key = ec.generate_private_key(ec.SECP256R1()) private_pem = private_key.private_bytes( encoding=serialization.Encoding.PEM, format=serialization.PrivateFormat.PKCS8, encryption_algorithm=serialization.NoEncryption(), ) public_numbers = private_key.public_key().public_numbers() public_raw = b"\x04" + public_numbers.x.to_bytes(32, "big") + public_numbers.y.to_bytes(32, "big") public_value = b64url(public_raw) VAPID_PRIVATE_KEY_FILE.write_bytes(private_pem) VAPID_PUBLIC_KEY_FILE.write_text(public_value + "\n", encoding="utf-8") try: os.chmod(VAPID_PRIVATE_KEY_FILE, 0o600) os.chmod(VAPID_PUBLIC_KEY_FILE, 0o600) except OSError: pass return public_value def web_push_ready(): return web_push_backend_status().get("ready", False) def web_push_apple_endpoint(subscription): endpoint = str((subscription or {}).get("endpoint") or "").lower() return "push.apple.com" in endpoint def vapid_subject(subscription=None): configured = str(os.environ.get("OWRT_REMOTE_VAPID_SUB", "")).strip() if configured: return configured public_url = str(os.environ.get("OWRT_REMOTE_PUBLIC_URL", "")).strip().rstrip("/") if public_url.lower().startswith("https://"): return public_url return "mailto:admin@localhost" def save_push_subscription(subscription, username="", ip="", user_agent=""): if not isinstance(subscription, dict): raise ValueError("subscription must be object") endpoint = str(subscription.get("endpoint") or "").strip() keys = subscription.get("keys") if isinstance(subscription.get("keys"), dict) else {} p256dh = str(keys.get("p256dh") or "").strip() auth = str(keys.get("auth") or "").strip() client_hint = normalize_client_hint(subscription.get("client_hint", "")) if not endpoint or not p256dh or not auth: raise ValueError("bad push subscription") ts = now_ts() item = { "id": hashlib.sha256(endpoint.encode("utf-8")).hexdigest()[:16], "endpoint": endpoint, "keys": {"p256dh": p256dh, "auth": auth}, "client": client_label(user_agent, client_hint), "client_hint": client_hint, "ip": ip or "", "user_agent": short_user_agent(user_agent), "username": username or current_username(), "created_at": ts, "last_seen": ts, } with PUSH_LOCK: items = [old for old in load_push_subscriptions() if old.get("endpoint") != endpoint] items.append(item) save_push_subscriptions(items) return item def remove_push_subscription(endpoint): endpoint = str(endpoint or "").strip() if not endpoint: return 0 with PUSH_LOCK: items = load_push_subscriptions() kept = [item for item in items if item.get("endpoint") != endpoint] if len(kept) != len(items): save_push_subscriptions(kept) return len(items) - len(kept) return 0 def push_payload_for_notification(item): payload = { "title": item.get("title") or APP_NAME, "body": item.get("body") or "", "tag": "owrt-" + str(item.get("id") or item.get("kind") or now_ts()), "url": "/", "kind": item.get("kind") or "info", "ts": int(item.get("ts") or now_ts()), } payload["web_push"] = 8030 payload["notification"] = { "title": payload["title"], "body": payload["body"], "tag": payload["tag"], "navigate": payload["url"], "silent": False, } return payload def send_web_push(subscription, payload): if not web_push_ready(): return "unavailable" try: webpush( subscription_info={ "endpoint": subscription.get("endpoint"), "keys": subscription.get("keys") or {}, }, data=json.dumps(payload, ensure_ascii=False, separators=(",", ":")), vapid_private_key=str(VAPID_PRIVATE_KEY_FILE), vapid_claims={"sub": vapid_subject(subscription)}, timeout=10, ttl=86400, ) return "ok" except Exception as exc: response = getattr(exc, "response", None) status_code = getattr(response, "status_code", None) detail = "" try: detail = str(getattr(response, "text", "") or "").strip() except Exception: detail = "" if not detail: detail = " ".join(str(exc).split()) detail = detail[:160] if status_code in (404, 410): return "gone" if detail: return f"error:{status_code or exc.__class__.__name__}:{detail}" return f"error:{status_code or exc.__class__.__name__}" def push_result_message(result, subscription=None): if result == "ok": return "" if result == "unavailable": return "На VPS не готов Web Push. Запусти свежий install-vps.sh и проверь HTTPS." if result == "gone": return "Подписка браузера устарела. Включи push заново на этом устройстве." if str(result).startswith("error:"): parts = str(result).split(":", 2) code = parts[1] if len(parts) > 1 and parts[1] else "unknown" detail = parts[2] if len(parts) > 2 else "" detail_lower = detail.lower() if web_push_apple_endpoint(subscription) and ( "badjwttoken" in detail_lower or vapid_subject(subscription) == "mailto:admin@localhost" ): return "iPhone/iPad push упёрся в VAPID subject на VPS. Включи HTTPS через enable-https.sh или задай OWRT_REMOTE_PUBLIC_URL=https://твой-домен (или OWRT_REMOTE_VAPID_SUB)." return f"VPS не смог отправить тестовый Web Push ({code}). Проверь HTTPS, DNS и install-vps.sh." return "VPS не смог подтвердить доставку Web Push." def queue_web_push_payload(payload, subscriptions=None): if subscriptions is None: subscriptions = load_push_subscriptions() if not subscriptions: remember_push_delivery(payload, [], "no_subscriptions") return def worker(): gone = [] results = [] for subscription in subscriptions: result = send_web_push(subscription, payload) results.append( { "client": subscription.get("client") or "браузер", "endpoint_host": push_endpoint_host(subscription.get("endpoint", "")), "result": result, } ) if result == "gone": gone.append(subscription.get("endpoint", "")) for endpoint in gone: remove_push_subscription(endpoint) summary = "ok" if results and all(item.get("result") == "ok" for item in results) else "partial" remember_push_delivery(payload, results, summary) threading.Thread(target=worker, daemon=True).start() def queue_web_push_notification(item): if not item: return queue_web_push_payload(push_payload_for_notification(item)) def service_worker_js(): return r""" self.addEventListener('install', event => { self.skipWaiting(); }); self.addEventListener('message', event => { if (event && event.data && event.data.type === 'SKIP_WAITING') { self.skipWaiting(); } }); self.addEventListener('activate', event => { event.waitUntil(self.clients.claim()); }); self.addEventListener('push', event => { let data = {}; try { data = event.data ? event.data.json() : {}; } catch (e) { data = {title: 'OpenWrt Remote Hub', body: event.data ? event.data.text() : ''}; } const notificationData = data && typeof data.notification === 'object' ? data.notification : null; const payload = notificationData ? { title: notificationData.title || data.title || 'OpenWrt Remote Hub', body: notificationData.body || data.body || '', tag: notificationData.tag || data.tag || 'owrt-remote-hub', url: notificationData.navigate || data.url || '/', badge: notificationData.badge || data.badge || undefined, icon: notificationData.icon || data.icon || undefined, kind: data.kind || 'info' } : data; const title = payload.title || 'OpenWrt Remote Hub'; const options = { body: payload.body || '', tag: payload.tag || 'owrt-remote-hub', renotify: true, data: {url: payload.url || '/'}, badge: payload.badge || undefined, icon: payload.icon || undefined }; event.waitUntil((async () => { const clients = await self.clients.matchAll({type: 'window', includeUncontrolled: true}); const hasVisibleClient = clients.some((client) => client && (client.visibilityState === 'visible' || client.focused)); if (hasVisibleClient && payload.kind !== 'push-test') return; await self.registration.showNotification(title, options); })()); }); self.addEventListener('notificationclick', event => { event.notification.close(); const url = (event.notification.data && event.notification.data.url) || '/'; event.waitUntil((async () => { const allClients = await self.clients.matchAll({type: 'window', includeUncontrolled: true}); for (const client of allClients) { if ('focus' in client) { await client.focus(); if ('navigate' in client) { try { await client.navigate(url); } catch (e) {} } return; } } if (self.clients.openWindow) await self.clients.openWindow(url); })()); }); """.strip() + "\n" def web_manifest_json(): return json.dumps( { "id": "/", "name": "OpenWrt Remote Hub", "short_name": "Wrt Hub", "start_url": "/", "scope": "/", "display": "standalone", "background_color": BRAND_THEME_COLOR, "theme_color": BRAND_THEME_COLOR, "description": "Удаленный доступ к OpenWrt через свой VPS", "icons": [ { "src": f"/favicon-192.png?v={SERVICE_WORKER_VERSION}", "sizes": "192x192", "type": "image/png", "purpose": "any maskable", }, { "src": f"/favicon-512.png?v={SERVICE_WORKER_VERSION}", "sizes": "512x512", "type": "image/png", "purpose": "any maskable", }, { "src": f"/apple-touch-icon.png?v={SERVICE_WORKER_VERSION}", "sizes": "180x180", "type": "image/png", "purpose": "any maskable", } ], }, ensure_ascii=False, separators=(",", ":"), ) def branding_head_tags(include_manifest=True): parts = [ f'', f'', f'', ] if include_manifest: parts.append(f'') parts.extend( [ f'', '', '', '', ] ) return "\n".join(parts) def favicon_svg(): return """ """.strip() + "\n" def run_quiet(args, timeout=2.5): try: return subprocess.run( args, stdout=subprocess.PIPE, stderr=subprocess.DEVNULL, text=True, timeout=timeout, check=False, ).stdout.strip() except Exception: return "" def current_boot_id(): try: return Path("/proc/sys/kernel/random/boot_id").read_text(encoding="utf-8").strip() except OSError: return "" def previous_boot_reason(): journal = run_quiet(["journalctl", "-b", "-1", "-n", "180", "--no-pager", "-o", "short-iso"], timeout=3.0) last_log = run_quiet(["last", "-x", "-n", "8", "reboot", "shutdown"], timeout=2.0) text = "\n".join([journal, last_log]).lower() reason = "причина не найдена в журнале" if any(word in text for word in ("out of memory", "oom-killer", "killed process", "memory cgroup out of memory")): reason = "похоже на нехватку памяти / OOM" elif any(word in text for word in ("kernel panic", "panic:")): reason = "похоже на kernel panic" elif any(word in text for word in ("watchdog", "hard lockup", "soft lockup")): reason = "похоже на watchdog/зависание" elif any(word in text for word in ("power key", "poweroff", "powering off")): reason = "похоже на выключение питания" elif any(word in text for word in ("the system will reboot now", "system reboot", "reboot.target", "systemd-reboot")): reason = "штатная перезагрузка командой reboot/systemctl" elif "shutdown" in text: reason = "штатное выключение/shutdown" details = [] for line in (journal + "\n" + last_log).splitlines(): low = line.lower() if any( marker in low for marker in ( "reboot", "shutdown", "panic", "oom", "out of memory", "watchdog", "power", "killed process", "systemd-logind", "systemd-reboot", ) ): details.append(" ".join(line.split())) if len(details) >= 8: break return reason, details def record_hub_start_event(): ensure_state() boot_id = current_boot_id() previous_boot_id = "" try: previous_boot_id = BOOT_ID_FILE.read_text(encoding="utf-8").strip() except OSError: pass if boot_id: try: BOOT_ID_FILE.write_text(boot_id + "\n", encoding="utf-8") os.chmod(BOOT_ID_FILE, 0o600) except OSError: pass if previous_boot_id and boot_id and previous_boot_id != boot_id: reason, details = previous_boot_reason() add_notification( "vps_up", "VPS снова онлайн", f"Hub запущен после перезагрузки. Причина: {reason}.", "warn", details, {"boot_id": boot_id}, dedupe_seconds=60, ) elif previous_boot_id: add_notification( "hub_restart", "Hub перезапущен", "Служба OpenWrt Remote Hub снова запущена.", "info", [], {"boot_id": boot_id}, dedupe_seconds=45, ) else: add_notification( "hub_start", "Hub запущен", "OpenWrt Remote Hub стартовал первый раз на этом VPS.", "info", [], {"boot_id": boot_id}, dedupe_seconds=60, ) def captcha_challenge(): code = str(secrets.randbelow(9000) + 1000) issued = str(now_ts()) nonce = secrets.token_urlsafe(8) body = f"{issued}:{nonce}:{code}" sig = hmac.new(session_token().encode("utf-8"), body.encode("utf-8"), hashlib.sha256).hexdigest() token = base64.urlsafe_b64encode(f"{body}:{sig}".encode("utf-8")).decode("ascii") return code, token def verify_captcha(token, answer): try: raw = base64.urlsafe_b64decode((token or "").encode("ascii")).decode("utf-8") issued, nonce, code, sig = raw.split(":", 3) body = f"{issued}:{nonce}:{code}" expected = hmac.new(session_token().encode("utf-8"), body.encode("utf-8"), hashlib.sha256).hexdigest() if not secrets.compare_digest(sig, expected): return False if now_ts() - int(issued) > CAPTCHA_TTL_SECONDS: return False return secrets.compare_digest(str(answer or "").strip(), code) except Exception: return False def verify_recaptcha_token(secret_key, response_token, remote_ip="", expected_hostname=""): secret_key = str(secret_key or "").strip() response_token = str(response_token or "").strip() if not secret_key or not response_token: return False, "Подтверди Google reCAPTCHA" payload = { "secret": secret_key, "response": response_token, } if remote_ip: payload["remoteip"] = str(remote_ip).strip() try: result = oauth_fetch_json( RECAPTCHA_VERIFY_URL, method="POST", data=payload, timeout=RECAPTCHA_VERIFY_TIMEOUT_SECONDS, ) except Exception as exc: detail = " ".join(str(exc or "").split())[:180] message = "Google reCAPTCHA недоступна с VPS. Переключил вход на локальную цифровую капчу ниже: повтори цифры и нажми Войти еще раз." if detail: message = f"{message} Причина: {detail}" return False, f"{RECAPTCHA_FALLBACK_MARKER}{message}" if not result.get("success"): errors = result.get("error-codes", []) detail = ", ".join(str(item) for item in errors if str(item).strip()) if "timeout-or-duplicate" in errors: return False, "Google reCAPTCHA устарела, попробуй еще раз" return False, f"Google reCAPTCHA отклонена{': ' + detail if detail else ''}" actual_hostname = str(result.get("hostname") or "").strip().lower() expected_hostname = str(expected_hostname or "").strip().lower() if expected_hostname and actual_hostname and actual_hostname != expected_hostname: return False, f"Google reCAPTCHA выдана для другого хоста: {actual_hostname}" return True, "" def recaptcha_fallback_message(value): text = str(value or "") if not text.startswith(RECAPTCHA_FALLBACK_MARKER): return "" return text[len(RECAPTCHA_FALLBACK_MARKER):].strip() def login_recaptcha_script(auth=None): state = effective_captcha_state(auth) if state.get("effective_mode") != CAPTCHA_MODE_RECAPTCHA: return "" return '' def legacy_login_captcha_html(auth=None): state = effective_captcha_state(auth) if state.get("effective_mode") == CAPTCHA_MODE_RECAPTCHA: safe_site_key = html.escape(state.get("site_key", ""), quote=True) return f"""
Нужен ключ Google reCAPTCHA v2 Checkbox для текущего домена. Проверка идет на сервере после отправки формы.
""" captcha_code, captcha_token = captcha_challenge() safe_captcha_token = html.escape(captcha_token, quote=True) safe_captcha_code = html.escape(captcha_code, quote=True) return f"""
{safe_captcha_code}
""" def modern_login_captcha_html(auth=None): state = effective_captcha_state(auth) if state.get("effective_mode") == CAPTCHA_MODE_RECAPTCHA: safe_site_key = html.escape(state.get("site_key", ""), quote=True) return f"""
Капча: подтверди, что ты не робот
Нужен ключ Google reCAPTCHA v2 Checkbox для текущего домена.
""" captcha_code, captcha_token = captcha_challenge() safe_captcha_token = html.escape(captcha_token, quote=True) safe_captcha_code = html.escape(captcha_code, quote=True) return f"""
Капча: введи эти цифры
{safe_captcha_code}
""" def clean_router_id(value): value = (value or "").strip() out = [] for ch in value: if ch.isalnum() or ch in "._-": out.append(ch) else: out.append("-") result = "".join(out).strip(".-_") if not result: raise ValueError("router id is empty") return result[:64] def clean_router_name(value): text = " ".join(str(value or "").replace("\r", " ").replace("\n", " ").split()).strip() if not text: raise ValueError("router name is empty") return text[:80] ROUTER_NOTE_TEXT_MAX_CHARS = 2000 ROUTER_NOTES_MAX_ENTRIES = 200 ROUTER_NOTES_STORAGE_VERSION = 1 ROUTER_NOTES_MEDIA_DIR = STATE_DIR / "router-note-images" ROUTER_NOTE_IMAGE_MAX_FILES = 8 ROUTER_NOTE_IMAGE_MAX_BYTES = 8 * 1024 * 1024 ROUTER_NOTE_IMAGE_TOTAL_MAX_BYTES = 24 * 1024 * 1024 ROUTER_NOTE_IMAGE_TYPES = { "image/jpeg": ".jpg", "image/png": ".png", "image/webp": ".webp", "image/gif": ".gif", } ROUTER_NOTE_IMAGE_EXTENSIONS = { ".jpg": "image/jpeg", ".jpeg": "image/jpeg", ".png": "image/png", ".webp": "image/webp", ".gif": "image/gif", } def clean_router_notes(value): text = str(value or "").replace("\r\n", "\n").replace("\r", "\n") lines = [line.rstrip() for line in text.split("\n")] text = "\n".join(lines).strip() return text[:ROUTER_NOTE_TEXT_MAX_CHARS] def clean_router_note_image_name(value): text = Path(str(value or "").strip()).name text = re.sub(r"\s+", " ", text).strip(" .") return (text or "image")[:120] def clean_router_note_image_item(item): if not isinstance(item, dict): return {} file_name = Path(str(item.get("file_name") or "")).name if not file_name: return {} ext = Path(file_name).suffix.lower() content_type = str(item.get("content_type") or "").split(";", 1)[0].strip().lower() if not content_type and ext in ROUTER_NOTE_IMAGE_EXTENSIONS: content_type = ROUTER_NOTE_IMAGE_EXTENSIONS[ext] if content_type not in ROUTER_NOTE_IMAGE_TYPES: return {} expected_ext = ROUTER_NOTE_IMAGE_TYPES[content_type] stem = Path(file_name).stem or secrets.token_hex(6) file_name = f"{stem}{expected_ext}" size = 0 try: size = max(0, int(item.get("size") or 0)) except (TypeError, ValueError): size = 0 return { "id": str(item.get("id") or stem)[:32], "file_name": file_name, "content_type": content_type, "name": clean_router_note_image_name(item.get("name") or file_name), "size": size, } def clean_router_note_images(items): clean_items = [] for item in list(items or [])[:ROUTER_NOTE_IMAGE_MAX_FILES]: clean_item = clean_router_note_image_item(item) if clean_item: clean_items.append(clean_item) return clean_items def router_note_media_dir(router_id, note_id=""): base = ROUTER_NOTES_MEDIA_DIR / clean_router_id(router_id) note_name = str(note_id or "").strip() if note_name: return base / note_name[:64] return base def router_note_image_path(router_id, note_id, file_name): return router_note_media_dir(router_id, note_id) / Path(str(file_name or "")).name def router_note_image_url(router_id, note_id, file_name): return ( f"/router/{urllib.parse.quote(clean_router_id(router_id))}" f"/notes-media/{urllib.parse.quote(str(note_id or '')[:64])}" f"/{urllib.parse.quote(Path(str(file_name or '')).name)}" ) def save_router_note_images(router_id, note_id, uploads): uploads = list(uploads or []) if len(uploads) > ROUTER_NOTE_IMAGE_MAX_FILES: raise ValueError(f"можно прикрепить не больше {ROUTER_NOTE_IMAGE_MAX_FILES} изображений") total_size = 0 saved = [] target_dir = router_note_media_dir(router_id, note_id) target_dir.mkdir(parents=True, exist_ok=True) for upload in uploads: raw = bytes((upload or {}).get("body") or b"") if not raw: continue total_size += len(raw) if len(raw) > ROUTER_NOTE_IMAGE_MAX_BYTES: raise ValueError("одно изображение слишком большое") if total_size > ROUTER_NOTE_IMAGE_TOTAL_MAX_BYTES: raise ValueError("общий размер изображений слишком большой") content_type = str((upload or {}).get("content_type") or "").split(";", 1)[0].strip().lower() filename = str((upload or {}).get("filename") or "") if content_type not in ROUTER_NOTE_IMAGE_TYPES: content_type = ROUTER_NOTE_IMAGE_EXTENSIONS.get(Path(filename).suffix.lower(), "") if content_type not in ROUTER_NOTE_IMAGE_TYPES: raise ValueError("поддерживаются только JPG, PNG, WEBP и GIF") image_id = secrets.token_hex(6) file_name = f"{image_id}{ROUTER_NOTE_IMAGE_TYPES[content_type]}" write_private_bytes(target_dir / file_name, raw) saved.append( { "id": image_id, "file_name": file_name, "content_type": content_type, "name": clean_router_note_image_name(filename or file_name), "size": len(raw), } ) return saved def delete_router_note_images(router_id, note_id): target = router_note_media_dir(router_id, note_id) if target.exists(): shutil.rmtree(target, ignore_errors=True) def payload_files(payload, field_name): files = (payload or {}).get("__files__", {}) if not isinstance(files, dict): return [] items = files.get(field_name, []) return list(items) if isinstance(items, list) else [] def build_router_note_entry(text, created_at=0, note_id="", images=None): clean_text = clean_router_notes(text) clean_images = clean_router_note_images(images) if not clean_text and not clean_images: return {} created = int(created_at or now_ts()) entry = { "id": str(note_id or secrets.token_hex(6))[:32], "text": clean_text, "created_at": created, } if clean_images: entry["images"] = clean_images return entry def parse_router_notes_entries(raw_value, fallback_ts=0): raw_text = str(raw_value or "").strip() if not raw_text: return [] payload = None try: payload = json.loads(raw_text) except json.JSONDecodeError: payload = None entries = [] if isinstance(payload, dict): payload_entries = payload.get("entries") if isinstance(payload_entries, list): for item in payload_entries: if not isinstance(item, dict): continue entry = build_router_note_entry( item.get("text", ""), created_at=item.get("created_at") or fallback_ts or now_ts(), note_id=item.get("id", ""), images=item.get("images") or [], ) if entry: entries.append(entry) return entries[:ROUTER_NOTES_MAX_ENTRIES] elif isinstance(payload, list): for item in payload: if not isinstance(item, dict): continue entry = build_router_note_entry( item.get("text", ""), created_at=item.get("created_at") or fallback_ts or now_ts(), note_id=item.get("id", ""), images=item.get("images") or [], ) if entry: entries.append(entry) return entries[:ROUTER_NOTES_MAX_ENTRIES] legacy_entry = build_router_note_entry(raw_text, created_at=fallback_ts or now_ts()) return [legacy_entry] if legacy_entry else [] def encode_router_notes_entries(entries): clean_entries = [] for item in list(entries or [])[:ROUTER_NOTES_MAX_ENTRIES]: if not isinstance(item, dict): continue entry = build_router_note_entry( item.get("text", ""), created_at=item.get("created_at") or now_ts(), note_id=item.get("id", ""), images=item.get("images") or [], ) if entry: clean_entries.append(entry) return json.dumps( { "version": ROUTER_NOTES_STORAGE_VERSION, "entries": clean_entries, }, ensure_ascii=False, separators=(",", ":"), ) def connect(db_path=DB_PATH): ensure_state() conn = sqlite3.connect(str(db_path)) conn.row_factory = sqlite3.Row return conn def init_db(conn): conn.execute( """ create table if not exists routers ( id text primary key, name text not null, role text not null default 'node', entry_port integer not null default 0, vps_host text not null default '', vless_port integer not null default 8443, vless_uuid text not null, vless_encryption text not null default 'none', vless_decryption text not null default 'none', vless_flow text not null default '', reverse_tag text not null default 'reverse-in', public_url text not null default '', admin_host text not null default '127.0.0.1', admin_port integer not null default 80, ssh_entry_port integer not null default 0, ssh_vless_uuid text not null default '', ssh_reverse_tag text not null default '', ssh_host text not null default '127.0.0.1', ssh_port integer not null default 22, notes text not null default '', created_at integer not null, updated_at integer not null, deleted_at integer not null default 0, last_seen integer, status_json text not null default '{}' ) """ ) ensure_column(conn, "routers", "custom_name", "text not null default ''") ensure_column(conn, "routers", "deleted_at", "integer not null default 0") ensure_column(conn, "routers", "ssh_entry_port", "integer not null default 0") ensure_column(conn, "routers", "ssh_vless_uuid", "text not null default ''") ensure_column(conn, "routers", "ssh_reverse_tag", "text not null default ''") ensure_column(conn, "routers", "ssh_host", "text not null default '127.0.0.1'") ensure_column(conn, "routers", "ssh_port", "integer not null default 22") ensure_column(conn, "routers", "notes", "text not null default ''") conn.execute( """ update routers set ssh_entry_port = entry_port + 1000 where entry_port > 0 and (ssh_entry_port is null or ssh_entry_port = 0) """ ) for row in conn.execute("select id, reverse_tag, ssh_vless_uuid, ssh_reverse_tag from routers").fetchall(): ssh_uuid = row["ssh_vless_uuid"] or str(uuid.uuid4()) ssh_tag = row["ssh_reverse_tag"] or f"{row['reverse_tag'] or 'reverse-in'}-ssh" if ssh_uuid != row["ssh_vless_uuid"] or ssh_tag != row["ssh_reverse_tag"]: conn.execute( "update routers set ssh_vless_uuid = ?, ssh_reverse_tag = ? where id = ?", (ssh_uuid, ssh_tag, row["id"]), ) conn.commit() def ensure_column(conn, table, column, definition): cols = {row["name"] for row in conn.execute(f"pragma table_info({table})")} if column not in cols: conn.execute(f"alter table {table} add column {column} {definition}") def get_router(conn, router_id): return conn.execute("select * from routers where id = ?", (router_id,)).fetchone() def router_deleted(row): if not row: return False try: return int(row["deleted_at"] or 0) > 0 except (IndexError, KeyError, TypeError, ValueError): return False def get_active_router(conn, router_id): row = get_router(conn, router_id) if router_deleted(row): return None return row def get_router_by_entry_port(conn, entry_port, exclude_id=""): return conn.execute( "select * from routers where coalesce(deleted_at, 0) = 0 and (entry_port = ? or ssh_entry_port = ?) and id != ?", (int(entry_port), int(entry_port), exclude_id), ).fetchone() def get_router_by_any_port(conn, port, exclude_id=""): return conn.execute( "select * from routers where coalesce(deleted_at, 0) = 0 and (entry_port = ? or ssh_entry_port = ?) and id != ?", (int(port), int(port), exclude_id), ).fetchone() def normalize_internal_ssh_port(ssh_port, entry_port=0, ssh_entry_port=0): try: port = int(ssh_port or 22) except (TypeError, ValueError): return 22 if port <= 0 or port in {int(entry_port or 0), int(ssh_entry_port or 0)}: return 22 return port def list_router_rows(conn): return conn.execute( """ select * from routers where coalesce(deleted_at, 0) = 0 order by case role when 'main' then 0 else 1 end, lower(id) """ ).fetchall() def row_to_router(row): data = dict(row) try: status = json.loads(data.get("status_json") or "{}") except json.JSONDecodeError: status = {} note_entries = parse_router_notes_entries(data.get("notes") or "", fallback_ts=data.get("updated_at") or data.get("created_at") or 0) latest_entry = note_entries[-1] if note_entries else {} latest_images = list(latest_entry.get("images") or []) latest_note = latest_entry.get("text") or (f"Фото: {len(latest_images)}" if latest_images else "") data["notes_entries"] = [ { **entry, "images": [ { **image, "url": router_note_image_url(data["id"], entry.get("id") or "", image.get("file_name") or ""), } for image in list(entry.get("images") or []) ], "created_at_iso": iso_time(entry.get("created_at") or 0), "created_at_label": format_router_note_time(entry.get("created_at") or 0), } for entry in note_entries ] data["notes"] = latest_note data["has_notes"] = bool(note_entries) data["notes_count"] = len(note_entries) data["notes_preview"] = " ".join(latest_note.split())[:220] custom_name = str(data.get("custom_name") or "").strip() if custom_name: data["name"] = custom_name last_seen = data.get("last_seen") service_enabled = str(status.get("service") or "").lower() != "disabled" online = bool(last_seen and now_ts() - int(last_seen) <= ONLINE_AFTER_SECONDS) data["status"] = status data["service_enabled"] = service_enabled data["online"] = online data["last_seen_iso"] = iso_time(last_seen) data["access_url"] = f"/access/{urllib.parse.quote(data['id'])}/" data["ssh_url"] = f"/ssh/{urllib.parse.quote(data['id'])}/" data["config_url"] = f"/router/{urllib.parse.quote(data['id'])}/config" data["notes_url"] = f"/router/{urllib.parse.quote(data['id'])}/notes" data["xray_client_url"] = f"/router/{urllib.parse.quote(data['id'])}/xray-client.json" data.pop("status_json", None) return data def router_with_access(router, account): router = dict(router or {}) router_id = str(router.get("id") or "") can_admin = account_has_router_flag(account, router_id, "A") can_ssh = account_has_router_flag(account, router_id, "B") can_manage = account_has_router_flag(account, router_id, "G") router["access_flags"] = sorted(router_flags_for_account(account, router_id)) router["permissions"] = { "owner": bool(account and account.get("is_owner")), "admin": bool(can_admin), "ssh": bool(can_ssh), "manage": bool(can_manage), "notes": bool(can_admin), "notes_edit": bool(can_manage), "notes_delete": bool(account and account.get("is_owner")), "config": bool(can_manage), "wol": bool(can_manage), "traffic": bool(can_manage), "delete": bool(account and account.get("is_owner")), "diagnose": bool(can_manage), } return router def delegated_auth_meta(auth=None, account=None, router_rows=None): auth = normalize_auth_state(auth or load_auth()) account = account or account_profile(auth, "") router_rows = list(router_rows or []) router_name_map = {} for row in router_rows: router = row_to_router(row) router_name_map[str(router.get("id") or "")] = str(router.get("name") or router.get("id") or "") assigned = [] for router_id in sorted((account or {}).get("router_ids", []), key=str.lower): flags = sorted(router_flags_for_account(account, router_id)) if not flags: continue assigned.append( { "id": router_id, "name": router_name_map.get(router_id, router_id), "flags": flags, "flag_label": "".join(flag for flag in ROUTER_ACCESS_FLAGS if flag in flags) or "-", } ) return { "username": (account or {}).get("username") or auth.get("username", "admin"), "is_owner": False, "can_add_router": bool(account_can_add_router(account)), "current_user": { "username": (account or {}).get("username") or auth.get("username", "admin"), "is_owner": False, }, "assigned_routers": assigned, "router_access": {item.get("id", ""): item.get("flags", []) for item in assigned}, "passkeys_supported": passkey_supported(), } def router_notification_label(router): router_id = str((router or {}).get("id") or "").strip() name = str((router or {}).get("name") or router_id or "router").strip() if router_id and name and name != router_id: return f"{name} ({router_id})" return name or router_id or "router" def router_notification_details(router): details = [] if not isinstance(router, dict): return details last_seen_iso = str(router.get("last_seen_iso") or "").strip() if last_seen_iso: details.append(f"Последний heartbeat: {last_seen_iso}") status = router.get("status") if isinstance(router.get("status"), dict) else {} wan_ip = str(status.get("wan_ip") or status.get("ip") or "").strip() if wan_ip: details.append(f"WAN IP: {wan_ip}") release = str(status.get("release") or "").strip() if release: details.append(f"Система: {release}") return details[:6] def notify_router_online(router, dedupe_seconds=45): label = router_notification_label(router) add_notification( "router_online", "Роутер снова в сети", f"{label} снова выходит на связь с Hub.", "info", router_notification_details(router), {"router_id": str((router or {}).get("id") or ""), "online": True}, dedupe_seconds=dedupe_seconds, ) def notify_router_offline(router, dedupe_seconds=0): label = router_notification_label(router) grace = max(ONLINE_AFTER_SECONDS, 1) add_notification( "router_offline", "Роутер пропал из сети", f"{label} не присылает heartbeat дольше {grace} сек.", "bad", router_notification_details(router), {"router_id": str((router or {}).get("id") or ""), "online": False}, dedupe_seconds=dedupe_seconds or max(45, grace // 2), ) def backup_filename(): stamp = dt.datetime.now(dt.timezone.utc).strftime("%Y%m%d-%H%M%S") return f"owrt-remote-hub-backup-{stamp}.tar.gz" def copy_sqlite_backup(src_path, dst_path): src_path = Path(src_path) dst_path = Path(dst_path) src_path.parent.mkdir(parents=True, exist_ok=True) dst_path.parent.mkdir(parents=True, exist_ok=True) if not src_path.exists(): conn = connect(src_path) try: init_db(conn) finally: conn.close() source = sqlite3.connect(str(src_path)) dest = sqlite3.connect(str(dst_path)) try: source.backup(dest) finally: dest.close() source.close() def write_private_bytes(path, data, mode=0o600): path = Path(path) path.parent.mkdir(parents=True, exist_ok=True) tmp = path.with_name(f".{path.name}.{os.getpid()}.tmp") tmp.write_bytes(data) try: os.chmod(tmp, mode) except OSError: pass os.replace(tmp, path) def create_hub_backup(out_path, db_path=DB_PATH): ensure_state() out_path = Path(out_path) out_path.parent.mkdir(parents=True, exist_ok=True) with tempfile.TemporaryDirectory(prefix="owrt-hub-backup-") as tmp_name: tmp_dir = Path(tmp_name) state_dir = tmp_dir / "state" state_dir.mkdir(parents=True, exist_ok=True) db_copy = state_dir / "hub.db" copy_sqlite_backup(db_path, db_copy) files = ["state/hub.db"] for path in BACKUP_STATE_FILES: path = Path(path) if not path.exists() or not path.is_file(): continue arcname = f"state/{path.name}" (state_dir / path.name).write_bytes(path.read_bytes()) files.append(arcname) manifest = { "app": APP_NAME, "version": BACKUP_VERSION, "created_at": iso_time(now_ts()), "hostname": socket.gethostname(), "state_dir": str(STATE_DIR), "db_path": str(db_path), "files": files, } (tmp_dir / "manifest.json").write_text(json.dumps(manifest, ensure_ascii=False, indent=2) + "\n", encoding="utf-8") tmp_archive = out_path.with_name(f".{out_path.name}.{os.getpid()}.tmp") with tarfile.open(tmp_archive, "w:gz") as tar: tar.add(tmp_dir / "manifest.json", arcname="manifest.json") for item in state_dir.iterdir(): if item.is_file(): tar.add(item, arcname=f"state/{item.name}") try: os.chmod(tmp_archive, 0o600) except OSError: pass os.replace(tmp_archive, out_path) return {"path": str(out_path), "filename": out_path.name, "files": files} def safe_tar_member_name(name): value = str(name or "").replace("\\", "/") if not value or value.startswith("/") or ":" in value: return False parts = value.split("/") return all(part and part not in {".", ".."} for part in parts) def extract_hub_backup(archive_path, tmp_dir): with tarfile.open(archive_path, "r:gz") as tar: members = tar.getmembers() for member in members: if not safe_tar_member_name(member.name): raise ValueError(f"unsafe backup member: {member.name}") if not (member.isfile() or member.isdir()): raise ValueError(f"unsupported backup member: {member.name}") tar.extractall(tmp_dir, members) def rewrite_router_endpoints(conn, vps_host="", public_url="", preserve_vps_fallback=False): rewritten = {} next_vps_host = str(vps_host or "").strip() next_public_url = str(public_url or "").strip() ts = now_ts() keep_vps_host = preserve_vps_fallback and should_preserve_router_vps_fallback(next_vps_host, next_public_url) if next_vps_host and not keep_vps_host: conn.execute( "update routers set vps_host = ?, updated_at = ? where deleted_at = 0", (next_vps_host, ts), ) rewritten["vps_host"] = next_vps_host if next_public_url: conn.execute( "update routers set public_url = ?, updated_at = ? where deleted_at = 0", (next_public_url, ts), ) rewritten["public_url"] = next_public_url if rewritten: conn.commit() return rewritten def router_current_hub_bundle(router, app_public_url="", request_origin="", fallback_host=""): row = dict(router or {}) router_public_url = public_url_origin(row.get("public_url", "")) app_origin = public_url_origin(app_public_url) request_origin = public_url_origin(request_origin) public_url = prefer_origin_with_explicit_port(router_public_url, app_origin) public_url = prefer_origin_with_explicit_port(public_url, request_origin) hub_url = public_url or request_origin or router_fallback_hub_url(row, fallback_host, 8088) config_vps_host = ( vps_host_name(public_url or hub_url) or str(row.get("vps_host") or "").strip() or vps_host_name(app_origin or request_origin) or vps_host_name(router_fallback_hub_url(row, fallback_host, 8088)) or "" ) hub_update = { "hub_url": hub_url, "public_url": public_url, "vps_host": config_vps_host, } return hub_update, hub_url, config_vps_host def restore_hub_backup(archive_path, db_path=DB_PATH, vps_host="", public_url=""): ensure_state() archive_path = Path(archive_path) restored_files = [] warnings = [] with tempfile.TemporaryDirectory(prefix="owrt-hub-restore-") as tmp_name: tmp_dir = Path(tmp_name) extract_hub_backup(archive_path, tmp_dir) manifest_path = tmp_dir / "manifest.json" if not manifest_path.exists(): raise ValueError("backup manifest.json not found") manifest = json.loads(manifest_path.read_text(encoding="utf-8")) if int(manifest.get("version") or 0) > BACKUP_VERSION: raise ValueError(f"backup version {manifest.get('version')} is newer than this Hub") state_dir = tmp_dir / "state" db_src = state_dir / "hub.db" if not db_src.exists(): raise ValueError("backup has no state/hub.db") db_path = Path(db_path) if db_path.exists(): old = db_path.with_name(f"{db_path.name}.before-restore-{now_ts()}") write_private_bytes(old, db_path.read_bytes()) warnings.append(f"old DB copy saved: {old}") write_private_bytes(db_path, db_src.read_bytes()) restored_files.append(str(db_path)) for target in BACKUP_STATE_FILES: src = state_dir / Path(target).name if not src.exists(): continue write_private_bytes(target, src.read_bytes()) restored_files.append(str(target)) rewritten = {} conn = connect(db_path) try: init_db(conn) rewritten = rewrite_router_endpoints(conn, vps_host=vps_host, public_url=public_url) finally: conn.close() xray = None try: xray = reload_vps_xray(db_path) except Exception as exc: warnings.append(f"xray reload skipped: {exc}") if os.environ.get("OWRT_REMOTE_AGENT_TOKEN"): warnings.append("OWRT_REMOTE_AGENT_TOKEN is set in environment, restored agent.token file may be ignored") return { "manifest": manifest, "restored_files": restored_files, "rewritten": rewritten, "xray": xray, "warnings": warnings, "restart_required": True, } def upsert_router(conn, values): router_id = clean_router_id(values.get("id")) current = get_router(conn, router_id) ts = now_ts() def keep_str(key, default=""): value = values.get(key) if value not in (None, ""): return value if current: return current[key] return default def keep_int(key, default=0): value = values.get(key) if value not in (None, ""): return int(value) if current: return int(current[key] or default) return default reverse_tag = keep_str("reverse_tag", "reverse-in") ssh_vless_uuid = values.get("ssh_vless_uuid") or (current["ssh_vless_uuid"] if current and current["ssh_vless_uuid"] else str(uuid.uuid4())) ssh_reverse_tag = values.get("ssh_reverse_tag") or (current["ssh_reverse_tag"] if current and current["ssh_reverse_tag"] else f"{reverse_tag}-ssh") if "notes" in values: incoming_notes = values.get("notes", "") if isinstance(incoming_notes, list): notes = encode_router_notes_entries(incoming_notes) else: notes = encode_router_notes_entries(parse_router_notes_entries(incoming_notes, fallback_ts=ts)) elif current: notes = str(current["notes"] or "") else: notes = encode_router_notes_entries([]) payload = { "id": router_id, "name": values.get("name") or router_id, "role": values.get("role") or "node", "entry_port": keep_int("entry_port", 0), "vps_host": keep_str("vps_host", ""), "vless_port": keep_int("vless_port", DEFAULT_VLESS_PORT), "vless_uuid": keep_str("vless_uuid", str(uuid.uuid4())), "vless_encryption": keep_str("vless_encryption", "none"), "vless_decryption": keep_str("vless_decryption", "none"), "vless_flow": keep_str("vless_flow", ""), "reverse_tag": reverse_tag, "public_url": keep_str("public_url", ""), "admin_host": keep_str("admin_host", "127.0.0.1"), "admin_port": keep_int("admin_port", 80), "ssh_entry_port": keep_int("ssh_entry_port", int(values.get("entry_port") or 0) + 1000 if values.get("entry_port") else 0), "ssh_vless_uuid": ssh_vless_uuid, "ssh_reverse_tag": ssh_reverse_tag, "ssh_host": keep_str("ssh_host", "127.0.0.1"), "ssh_port": keep_int("ssh_port", 22), "notes": notes, "updated_at": ts, "deleted_at": 0, } payload["ssh_port"] = normalize_internal_ssh_port( payload["ssh_port"], payload["entry_port"], payload["ssh_entry_port"], ) if current: conn.execute( """ update routers set name = :name, role = :role, entry_port = :entry_port, vps_host = :vps_host, vless_port = :vless_port, vless_uuid = :vless_uuid, vless_encryption = :vless_encryption, vless_decryption = :vless_decryption, vless_flow = :vless_flow, reverse_tag = :reverse_tag, public_url = :public_url, admin_host = :admin_host, admin_port = :admin_port, ssh_entry_port = :ssh_entry_port, ssh_vless_uuid = :ssh_vless_uuid, ssh_reverse_tag = :ssh_reverse_tag, ssh_host = :ssh_host, ssh_port = :ssh_port, notes = :notes, deleted_at = :deleted_at, updated_at = :updated_at where id = :id """, payload, ) else: payload["created_at"] = ts conn.execute( """ insert into routers ( id, name, role, entry_port, vps_host, vless_port, vless_uuid, vless_encryption, vless_decryption, vless_flow, reverse_tag, public_url, admin_host, admin_port, ssh_entry_port, ssh_vless_uuid, ssh_reverse_tag, ssh_host, ssh_port, notes, created_at, updated_at, deleted_at ) values ( :id, :name, :role, :entry_port, :vps_host, :vless_port, :vless_uuid, :vless_encryption, :vless_decryption, :vless_flow, :reverse_tag, :public_url, :admin_host, :admin_port, :ssh_entry_port, :ssh_vless_uuid, :ssh_reverse_tag, :ssh_host, :ssh_port, :notes, :created_at, :updated_at, :deleted_at ) """, payload, ) conn.commit() return get_router(conn, router_id) def heartbeat(conn, payload): router_id = clean_router_id(payload.get("id")) row = get_router(conn, router_id) ts = now_ts() status_json = json.dumps(payload, ensure_ascii=False, separators=(",", ":")) was_deleted = router_deleted(row) known_before = bool(row and not was_deleted) was_online = bool(row_to_router(row).get("online")) if known_before else False old_entry_port = int(row["entry_port"] or 0) if row else 0 old_ssh_entry_port = int(row["ssh_entry_port"] or 0) if row else 0 created_with_xray_ports = False if row: entry_port = int(row["entry_port"] or 0) ssh_entry_port = int(row["ssh_entry_port"] or 0) else: entry_port = int(payload.get("entry_port") or 0) if str(payload.get("entry_port", "")).isdigit() else 0 ssh_entry_port = 0 ssh_port = normalize_internal_ssh_port(payload.get("ssh_port") or 22, entry_port, ssh_entry_port) if not row: row = upsert_router( conn, { "id": router_id, "name": payload.get("name") or router_id, "role": payload.get("role") or "node", "entry_port": payload.get("entry_port") or 0, "vps_host": payload.get("vps_host") or "", "admin_host": payload.get("admin_host") or "127.0.0.1", "admin_port": payload.get("admin_port") or 80, "ssh_host": payload.get("ssh_host") or "127.0.0.1", "ssh_port": ssh_port, }, ) created_with_xray_ports = bool(int(row["entry_port"] or 0) or int(row["ssh_entry_port"] or 0)) ssh_entry_port = int(row["ssh_entry_port"] or 0) ssh_port = normalize_internal_ssh_port(payload.get("ssh_port") or 22, int(row["entry_port"] or 0), ssh_entry_port) conn.execute( """ update routers set name = case when nullif(custom_name, '') is not null then custom_name else coalesce(nullif(?, ''), name) end, role = coalesce(nullif(?, ''), role), public_url = coalesce(nullif(?, ''), public_url), admin_host = coalesce(nullif(?, ''), admin_host), admin_port = coalesce(?, admin_port), ssh_host = coalesce(nullif(?, ''), ssh_host), ssh_port = coalesce(?, ssh_port), last_seen = ?, status_json = ?, updated_at = ?, deleted_at = 0 where id = ? """, ( payload.get("name") or "", payload.get("role") or "", payload.get("public_url") or "", payload.get("admin_host") or "", int(payload["admin_port"]) if str(payload.get("admin_port", "")).isdigit() else None, payload.get("ssh_host") or "", ssh_port, ts, status_json, ts, router_id, ), ) conn.commit() router = row_to_router(get_router(conn, router_id)) entry_now = int(router.get("entry_port") or 0) ssh_entry_now = int(router.get("ssh_entry_port") or 0) router["_xray_reload_required"] = bool( (entry_now or ssh_entry_now) and ( was_deleted or created_with_xray_ports or old_entry_port != entry_now or old_ssh_entry_port != ssh_entry_now ) ) router["_became_online"] = bool(known_before and not was_online and router.get("online")) return router def rename_router(conn, router_id, name): router_id = clean_router_id(router_id) clean_name = clean_router_name(name) row = get_router(conn, router_id) if not row: raise ValueError("router not found") conn.execute( "update routers set name = ?, custom_name = ?, updated_at = ? where id = ?", (clean_name, clean_name, now_ts(), router_id), ) conn.commit() return get_router(conn, router_id) def update_router_notes(conn, router_id, notes): router_id = clean_router_id(router_id) row = get_router(conn, router_id) if not row or router_deleted(row): raise ValueError("router not found") clean_notes = clean_router_notes(notes) stored = encode_router_notes_entries([build_router_note_entry(clean_notes, created_at=now_ts())] if clean_notes else []) conn.execute( "update routers set notes = ?, updated_at = ? where id = ?", (stored, now_ts(), router_id), ) conn.commit() return get_router(conn, router_id) def append_router_note(conn, router_id, note_text, image_uploads=None): router_id = clean_router_id(router_id) row = get_router(conn, router_id) if not row or router_deleted(row): raise ValueError("router not found") note_id = secrets.token_hex(6) saved_images = save_router_note_images(router_id, note_id, image_uploads) entry = build_router_note_entry(note_text, created_at=now_ts(), note_id=note_id, images=saved_images) if not entry: if saved_images: delete_router_note_images(router_id, note_id) raise ValueError("note is empty") try: entries = parse_router_notes_entries(row["notes"] or "", fallback_ts=row["updated_at"] or row["created_at"] or 0) entries.append(entry) entries = entries[-ROUTER_NOTES_MAX_ENTRIES:] conn.execute( "update routers set notes = ?, updated_at = ? where id = ?", (encode_router_notes_entries(entries), now_ts(), router_id), ) conn.commit() except Exception: if saved_images: delete_router_note_images(router_id, note_id) raise return get_router(conn, router_id) def update_router_note_entry(conn, router_id, note_id, note_text): router_id = clean_router_id(router_id) note_id = str(note_id or "").strip() if not note_id: raise ValueError("note id is empty") row = get_router(conn, router_id) if not row or router_deleted(row): raise ValueError("router not found") clean_text = clean_router_notes(note_text) entries = parse_router_notes_entries(row["notes"] or "", fallback_ts=row["updated_at"] or row["created_at"] or 0) updated = False for item in entries: if str(item.get("id") or "") != note_id: continue if not clean_text and not list(item.get("images") or []): raise ValueError("note is empty") item["text"] = clean_text updated = True break if not updated: raise ValueError("note not found") conn.execute( "update routers set notes = ?, updated_at = ? where id = ?", (encode_router_notes_entries(entries), now_ts(), router_id), ) conn.commit() return get_router(conn, router_id) def delete_router_note_entry(conn, router_id, note_id): router_id = clean_router_id(router_id) note_id = str(note_id or "").strip() if not note_id: raise ValueError("note id is empty") row = get_router(conn, router_id) if not row or router_deleted(row): raise ValueError("router not found") entries = parse_router_notes_entries(row["notes"] or "", fallback_ts=row["updated_at"] or row["created_at"] or 0) filtered = [item for item in entries if str(item.get("id") or "") != note_id] if len(filtered) == len(entries): raise ValueError("note not found") conn.execute( "update routers set notes = ?, updated_at = ? where id = ?", (encode_router_notes_entries(filtered), now_ts(), router_id), ) conn.commit() delete_router_note_images(router_id, note_id) return get_router(conn, router_id) def make_server_xray_config(rows, listen_host="0.0.0.0", listen_port=DEFAULT_VLESS_PORT, decryption="none"): clients = [] inbounds = [ { "tag": "owrt-remote-vless", "listen": listen_host, "port": int(listen_port), "protocol": "vless", "settings": { "clients": clients, "decryption": decryption, }, "streamSettings": { "network": "tcp", "security": "none", }, } ] rules = [] for row in rows: router_id = clean_router_id(row["id"]) entry_port = int(row["entry_port"] or 0) if entry_port <= 0: continue ssh_entry_port = int(row["ssh_entry_port"] or 0) reverse_out = f"reverse-{router_id}" ssh_reverse_out = f"{reverse_out}-ssh" portal_in = f"entry-{router_id}" client = { "id": row["vless_uuid"], "email": f"{router_id}@owrt-remote", "reverse": { "tag": reverse_out, }, } if row["vless_flow"]: client["flow"] = row["vless_flow"] clients.append(client) if ssh_entry_port > 0: ssh_client = { "id": row["ssh_vless_uuid"], "email": f"{router_id}-ssh@owrt-remote", "reverse": { "tag": ssh_reverse_out, }, } if row["vless_flow"]: ssh_client["flow"] = row["vless_flow"] clients.append(ssh_client) inbounds.append( { "tag": portal_in, "listen": "127.0.0.1", "port": entry_port, "protocol": "tunnel", "settings": { "allowedNetwork": "tcp", "rewriteAddress": row["admin_host"], "rewritePort": int(row["admin_port"]), }, } ) rules.append( { "type": "field", "inboundTag": [portal_in], "outboundTag": reverse_out, } ) if ssh_entry_port > 0: ssh_in = f"ssh-{router_id}" inbounds.append( { "tag": ssh_in, "listen": "127.0.0.1", "port": ssh_entry_port, "protocol": "tunnel", "settings": { "allowedNetwork": "tcp", "rewriteAddress": row["ssh_host"] or "127.0.0.1", "rewritePort": int(row["ssh_port"] or 22), }, } ) rules.append( { "type": "field", "inboundTag": [ssh_in], "outboundTag": ssh_reverse_out, } ) return { "log": {"loglevel": "warning"}, "inbounds": inbounds, "outbounds": [{"tag": "direct", "protocol": "freedom"}], "routing": {"rules": rules}, "remarks": "OpenWrt Remote Hub server config", } def make_router_xray_config(row): bridge_tag = row["reverse_tag"] ssh_bridge_tag = row["ssh_reverse_tag"] or f"{bridge_tag}-ssh" return { "log": {"loglevel": "warning"}, "inbounds": [], "outbounds": [ { "tag": "router-admin", "protocol": "freedom", "settings": { "redirect": f"{row['admin_host']}:{int(row['admin_port'])}", }, }, { "tag": "router-ssh", "protocol": "freedom", "settings": { "redirect": f"{row['ssh_host'] or '127.0.0.1'}:{int(row['ssh_port'] or 22)}", }, }, { "tag": "vps-interconn", "protocol": "vless", "settings": { "address": row["vps_host"], "port": int(row["vless_port"]), "id": row["vless_uuid"], "encryption": row["vless_encryption"], "flow": row["vless_flow"], "reverse": {"tag": bridge_tag}, }, "streamSettings": {"network": "tcp", "security": "none"}, }, { "tag": "vps-ssh-interconn", "protocol": "vless", "settings": { "address": row["vps_host"], "port": int(row["vless_port"]), "id": row["ssh_vless_uuid"], "encryption": row["vless_encryption"], "flow": row["vless_flow"], "reverse": {"tag": ssh_bridge_tag}, }, "streamSettings": {"network": "tcp", "security": "none"}, }, ], "routing": { "rules": [ { "type": "field", "inboundTag": [bridge_tag], "outboundTag": "router-admin", }, { "type": "field", "inboundTag": [ssh_bridge_tag], "outboundTag": "router-ssh", } ] }, "remarks": f"OpenWrt Remote client for {row['id']}", } def reload_vps_xray(db_path=DB_PATH): out = Path(os.environ.get("OWRT_REMOTE_XRAY_CONFIG", "/etc/xray/owrt-remote.json")) service = os.environ.get("OWRT_REMOTE_XRAY_SERVICE", "owrt-remote-xray") conn = connect(db_path) try: init_db(conn) rows = list_router_rows(conn) finally: conn.close() config = make_server_xray_config(rows) atomic_write_text(out, json.dumps(config, ensure_ascii=False, indent=2) + "\n", mode=0o600) try: os.chmod(out, 0o600) except OSError: pass result = subprocess.run( ["systemctl", "restart", service], text=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=20, check=False, ) if result.returncode != 0: detail = (result.stderr or result.stdout or "").strip() raise RuntimeError(f"systemctl restart {service} failed: {detail}") return {"config": str(out), "service": service, "routers": len(rows)} def restart_vps_xray(): service = os.environ.get("OWRT_REMOTE_XRAY_SERVICE", "owrt-remote-xray") result = subprocess.run( ["systemctl", "restart", service], text=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=20, check=False, ) if result.returncode != 0: detail = (result.stderr or result.stdout or "").strip() raise RuntimeError(f"systemctl restart {service} failed: {detail}") return {"service": service} def active_ssh_http_sessions(router_id=None): with SSH_HTTP_LOCK: sessions = list(SSH_HTTP_SESSIONS.values()) count = 0 for session in sessions: if is_vps_terminal_id(session.get("router_id")): continue if router_id and str(session.get("router_id") or "") != str(router_id): continue with session.get("lock", threading.Lock()): alive = bool(session.get("alive")) if alive: count += 1 return count def maybe_restart_vps_xray_after_wan_reconnect(router_id): if str(os.environ.get("OWRT_REMOTE_RESTART_XRAY_ON_WAN_RECONNECT", "1")).lower() in {"0", "no", "false", "off"}: return {"skipped": "disabled"} active_sessions = active_ssh_http_sessions(router_id) if active_sessions: return {"skipped": "active-ssh-terminal", "active_sessions": active_sessions} cooldown = int(os.environ.get("OWRT_REMOTE_WAN_RECONNECT_XRAY_COOLDOWN", "90")) now = now_ts() last = 0 try: data = json.loads(XRAY_WAN_RECONNECT_FILE.read_text(encoding="utf-8")) last = int(data.get("ts") or 0) except Exception: pass if now - last < cooldown: return {"skipped": "cooldown", "remaining": cooldown - (now - last)} result = restart_vps_xray() XRAY_WAN_RECONNECT_FILE.parent.mkdir(parents=True, exist_ok=True) atomic_write_text( XRAY_WAN_RECONNECT_FILE, json.dumps({"ts": now, "router_id": router_id, "result": result}, ensure_ascii=False) + "\n", mode=0o600, ) result["reason"] = "wan-reconnect" return result def build_openwrt_config_payload(row, hub_url, vps_host_override="", public_url_override=""): reverse_tag = row_str_value(row, "reverse_tag", "reverse-in") ssh_reverse_tag = row_str_value(row, "ssh_reverse_tag", "") or f"{reverse_tag}-ssh" ssh_host = row_str_value(row, "ssh_host", "127.0.0.1") admin_host = row_str_value(row, "admin_host", "127.0.0.1") effective_public_url = str(public_url_override or row_str_value(row, "public_url", "")).strip() effective_vps_host = str(vps_host_override or row_str_value(row, "vps_host", "")).strip() if not effective_vps_host: effective_vps_host = vps_host_name(effective_public_url) or vps_host_name(hub_url) or "127.0.0.1" payload = { "id": row_str_value(row, "id"), "name": row_str_value(row, "name"), "role": row_str_value(row, "role", "node"), "hub_url": str(hub_url or ""), "vps_host": effective_vps_host, "vps_port": row_int_value(row, "vless_port", DEFAULT_VLESS_PORT), "vless_uuid": row_str_value(row, "vless_uuid"), "vless_encryption": row_str_value(row, "vless_encryption", "none"), "vless_flow": row_str_value(row, "vless_flow", ""), "reverse_tag": reverse_tag, "ssh_vless_uuid": row_str_value(row, "ssh_vless_uuid"), "ssh_reverse_tag": ssh_reverse_tag, "admin_host": admin_host, "admin_port": row_int_value(row, "admin_port", 80), "ssh_host": ssh_host, "ssh_port": normalize_internal_ssh_port( row_int_value(row, "ssh_port", 22), row_int_value(row, "entry_port", 0), row_int_value(row, "ssh_entry_port", 0), ), "public_url": effective_public_url, } return payload def build_openwrt_config_lines(payload, mode="manual"): lines = [ "uci -q delete owrtremote.main", "uci set owrtremote.main=remote", "uci set owrtremote.main.enabled='1'", f"uci set owrtremote.main.router_id='{sh_quote(payload['id'])}'", f"uci set owrtremote.main.router_name='{sh_quote(payload['name'])}'", f"uci set owrtremote.main.role='{sh_quote(payload['role'])}'", f"uci set owrtremote.main.hub_url='{sh_quote(payload['hub_url'])}'", f"uci set owrtremote.main.hub_token='{sh_quote(agent_token())}'", "uci set owrtremote.main.heartbeat_interval='30'", "uci set owrtremote.main.xray_bin='/usr/bin/xray'", "uci set owrtremote.main.xray_config='/etc/xray/owrt-remote-client.json'", f"uci set owrtremote.main.vps_host='{sh_quote(payload['vps_host'])}'", f"uci set owrtremote.main.vps_port='{payload['vps_port']}'", f"uci set owrtremote.main.vless_uuid='{sh_quote(payload['vless_uuid'])}'", f"uci set owrtremote.main.vless_encryption='{sh_quote(payload['vless_encryption'])}'", f"uci set owrtremote.main.vless_flow='{sh_quote(payload['vless_flow'])}'", f"uci set owrtremote.main.reverse_tag='{sh_quote(payload['reverse_tag'])}'", f"uci set owrtremote.main.ssh_vless_uuid='{sh_quote(payload['ssh_vless_uuid'])}'", f"uci set owrtremote.main.ssh_reverse_tag='{sh_quote(payload['ssh_reverse_tag'])}'", f"uci set owrtremote.main.admin_host='{sh_quote(payload['admin_host'])}'", f"uci set owrtremote.main.admin_port='{payload['admin_port']}'", f"uci set owrtremote.main.ssh_host='{sh_quote(payload['ssh_host'])}'", f"uci set owrtremote.main.ssh_port='{payload['ssh_port']}'", f"uci set owrtremote.main.public_url='{sh_quote(payload['public_url'])}'", "uci commit owrtremote", "owrt-remote render-client", "/etc/init.d/owrt-remote enable", ] if mode == "ssh-apply": lines.extend( [ "owrt-remote heartbeat rebind >/dev/null 2>&1 || true", "( sleep 1; /etc/init.d/owrt-remote restart >/dev/null 2>&1 ) >/dev/null 2>&1 &", "echo 'owrt-remote rebind applied'", ] ) else: lines.extend( [ "/etc/init.d/owrt-remote restart", "owrt-remote heartbeat", ] ) return lines def make_openwrt_config(row, hub_url, vps_host_override="", public_url_override=""): payload = build_openwrt_config_payload( row, hub_url, vps_host_override=vps_host_override, public_url_override=public_url_override, ) lines = build_openwrt_config_lines(payload, mode="manual") return "\n".join(lines) + "\n" def make_openwrt_ssh_apply_script(row, hub_url, vps_host_override="", public_url_override=""): payload = build_openwrt_config_payload( row, hub_url, vps_host_override=vps_host_override, public_url_override=public_url_override, ) lines = ["set -eu"] + build_openwrt_config_lines(payload, mode="ssh-apply") return "\n".join(lines) + "\n" def sh_quote(value): return str(value).replace("'", "'\"'\"'") def parse_cookies(header): cookies = {} for chunk in (header or "").split(";"): if "=" in chunk: key, value = chunk.split("=", 1) cookies[key.strip()] = value.strip() return cookies def clean_forward_cookie(cookie_header): parts = [] for chunk in (cookie_header or "").split(";"): if not chunk.strip(): continue if ( chunk.strip().startswith("owrt_remote_admin=") or chunk.strip().startswith(f"{SESSION_COOKIE}=") or chunk.strip().startswith(f"{ROUTER_COOKIE}=") ): continue parts.append(chunk.strip()) return "; ".join(parts) def current_router_cookie(router_id): return f"{ROUTER_COOKIE}={urllib.parse.quote(router_id)}; HttpOnly; SameSite=Lax; Path=/" def is_vps_terminal_id(router_id): return router_id == VPS_TERMINAL_ID def vps_terminal_row(): return {"id": VPS_TERMINAL_ID, "name": "VPS"} def vps_terminal_commands(host): host = (host or "").strip() or "YOUR_VPS_IP" return [ { "title": "Обновить Hub", "note": "Свежий hub.py из main; обновление уходит в отдельный systemd-run", "command": f'u=owrt-remote-selfupdate-$(date +%s); systemd-run --unit=\"$u\" --collect /bin/sh -lc \'v=$(date +%s); curl -fsSL -o /opt/owrt-remote/owrt-remote-hub.py \"{RAW_REPO_BASE}/vps/owrt-remote-hub.py?v=$v\" && chmod +x /opt/owrt-remote/owrt-remote-hub.py && systemctl restart owrt-remote\' && echo \"$u started; reopen VPS terminal in 3-5 sec\"', }, { "title": "Статус Hub", "note": "Проверка сервиса owrt-remote", "command": "systemctl status owrt-remote --no-pager -l", }, { "title": "Логи Hub", "note": "Последние строки journald по Hub", "command": "journalctl -u owrt-remote -n 80 --no-pager -l", }, { "title": "Проверка портов", "note": "Слушают ли 80/443/8088/8443", "command": "ss -lntp | grep -E ':(80|443|8088|8443)'", }, { "title": "Health Hub", "note": "Локальная health-проверка Hub", "command": "curl -sS http://127.0.0.1:8088/health", }, { "title": "Включить HTTPS", "note": "Обновить https-конфиг из репо для текущего host", "command": f'curl -fsSL "{RAW_REPO_BASE}/vps/enable-https.sh?v=$(date +%s)" | sh -s -- {host}', }, { "title": "Установить VPS заново", "note": "install-vps.sh из репо", "command": f'curl -fsSL "{RAW_REPO_BASE}/vps/install-vps.sh?v=$(date +%s)" | sh', }, ] def vps_quick_commands_html(host): cards = [] for item in vps_terminal_commands(host): title = html.escape(item["title"]) note = html.escape(item["note"]) command = item["command"] safe_cmd = html.escape(command, quote=True) preview = html.escape(command) cards.append( f"""
{title} {note}
{preview}
""".strip() ) joined = "\n".join(cards) return f"""

Быстрые команды

Команды взяты из репозитория luci-app-owrt-remote. Можно копировать или сразу отправлять в VPS terminal.

{joined}
""".strip() def ssh_ws_token(secret, router_id): return hmac.new( secret.encode("utf-8"), f"ssh:{router_id}".encode("utf-8"), hashlib.sha256, ).hexdigest() def strip_access_prefix(path, router_id): prefix = f"/access/{urllib.parse.quote(router_id)}" if path == prefix: return "/" if path.startswith(prefix + "/"): return path[len(prefix):] or "/" return path or "/" def rewrite_forward_url(value, router_id, port): if not value: return value parsed = urllib.parse.urlsplit(value) path = strip_access_prefix(parsed.path, router_id) return urllib.parse.urlunsplit(("http", f"127.0.0.1:{port}", path, parsed.query, parsed.fragment)) def ws_accept_value(key): raw = hashlib.sha1((key + WS_GUID).encode("ascii")).digest() return base64.b64encode(raw).decode("ascii") def recv_exact(sock, size): chunks = [] left = size while left > 0: chunk = sock.recv(left) if not chunk: raise ConnectionError("websocket closed") chunks.append(chunk) left -= len(chunk) return b"".join(chunks) def ws_read_frame(sock): head = recv_exact(sock, 2) first, second = head[0], head[1] opcode = first & 0x0F masked = bool(second & 0x80) length = second & 0x7F if length == 126: length = struct.unpack("!H", recv_exact(sock, 2))[0] elif length == 127: length = struct.unpack("!Q", recv_exact(sock, 8))[0] mask = recv_exact(sock, 4) if masked else b"" payload = recv_exact(sock, length) if length else b"" if masked and payload: payload = bytes(b ^ mask[i % 4] for i, b in enumerate(payload)) return opcode, payload def ws_send_frame(sock, payload, opcode=1): if isinstance(payload, str): payload = payload.encode("utf-8", errors="replace") length = len(payload) if length < 126: head = struct.pack("!BB", 0x80 | opcode, length) elif length < 65536: head = struct.pack("!BBH", 0x80 | opcode, 126, length) else: head = struct.pack("!BBQ", 0x80 | opcode, 127, length) sock.sendall(head + payload) def set_pty_size(fd, rows, cols): try: rows = max(8, min(80, int(rows or 24))) cols = max(20, min(260, int(cols or 80))) except Exception: return False try: import fcntl import termios fcntl.ioctl(fd, termios.TIOCSWINSZ, struct.pack("HHHH", rows, cols, 0, 0)) return True except Exception: return False def write_pty_all(fd, data, timeout=10.0, chunk_size=1024): if isinstance(data, str): data = data.encode("utf-8", errors="replace") view = memoryview(data or b"") total = 0 deadline = time.monotonic() + timeout while total < len(view): remaining = deadline - time.monotonic() if remaining <= 0: raise TimeoutError("terminal input write timed out") _, writable, _ = select.select([], [fd], [], min(1.0, remaining)) if fd not in writable: continue written = os.write(fd, view[total : total + chunk_size]) if written <= 0: raise OSError("terminal input write returned 0 bytes") total += written return total def parse_resize_payload(payload): try: message = json.loads(payload.decode("utf-8", errors="ignore")) except Exception: return None if not isinstance(message, dict) or message.get("type") != "resize": return None return message.get("rows"), message.get("cols") def dashboard_html(routers, username, sessions=None, notifications=None, auth_bootstrap=None): routers_json = json.dumps(routers, ensure_ascii=False) sessions_json = json.dumps(sessions or [], ensure_ascii=False) notifications_json = json.dumps(notifications or [], ensure_ascii=False) auth_bootstrap_json = json.dumps(auth_bootstrap or {}, ensure_ascii=False) push_bootstrap = web_push_backend_status() push_bootstrap_json = json.dumps( { "ready": bool(push_bootstrap.get("ready", False)), "publicKey": str(push_bootstrap.get("public_key", "") or ""), "subject": str(push_bootstrap.get("subject", "") or ""), }, ensure_ascii=False, ) is_owner = bool((auth_bootstrap or {}).get("is_owner")) safe_username = html.escape(username, quote=True) return f""" {branding_head_tags()} {APP_NAME}

OpenWrt Remote Hub v106

Терминал VPS Выйти
v106
""" def ssh_terminal_html(row, ws_token): router_id = row["id"] safe_id = html.escape(router_id, quote=True) safe_name = html.escape(row["name"] or router_id, quote=True) ssh_port = int(row["ssh_entry_port"] or 0) quoted_id = urllib.parse.quote(router_id) ws_path = f"/ssh-ws/{quoted_id}?t={urllib.parse.quote(ws_token)}" check_path = f"/api/ssh/{quoted_id}/check?t={urllib.parse.quote(ws_token)}" session_path = f"/api/ssh/{quoted_id}/session?t={urllib.parse.quote(ws_token)}" return f""" {branding_head_tags(include_manifest=False)} SSH {safe_name}

SSH · {safe_name}

Назад в Hub
__QUICK_COMMANDS_HTML__
Terminal

    
    
""" def router_notes_html(router, username="", saved="", error="", draft=None, edit_note_id=""): router = dict(router or {}) router_id = str(router.get("id") or "").strip() router_name = str(router.get("name") or router_id or "router").strip() permissions = router.get("permissions") if isinstance(router.get("permissions"), dict) else {} can_edit = bool(permissions.get("notes_edit") or permissions.get("manage")) can_delete = bool(permissions.get("notes_delete") or permissions.get("owner")) note_entries = list(router.get("notes_entries") or []) visible_entries = list(reversed(note_entries)) has_note_images = any(bool(item.get("images")) for item in visible_entries) edit_note_id = str(edit_note_id or "").strip() if not can_edit: edit_note_id = "" notes_value = clean_router_notes(draft if draft is not None else "") safe_router_name = html.escape(router_name) safe_notes = html.escape(notes_value) safe_notes_url = html.escape(str(router.get("notes_url") or f"/router/{urllib.parse.quote(router_id)}/notes"), quote=True) note_len = len(notes_value) notes_total = len(note_entries) message_html = "" saved = str(saved or "").strip().lower() def render_note_images_html(images): tiles = [] for image in list(images or []): image_url = html.escape(str(image.get("url") or ""), quote=True) if not image_url: continue image_name = html.escape(str(image.get("name") or "Изображение")) tiles.append( f""" {image_name} {image_name} """ ) return f'
{"".join(tiles)}
' if tiles else "" if error: message_html = f'
{html.escape(str(error))}
' elif saved == "added": message_html = '
Заметка опубликована.
' elif saved == "updated": message_html = '
Заметка обновлена.
' elif saved == "deleted": message_html = '
Заметка удалена.
' read_only_css = "" view_only_notice_html = "" if not can_edit: read_only_css = ".notesLayout{grid-template-columns:1fr}.editor{display:none}.cardActions{display:none!important}" view_only_notice_html = '
Доступ к заметкам открыт только для просмотра.
' notes_layout_class = "notesLayout notesLayoutMedia" if has_note_images else "notesLayout" notes_items = [] for item in visible_entries: note_id = str(item.get("id") or "") safe_note_id = html.escape(note_id, quote=True) safe_edit_link = html.escape(f"{router.get('notes_url') or f'/router/{urllib.parse.quote(router_id)}/notes'}?edit={urllib.parse.quote(note_id)}", quote=True) note_time_iso = html.escape(str(item.get("created_at_iso") or ""), quote=True) note_time_label = html.escape(str(item.get("created_at_label") or "Дата публикации неизвестна")) note_text_html = "" if str(item.get("text") or "").strip(): note_text_html = f'
{html.escape(str(item.get("text") or "")).replace(chr(10), "
")}
' note_images_html = render_note_images_html(item.get("images") or []) if can_edit and note_id == edit_note_id: edit_text = clean_router_notes(draft if draft is not None else item.get("text") or "") safe_edit_text = html.escape(edit_text) edit_count = len(edit_text) note_body_html = f"""

Редактирование

{edit_count} / {ROUTER_NOTE_TEXT_MAX_CHARS}
{note_images_html}
Отмена
""" else: note_action_parts = [] if can_edit: note_action_parts.append(f'Редактировать') if can_delete: note_action_parts.append( f"""
""" ) note_actions_html = "" if note_action_parts: note_actions_html = f"""
{''.join(note_action_parts)}
""" note_body_html = f""" {note_text_html} {note_images_html} {note_actions_html}""" notes_items.append( f"""
Публикация
{note_body_html}
""" ) notes_items_html = "".join(notes_items) if not notes_items_html: notes_items_html = '
Пока нет опубликованных заметок. Первая запись появится здесь сразу после сохранения.
' return f""" Заметки роутер {safe_router_name}

Заметки роутер {safe_router_name}

{message_html}

Новая заметка

{note_len} / {ROUTER_NOTE_TEXT_MAX_CHARS}
Можно выбрать до {ROUTER_NOTE_IMAGE_MAX_FILES} изображений.

История заметок

Всего публикаций: {notes_total}
{view_only_notice_html}
{notes_items_html}
""" def ssh_terminal_html_v2(row, ws_token, quick_commands_html=""): router_id = row["id"] safe_name = html.escape(row["name"] or router_id, quote=True) quoted_id = urllib.parse.quote(router_id) ws_path = f"/ssh-ws/{quoted_id}?t={urllib.parse.quote(ws_token)}" check_path = f"/api/ssh/{quoted_id}/check?t={urllib.parse.quote(ws_token)}" session_path = f"/api/ssh/{quoted_id}/session?t={urllib.parse.quote(ws_token)}" is_vps_terminal = is_vps_terminal_id(router_id) title_prefix = "VPS" if is_vps_terminal else "SSH" page_title = "VPS terminal" if is_vps_terminal else f"{title_prefix} {row['name'] or router_id}" header_title = f"{title_prefix} · {row['name'] or router_id}" connect_label = "VPS terminal" if is_vps_terminal else "SSH" closed_label = "VPS terminal закрыт" if is_vps_terminal else "SSH соединение закрыто" silent_label = "VPS terminal молчит больше 3 секунд" if is_vps_terminal else "SSH молчит больше 3 секунд" ready_label = "VPS terminal запущен. Это root shell самого VPS. Команды ниже можно копировать или сразу отправлять в терминал." if is_vps_terminal else "" force_http_only = str(os.environ.get("OWRT_REMOTE_TERMINAL_WS", "")).lower() not in {"1", "yes", "true", "on"} if is_vps_terminal: header_title = "VPS terminal" page = r""" {branding_head_tags(include_manifest=False)} SSH __SAFE_NAME__

SSH · __SAFE_NAME__

Назад в Hub
__QUICK_COMMANDS_HTML__
Terminal
Загрузка терминала...
""" return ( page.replace("__SAFE_NAME__", safe_name) .replace("{branding_head_tags(include_manifest=False)}", branding_head_tags(include_manifest=False)) .replace("__WS_PATH_JSON__", json.dumps(ws_path)) .replace("__CHECK_PATH_JSON__", json.dumps(check_path)) .replace("__SESSION_PATH_JSON__", json.dumps(session_path)) .replace("__ROUTER_ID_JSON__", json.dumps(router_id)) .replace("__IS_VPS_TERMINAL_JSON__", json.dumps(is_vps_terminal)) .replace("__FORCE_HTTP_ONLY_JSON__", json.dumps(force_http_only)) .replace("__CONNECT_LABEL_JSON__", json.dumps(connect_label)) .replace("__CLOSED_LABEL_JSON__", json.dumps(closed_label)) .replace("__SILENT_LABEL_JSON__", json.dumps(silent_label)) .replace("__READY_LABEL_JSON__", json.dumps(ready_label)) .replace("__QUICK_COMMANDS_HTML__", quick_commands_html) .replace(f"SSH {safe_name}", f"{html.escape(page_title)}") .replace(f"

SSH · {safe_name}

", f"

{html.escape(header_title)}

") ) def _legacy_login_html(error=""): error_html = f"
{html.escape(error)}
" if error else "" auth = normalize_auth_state(load_auth()) captcha_html = legacy_login_captcha_html(auth) recaptcha_script = login_recaptcha_script(auth) return f""" {branding_head_tags()} OpenWrt Remote Hub {recaptcha_script}
AUTH FLOW

Схема доступа

Основной вход можно увести в Passkey или ED25519, а пароль оставить как резервную ветку с 2FA.

WEB-панель
↓
Авторизация
Passkey: off Passkey Android, iPhone, Windows Hello, Face ID, Touch ID и системные ключи.
ED25519: off ED25519 Вход по SSH challenge и ASCII signature без отправки приватного ключа.
Password: reserve Резерв Пароль остается запасным методом и усиливается TOTP-кодом, когда 2FA включена.
↓
Secure session
PASSKEY

Вход по Passkey

Android, iPhone, Windows Hello, Touch ID и другие системные ключи могут входить без пароля.

Сначала зарегистрируй passkey в меню доступа внутри панели.
ED25519

Вход по SSH ED25519

Мануал как создать Ssh key
""" def login_html(error=""): error_html = f"
{html.escape(error)}
" if error else "" auth = normalize_auth_state(load_auth()) initial_login_meta_json = json.dumps(public_auth_meta(auth), ensure_ascii=False).replace(" {branding_head_tags()} OpenWrt Remote Hub

Вход в систему

Авторизуйся для доступа к панели и защищённым сценариям управления.

{error_html}
Безопасное соединение. Данные и альтернативные методы авторизации защищены.
""" def ssh_key_manual_html(): return """ Мануал: SSH key для Hub

Мануал: как создать SSH key для Hub

Открыть логин Hub

PowerShell команды выполняются на вашем ПК с Windows, не на VPS. В Hub вы вставляете публичный ключ, потом challenge и затем подпись.

Важно: файл id_ed25519_hub это приватный ключ, его никому не показывать. В Hub вставляется только файл .pub.

1. Открой PowerShell на Windows

Нажмите Пуск, введите PowerShell и откройте Windows PowerShell.

2. Создай SSH-ключ на своем ПК

Выполни команду ниже. Потом можно просто два раза нажать Enter, если не хочешь ставить passphrase на ключ.

PowerShell
ssh-keygen -t ed25519 -a 100 -f $env:USERPROFILE\\.ssh\\id_ed25519_hub -C "hub-login"

После этого появятся файлы C:\\Users\\ВАШЕ_ИМЯ\\.ssh\\id_ed25519_hub и C:\\Users\\ВАШЕ_ИМЯ\\.ssh\\id_ed25519_hub.pub.

3. Покажи публичный ключ и скопируй его целиком

Нужна вся строка вида ssh-ed25519 AAAA... hub-login.

PowerShell
Get-Content $env:USERPROFILE\\.ssh\\id_ed25519_hub.pub

4. Добавь публичный ключ в Hub

Открой Hub, зайди в Доступ к Hub, блок SSH ED25519. Введи текущий пароль от Hub, укажи метку, например Windows-PC, вставь строку из файла .pub и нажми Добавить SSH ED25519.

5. Получи challenge на экране логина Hub

Нажми Получить challenge, скопируй текст и сохрани его в файл на Windows ПК. Проще всего открыть Блокнот этой командой:

PowerShell
notepad $env:TEMP\\hub-challenge.txt

Вставь туда challenge из Hub, сохрани файл и закрой Блокнот.

6. Подпиши challenge приватным ключом

Подписывать нужно файлом без .pub, то есть именно приватным ключом id_ed25519_hub.

PowerShell
ssh-keygen -Y sign -f $env:USERPROFILE\\.ssh\\id_ed25519_hub -n owrt-remote-hub $env:TEMP\\hub-challenge.txt

После этого рядом появится файл C:\\Users\\ВАШЕ_ИМЯ\\AppData\\Local\\Temp\\hub-challenge.txt.sig.

7. Покажи подпись и скопируй весь блок

Нужен весь текст от -----BEGIN SSH SIGNATURE----- до -----END SSH SIGNATURE-----.

PowerShell
Get-Content $env:TEMP\\hub-challenge.txt.sig

8. Вставь подпись обратно в Hub

Вернись на экран логина, вставь весь блок подписи в поле SSH signature и нажми Проверить подпись. Если все ок, Hub впустит без пароля.

Если команда ssh-keygen не работает

Проверь, установлен ли OpenSSH Client в Windows.

PowerShell
ssh -V
""" _base_login_html = login_html def login_html(error="", force_local_captcha=False): auth = normalize_auth_state(load_auth()) page = _base_login_html(error) if force_local_captcha: page, _ = re.subn( r'()', r'\1', page, count=1, ) return page state = effective_captcha_state(auth) if state.get("effective_mode") != CAPTCHA_MODE_RECAPTCHA: return page replacement = modern_login_captcha_html(auth) page, count = re.subn( r'
.*?', replacement, page, count=1, flags=re.S, ) if count and ".captchaSectionRecaptcha" not in page: page = page.replace( ".captchaRefresh:active{transform:translateY(1px)}", ".captchaRefresh:active{transform:translateY(1px)}" ".captchaSectionRecaptcha{gap:12px}" ".captchaHint{color:var(--muted);font-size:12px;line-height:1.45}" ".recaptchaBox{display:flex;justify-content:center;overflow-x:auto;padding:4px 0}", 1, ) script = login_recaptcha_script(auth) if script and script not in page: page = page.replace("", f"{script}\n", 1) return page class App: def __init__(self, db_path, session, agent, public_url): self.db_path = Path(db_path) self.session_token = session self.agent_token = agent self.public_url = public_url.rstrip("/") self.router_state_lock = threading.Lock() self.router_state_snapshot = {} self.router_monitor_stop = threading.Event() self.router_monitor_thread = None def conn(self): conn = connect(self.db_path) init_db(conn) return conn def snapshot_router_states(self): with self.conn() as conn: routers = [row_to_router(row) for row in list_router_rows(conn)] return { str(router.get("id") or ""): { "online": bool(router.get("online")), "router": router, } for router in routers if str(router.get("id") or "").strip() } def prime_router_state_snapshot(self): snapshot = self.snapshot_router_states() with self.router_state_lock: self.router_state_snapshot = snapshot def check_router_state_changes(self): current = self.snapshot_router_states() with self.router_state_lock: previous = dict(self.router_state_snapshot) self.router_state_snapshot = current for router_id, old in previous.items(): new = current.get(router_id) if not new: continue if bool(old.get("online")) and not bool(new.get("online")): notify_router_offline(new.get("router") or {}) def router_state_monitor_loop(self): interval = max(3, int(os.environ.get("OWRT_REMOTE_ROUTER_NOTIFY_POLL", "5"))) self.prime_router_state_snapshot() while not self.router_monitor_stop.wait(interval): try: self.check_router_state_changes() except Exception as exc: print(f"WARNING: router state monitor error: {exc}", file=sys.stderr) def start_router_state_monitor(self): if self.router_monitor_thread and self.router_monitor_thread.is_alive(): return self.router_monitor_stop.clear() self.router_monitor_thread = threading.Thread(target=self.router_state_monitor_loop, daemon=True) self.router_monitor_thread.start() def stop_router_state_monitor(self): self.router_monitor_stop.set() class Handler(BaseHTTPRequestHandler): server_version = "owrt-remote-hub/1.0" protocol_version = "HTTP/1.1" @property def app(self): return self.server.app def log_message(self, fmt, *args): sys.stderr.write("%s - - [%s] %s\n" % (self.address_string(), self.log_date_time_string(), fmt % args)) def parsed(self): return urllib.parse.urlsplit(self.path) def query(self): return urllib.parse.parse_qs(self.parsed().query) def maybe_proxy_luci_absolute(self, path): if not any(path == root or path.startswith(root + "/") for root in LUCI_ABSOLUTE_ROOTS): return False router_id = "" ref_path = urllib.parse.urlsplit(self.headers.get("Referer", "")).path parts = ref_path.split("/", 3) if len(parts) >= 3 and parts[1] == "access" and parts[2]: router_id = parts[2] if not router_id: router_id = urllib.parse.unquote(parse_cookies(self.headers.get("Cookie", "")).get(ROUTER_COOKIE, "")) if router_id: self.proxy_access(f"/access/{router_id}{path}") return True return False def client_ip(self): forwarded = self.headers.get("X-Forwarded-For", "") if forwarded: return forwarded.split(",", 1)[0].strip() try: return self.client_address[0] except Exception: return "" def current_session_token(self): return parse_cookies(self.headers.get("Cookie", "")).get(SESSION_COOKIE, "") def current_hub_session(self, touch=True): return verify_hub_session( self.current_session_token(), touch=touch, ip=self.client_ip() if touch else "", user_agent=self.headers.get("User-Agent", "") if touch else "", ) def legacy_admin_ok(self): return secrets.compare_digest(self.current_session_token(), self.app.session_token) def admin_ok(self): return bool(self.current_hub_session()) or self.legacy_admin_ok() def current_account_profile(self, touch=True): auth = normalize_auth_state(load_auth()) if self.legacy_admin_ok(): return account_profile(auth, auth.get("username", "admin")) session = self.current_hub_session(touch=touch) if not session: return None return account_profile(auth, session.get("username", "")) def owner_ok(self): profile = self.current_account_profile(touch=False) return bool(profile and profile.get("is_owner")) def can_add_router(self): profile = self.current_account_profile(touch=False) return bool(profile and account_can_add_router(profile)) def require_owner(self, json_mode=False): if self.owner_ok(): return True if not self.admin_ok(): if json_mode: self.send_json(401, {"ok": False, "error": "not authorized"}) else: self.send_bytes(401, login_html().encode("utf-8"), "text/html; charset=utf-8") return False if json_mode: self.send_json(403, {"ok": False, "error": "Недостаточно прав"}) else: self.send_text(403, "Недостаточно прав") return False def require_add_router(self, json_mode=False): if self.can_add_router(): return True if not self.admin_ok(): if json_mode: self.send_json(401, {"ok": False, "error": "not authorized"}) else: self.send_bytes(401, login_html().encode("utf-8"), "text/html; charset=utf-8") return False if json_mode: self.send_json(403, {"ok": False, "error": "Недостаточно прав для добавления роутера"}) else: self.send_text(403, "Недостаточно прав для добавления роутера") return False def router_access_allowed(self, router_id, flag): profile = self.current_account_profile() return bool(profile and account_has_router_flag(profile, router_id, flag)) def require_router_access(self, router_id, flag, json_mode=False): if self.router_access_allowed(router_id, flag): return True if not self.admin_ok(): if json_mode: self.send_json(401, {"ok": False, "error": "not authorized"}) else: self.send_bytes(401, login_html().encode("utf-8"), "text/html; charset=utf-8") return False if json_mode: self.send_json(403, {"ok": False, "error": "Недостаточно прав для этого роутера"}) else: self.send_text(403, "Недостаточно прав для этого роутера") return False def current_or_owner_session_scope(self): profile = self.current_account_profile(touch=False) if not profile or profile.get("is_owner"): return "" return str(profile.get("username") or "") def visible_routers(self, conn, account=None): profile = account or self.current_account_profile() routers = [row_to_router(r) for r in list_router_rows(conn)] if profile and not profile.get("is_owner"): allowed = set(profile.get("router_ids") or []) routers = [router for router in routers if str(router.get("id") or "") in allowed] return [router_with_access(router, profile) for router in routers] def ssh_token_ok(self, router_id): token = self.query().get("t", [""])[0] if not token: return False return secrets.compare_digest(token, ssh_ws_token(self.app.session_token, router_id)) def agent_ok(self): auth = self.headers.get("Authorization", "") if auth.startswith("Bearer "): return secrets.compare_digest(auth[7:].strip(), self.app.agent_token) return False def send_bytes(self, status, body, content_type="text/plain; charset=utf-8", extra_headers=None): self.close_connection = True self.send_response(status) self.send_header("Content-Type", content_type) self.send_header("Cache-Control", "no-store") self.send_header("Connection", "close") if extra_headers: for key, value in extra_headers: if key.lower() in {"connection", "content-length", "content-type", "cache-control"}: continue self.send_header(key, value) self.send_header("Content-Length", str(len(body))) self.end_headers() if self.command != "HEAD": try: self.wfile.write(body) self.wfile.flush() except (BrokenPipeError, ConnectionResetError, ssl.SSLError): pass def send_raw_bytes(self, status, body, content_type="application/octet-stream", extra_headers=None): self.close_connection = True reason = self.responses.get(status, ("OK",))[0] headers = [ f"{self.protocol_version} {status} {reason}", f"Server: {self.version_string()}", f"Date: {self.date_time_string()}", f"Content-Type: {content_type}", "Cache-Control: no-store", "Connection: close", f"Content-Length: {len(body)}", ] if extra_headers: for key, value in extra_headers: low = key.lower() if low in {"connection", "content-length", "content-type", "cache-control"}: continue safe_key = str(key).replace("\r", "").replace("\n", "") safe_value = str(value).replace("\r", "").replace("\n", "") headers.append(f"{safe_key}: {safe_value}") raw = ("\r\n".join(headers) + "\r\n\r\n").encode("iso-8859-1", "replace") if self.command != "HEAD": raw += body try: self.request.sendall(raw) self.log_request(status, len(body)) except (BrokenPipeError, ConnectionResetError, ssl.SSLError): pass def send_text(self, status, text, content_type="text/plain; charset=utf-8"): self.send_bytes(status, text.encode("utf-8"), content_type) def send_local_asset(self, file_path, content_type): try: body = Path(file_path).read_bytes() except FileNotFoundError: self.send_text(404, "asset not found") return self.send_bytes(200, body, content_type) def send_json(self, status, payload): body = json.dumps(payload, ensure_ascii=False, separators=(",", ":")).encode("utf-8") self.send_bytes(status, body, "application/json; charset=utf-8") def require_admin(self): if self.admin_ok(): return True self.send_bytes(401, login_html().encode("utf-8"), "text/html; charset=utf-8") return False def read_body(self): if self.headers.get("Transfer-Encoding", "").lower() == "chunked": chunks = [] while True: line = self.rfile.readline().strip() if not line: continue size = int(line.split(b";", 1)[0], 16) if size == 0: while self.rfile.readline().strip(): pass break chunks.append(self.rfile.read(size)) self.rfile.read(2) return b"".join(chunks) length = int(self.headers.get("Content-Length", "0") or "0") return self.rfile.read(length) if length else b"" def read_payload(self): body = self.read_body() ctype = self.headers.get("Content-Type", "") if "application/json" in ctype: return json.loads(body.decode("utf-8") or "{}") if "multipart/form-data" in ctype.lower(): message = BytesParser(policy=email_policy_default).parsebytes( b"Content-Type: " + ctype.encode("utf-8", errors="replace") + b"\r\nMIME-Version: 1.0\r\n\r\n" + body ) payload = {"__files__": {}} if not message.is_multipart(): return payload for part in message.iter_parts(): if part.get_content_disposition() != "form-data": continue name = str(part.get_param("name", header="content-disposition") or "").strip() if not name: continue filename = part.get_filename() raw = part.get_payload(decode=True) or b"" if filename is not None: payload["__files__"].setdefault(name, []).append( { "filename": filename, "content_type": part.get_content_type() or "", "body": raw, } ) continue payload[name] = raw.decode(part.get_content_charset() or "utf-8", errors="replace") return payload parsed = urllib.parse.parse_qs(body.decode("utf-8")) return {k: v[-1] for k, v in parsed.items()} def session_cookie(self, token): secure = "; Secure" if self.request_scheme() == "https" else "" return f"{SESSION_COOKIE}={token}; HttpOnly; SameSite=Lax; Path=/; Max-Age={SESSION_TTL_SECONDS}{secure}" def clear_session_cookie(self): secure = "; Secure" if self.request_scheme() == "https" else "" return f"{SESSION_COOKIE}=; HttpOnly; SameSite=Lax; Path=/; Max-Age=0{secure}" def request_scheme(self): forwarded = str(self.headers.get("X-Forwarded-Proto", "")).split(",", 1)[0].strip().lower() if forwarded in {"http", "https"}: return forwarded return "https" if isinstance(self.request, ssl.SSLSocket) else "http" def request_host(self): scheme = self.request_scheme() host = str(self.headers.get("X-Forwarded-Host") or self.headers.get("Host") or "").split(",", 1)[0].strip() forwarded_port = self.headers.get("X-Forwarded-Port", "") return append_forwarded_port(scheme, host, forwarded_port) def request_origin(self): return origin_from_parts(self.request_scheme(), self.request_host()) def request_host_name(self): try: return urllib.parse.urlsplit(self.request_origin()).hostname or "" except Exception: return "" def webauthn_rp_id(self): return public_url_rp_id(self.app.public_url) or self.request_host_name() def webauthn_allowed_origins(self): values = [] for item in (public_url_origin(self.app.public_url), self.request_origin()): if item and item not in values: values.append(item) return values def build_webauthn_server(self): if not passkey_supported(): raise ValueError("На сервере не установлен модуль Passkey/WebAuthn") rp_id = self.webauthn_rp_id() origins = set(self.webauthn_allowed_origins()) if not rp_id or not origins: raise ValueError("Не удалось определить origin/RP ID для Passkey") def verify_origin(origin): try: parts = urllib.parse.urlsplit(str(origin or "")) return origin_from_parts(parts.scheme, parts.netloc) in origins except Exception: return False return Fido2Server({"id": rp_id, "name": APP_NAME}, verify_origin=verify_origin) def require_current_password(self, payload, auth=None): auth = normalize_auth_state(auth or load_auth()) current_password = str((payload or {}).get("current_password") or "") if not verify_login(auth.get("username", ""), current_password): raise ValueError("Текущий пароль неверный") return auth def verify_login_captcha(self, payload, auth=None): auth = normalize_auth_state(auth or load_auth()) override_mode = sanitize_captcha_mode((payload or {}).get("captcha_mode_override")) if override_mode == CAPTCHA_MODE_DIGITS: captcha_token = (payload or {}).get("captcha_token", "") captcha_answer = (payload or {}).get("captcha_answer", "") if verify_captcha(captcha_token, captcha_answer): return True, "" return False, "Неверная локальная капча" state = effective_captcha_state(auth) if state.get("effective_mode") == CAPTCHA_MODE_RECAPTCHA: token = ( (payload or {}).get("g-recaptcha-response") or (payload or {}).get("recaptcha_token") or "" ) return verify_recaptcha_token( state.get("secret_key", ""), token, remote_ip=self.client_ip(), expected_hostname=self.request_host_name(), ) captcha_token = (payload or {}).get("captcha_token", "") captcha_answer = (payload or {}).get("captcha_answer", "") if verify_captcha(captcha_token, captcha_answer): return True, "" return False, "Неверная капча" def create_login_session(self, username="", auth_method="password"): session_username = str(username or current_username()).strip() token, session = make_hub_session( session_username, self.client_ip(), self.headers.get("User-Agent", ""), auth_method=auth_method, ) add_notification( "login", "Вход в Hub", f"{session.get('client', 'устройство')} · {auth_method_label(auth_method)} · IP {session.get('ip', 'unknown')}", "warn", [session.get("user_agent", "")], { "session_id": session.get("id", ""), "username": session_username, "ip": session.get("ip", ""), "client": session.get("client", ""), "user_agent": session.get("user_agent", ""), "auth_method": auth_method, }, ) return token, session def send_login_json(self, username="", auth_method="password"): token, _ = self.create_login_session(username, auth_method) body = { "ok": True, "redirect": "/", "auth_method": auth_method, "username": username or current_username(), } self.send_bytes( 200, json.dumps(body, ensure_ascii=False, separators=(",", ":")).encode("utf-8"), "application/json; charset=utf-8", [("Set-Cookie", self.session_cookie(token))], ) def social_callback_url(self, provider): provider = str(provider or "").strip().lower() base = public_url_origin(self.app.public_url) or self.request_origin() if not base: raise ValueError("Не удалось определить внешний URL Hub для OAuth callback") return f"{base}/oauth/{provider}/callback" def social_provider_config(self, provider, auth=None): provider = str(provider or "").strip().lower() if provider not in SOCIAL_PROVIDERS: raise ValueError("Неизвестный OAuth provider") auth = normalize_auth_state(auth or load_auth()) return sanitize_social_provider_state(provider, auth.get("social", {}).get(provider)) def social_flow_authorize_url(self, provider, state, redirect_uri, flow=None): provider = str(provider or "").strip().lower() cfg = self.social_provider_config(provider) if not social_provider_configured(provider, cfg): raise ValueError(social_provider_setup_message(provider)) flow = dict(flow or {}) if provider == "github": query = { "client_id": cfg["client_id"], "redirect_uri": redirect_uri, "scope": "read:user user:email", "state": state, "allow_signup": "false", } elif provider == "vk": code_verifier = str(flow.get("code_verifier") or "").strip() if not code_verifier: raise ValueError("VK ID flow не подготовлен") query = { "client_id": cfg["client_id"], "redirect_uri": redirect_uri, "response_type": "code", "scope": "email vkid.personal_info", "state": state, "code_challenge": make_pkce_challenge(code_verifier), "code_challenge_method": "S256", } else: raise ValueError("Неизвестный OAuth provider") return f"{SOCIAL_PROVIDERS[provider]['authorize_url']}?{urllib.parse.urlencode(query)}" def oauth_popup_html(self, title, message, provider="", ok=False): tone = "ok" if ok else "bad" provider = str(provider or "").strip().lower() payload = json.dumps({"type": "owrt-social-linked", "provider": provider, "ok": bool(ok)}, ensure_ascii=False) safe_title = html.escape(title or APP_NAME) safe_message = html.escape(message or "") return f""" {branding_head_tags(include_manifest=False)} {safe_title}
{'Готово' if ok else 'Ошибка'}

{safe_title}

{safe_message}

{'Вернуться в Hub' if ok else 'Открыть вход в Hub'}
""" def social_login_error_page(self, message): safe_message = html.escape(message or "Не удалось завершить OAuth вход") return f""" {branding_head_tags(include_manifest=False)} OAuth ошибка

OAuth вход не завершен

{safe_message}

Вернуться на страницу входа
""" def exchange_social_code(self, provider, code, redirect_uri, flow=None, flow_state="", device_id=""): provider = str(provider or "").strip().lower() cfg = self.social_provider_config(provider) flow = dict(flow or {}) if provider == "github": token = oauth_fetch_json( SOCIAL_PROVIDERS[provider]["token_url"], method="POST", headers={ "Accept": "application/json", "Content-Type": "application/x-www-form-urlencoded", }, data={ "client_id": cfg["client_id"], "client_secret": cfg["client_secret"], "code": code, "redirect_uri": redirect_uri, }, ) access_token = str(token.get("access_token") or "").strip() if not access_token: raise ValueError(token.get("error_description") or token.get("error") or "GitHub не вернул access token") profile = oauth_fetch_json( "https://api.github.com/user", headers={ "Accept": "application/vnd.github+json", "Authorization": f"Bearer {access_token}", }, ) emails = oauth_fetch_json( "https://api.github.com/user/emails", headers={ "Accept": "application/vnd.github+json", "Authorization": f"Bearer {access_token}", }, ) primary_email = "" if isinstance(emails, list): for row in emails: if row.get("primary"): primary_email = str(row.get("email") or "").strip() break if not primary_email and emails: primary_email = str(emails[0].get("email") or "").strip() account_id = str(profile.get("id") or "").strip() if not account_id: raise ValueError("GitHub не вернул ID пользователя") return { "id": account_id, "label": str(profile.get("name") or profile.get("login") or primary_email or account_id), "login": str(profile.get("login") or "").strip(), "name": str(profile.get("name") or "").strip(), "email": primary_email, "profile_url": str(profile.get("html_url") or "").strip(), "avatar_url": str(profile.get("avatar_url") or "").strip(), } if provider == "vk": code_verifier = str(flow.get("code_verifier") or "").strip() if not code_verifier: raise ValueError("VK ID flow истек. Запусти вход еще раз") device_id = str(device_id or "").strip() if not device_id: raise ValueError("VK ID не вернул device_id") token_payload = { "grant_type": "authorization_code", "client_id": cfg["client_id"], "code": code, "redirect_uri": redirect_uri, "code_verifier": code_verifier, "device_id": device_id, "state": str(flow_state or "").strip(), } service_token = str(cfg.get("client_secret") or "").strip() if service_token: token_payload["service_token"] = service_token token = oauth_fetch_json( SOCIAL_PROVIDERS[provider]["token_url"], method="POST", headers={"Accept": "application/json"}, data=token_payload, ) access_token = str(token.get("access_token") or "").strip() if not access_token: raise ValueError(token.get("error_description") or token.get("error") or "VK ID не вернул access token") token_state = str(token.get("state") or "").strip() if token_state and token_state != str(flow_state or "").strip(): raise ValueError("VK ID вернул неожиданный state") profile = oauth_fetch_json( SOCIAL_PROVIDERS[provider]["api_url"], method="POST", headers={"Accept": "application/json"}, data={ "client_id": cfg["client_id"], "access_token": access_token, }, ) user = profile.get("user") if isinstance(profile.get("user"), dict) else {} account_id = str(token.get("user_id") or user.get("user_id") or "").strip() if not account_id: raise ValueError("VK ID не вернул ID пользователя") first_name = str(user.get("first_name") or "").strip() last_name = str(user.get("last_name") or "").strip() full_name = " ".join(part for part in (first_name, last_name) if part).strip() email = str(user.get("email") or "").strip() return { "id": account_id, "label": full_name or email or f"VK ID {account_id}", "login": "", "name": full_name, "email": email, "profile_url": f"https://vk.com/id{account_id}", "avatar_url": str(user.get("avatar") or "").strip(), } raise ValueError("Неизвестный OAuth provider") def serve_acme_challenge(self, path): prefix = "/.well-known/acme-challenge/" token = urllib.parse.unquote(path[len(prefix):]) if not token or "/" in token or "\\" in token: self.send_text(404, "not found") return challenge_path = ACME_WEBROOT / ".well-known" / "acme-challenge" / token try: body = challenge_path.read_bytes() except OSError: self.send_text(404, "not found") return self.send_bytes(200, body, "text/plain; charset=utf-8") def redirect(self, location, extra_headers=None): self.close_connection = True self.send_response(302) self.send_header("Location", location) self.send_header("Content-Length", "0") self.send_header("Connection", "close") if extra_headers: for key, value in extra_headers: self.send_header(key, value) self.end_headers() def login(self): payload = self.read_payload() username = payload.get("username", "") password = payload.get("password", "") otp = payload.get("otp", "") captcha_token = payload.get("captcha_token", "") captcha_answer = payload.get("captcha_answer", "") if not verify_captcha(captcha_token, captcha_answer): self.send_bytes(401, login_html("Неверная капча").encode("utf-8"), "text/html; charset=utf-8") return ok, error_text, auth, auth_method = verify_password_login(username, password, otp) if ok: token, _ = self.create_login_session((auth or {}).get("username", username), auth_method) self.redirect("/", [("Set-Cookie", self.session_cookie(token))]) return self.send_bytes(401, login_html(error_text or "Неверный логин или пароль").encode("utf-8"), "text/html; charset=utf-8") def login(self): payload = self.read_payload() username = payload.get("username", "") password = payload.get("password", "") otp = payload.get("otp", "") captcha_ok, captcha_error = self.verify_login_captcha(payload) if not captcha_ok: fallback_message = recaptcha_fallback_message(captcha_error) self.send_bytes( 401, login_html( fallback_message or captcha_error or "Неверная капча", force_local_captcha=bool(fallback_message), ).encode("utf-8"), "text/html; charset=utf-8", ) return ok, error_text, auth, auth_method = verify_password_login(username, password, otp) if ok: token, _ = self.create_login_session((auth or {}).get("username", username), auth_method) self.redirect("/", [("Set-Cookie", self.session_cookie(token))]) return self.send_bytes(401, login_html(error_text or "Неверный логин или пароль").encode("utf-8"), "text/html; charset=utf-8") def update_auth(self): payload = self.read_payload() auth = load_auth() current_password = payload.get("current_password", "") if not verify_login(auth.get("username", ""), current_password): self.send_text(403, "Текущий пароль неверный") return username = payload.get("username", auth.get("username", "admin")) new_password = payload.get("password", "") confirm = payload.get("password_confirm", "") if new_password: if new_password != confirm: self.send_text(400, "Новый пароль и повтор не совпадают") return if len(new_password) < MIN_PASSWORD_LENGTH: self.send_text(400, f"Новый пароль должен быть минимум {MIN_PASSWORD_LENGTH} символа") return save_auth(username, new_password) else: clean = clean_username(username) auth["username"] = clean save_auth_state(auth) self.send_text(200, "Доступ к Hub обновлен") def update_auth(self): payload = self.read_payload() auth = normalize_auth_state(load_auth()) current_password = payload.get("current_password", "") if not verify_login(auth.get("username", ""), current_password): self.send_text(403, "Текущий пароль неверный") return username = payload.get("username", auth.get("username", "admin")) new_password = payload.get("password", "") confirm = payload.get("password_confirm", "") captcha_mode = sanitize_captcha_mode(payload.get("captcha_mode")) captcha_site_key = str(payload.get("captcha_site_key") or "").strip() captcha_secret_key = str(payload.get("captcha_secret_key") or "").strip() if new_password: if new_password != confirm: self.send_text(400, "Новый пароль и повтор не совпадают") return if len(new_password) < MIN_PASSWORD_LENGTH: self.send_text(400, f"Новый пароль должен быть минимум {MIN_PASSWORD_LENGTH} символа") return if captcha_mode == CAPTCHA_MODE_RECAPTCHA and not (captcha_site_key and captcha_secret_key): self.send_text(400, "Для Google reCAPTCHA v2 Checkbox нужны Site Key и Secret Key") return auth["username"] = clean_username(username) if new_password: auth["password"] = password_digest(new_password) auth["captcha"] = sanitize_captcha_state( { "mode": captcha_mode, "site_key": captcha_site_key, "secret_key": captcha_secret_key, } ) auth["updated_at"] = now_ts() save_auth_state(auth) self.send_text(200, "Доступ к Hub обновлен") def build_auth_meta(self): auth = normalize_auth_state(load_auth()) current = self.current_account_profile(touch=False) if self.admin_ok() else None if current and current.get("is_owner"): meta = admin_auth_meta(auth) with self.app.conn() as conn: router_rows = list_router_rows(conn) session_rows_by_username = {} for session in list_hub_sessions("", ""): username = str(session.get("username") or "") if not username: continue session_rows_by_username.setdefault(username, []).append(session) login_rows_by_username = {} for event in list_login_events(""): username = str(event.get("username") or "") if not username: continue login_rows_by_username.setdefault(username, []).append(event) meta["username"] = current.get("username", auth.get("username", "admin")) meta["is_owner"] = True meta["can_add_router"] = True meta["current_user"] = { "username": current.get("username", auth.get("username", "admin")), "is_owner": True, } meta["router_options"] = [ { "id": router.get("id", ""), "name": router.get("name", ""), "role": router.get("role", "node"), } for router in [row_to_router(row) for row in router_rows] ] meta["delegated_users"] = [ item for item in ( serialize_delegated_user( auth, user, router_rows, session_rows_by_username.get(str((user or {}).get("username") or ""), []), login_rows_by_username.get(str((user or {}).get("username") or ""), []), ) for user in auth.get("delegated_users", []) ) if item ] elif current: with self.app.conn() as conn: router_rows = list_router_rows(conn) meta = delegated_auth_meta(auth, current, router_rows) else: meta = public_auth_meta(auth) meta["can_add_router"] = False social = meta.get("social") if isinstance(meta.get("social"), dict) else {} for provider, item in social.items(): if not isinstance(item, dict): continue item["redirect_uri"] = self.social_callback_url(provider) return meta def auth_meta(self): self.send_json(200, {"ok": True, "auth": self.build_auth_meta()}) def save_delegated_user(self): try: payload = self.read_payload() auth = self.require_current_password(payload) username = clean_username(payload.get("username", "")) if secrets.compare_digest(username, auth.get("username", "")): raise ValueError("Главный аккаунт нельзя превратить в ограниченный") user_id = str(payload.get("id") or "").strip() password = str(payload.get("password") or "") password_confirm = str(payload.get("password_confirm") or "") if password: if password != password_confirm: raise ValueError("Пароль и повтор не совпадают") if len(password) < MIN_PASSWORD_LENGTH: raise ValueError(f"Пароль должен быть минимум {MIN_PASSWORD_LENGTH} символа") next_password = password_digest(password) else: next_password = None router_flags = sanitize_router_access_map(payload.get("router_flags")) enabled = bool(payload.get("enabled", True)) existing = None for item in auth.get("delegated_users", []): if user_id and item.get("id") == user_id: existing = item break for item in auth.get("delegated_users", []): if existing and item.get("id") == existing.get("id"): continue if secrets.compare_digest(item.get("username", ""), username): raise ValueError("Пользователь с таким логином уже существует") if existing is None and next_password is None: raise ValueError("Для нового пользователя нужен пароль") updated_users = [] replaced = False for item in auth.get("delegated_users", []): if existing and item.get("id") == existing.get("id"): updated_users.append( { **item, "username": username, "password": next_password or item.get("password", {}), "enabled": enabled, "router_flags": router_flags, "updated_at": now_ts(), } ) replaced = True continue updated_users.append(item) if not replaced: updated_users.append( { "id": user_id or secrets.token_hex(8), "username": username, "password": next_password, "enabled": enabled, "router_flags": router_flags, "created_at": now_ts(), "updated_at": now_ts(), } ) auth = save_auth_state({**auth, "delegated_users": updated_users}) self.send_json(200, {"ok": True, "message": "Пользователь сохранен", "auth": self.build_auth_meta()}) except ValueError as exc: self.send_json(400, {"ok": False, "error": str(exc)}) except Exception as exc: self.send_json(500, {"ok": False, "error": str(exc)}) def delete_delegated_user(self): try: payload = self.read_payload() auth = self.require_current_password(payload) user_id = str(payload.get("id") or "").strip() if not user_id: raise ValueError("Не указан пользователь") removed = 0 removed_username = "" kept = [] for item in auth.get("delegated_users", []): if item.get("id") == user_id: removed += 1 removed_username = str(item.get("username") or "") continue kept.append(item) if not removed: raise ValueError("Пользователь уже удален") revoke_hub_sessions_for_username(removed_username) auth = save_auth_state({**auth, "delegated_users": kept}) self.send_json(200, {"ok": True, "message": "Пользователь удален", "auth": self.build_auth_meta()}) except ValueError as exc: self.send_json(400, {"ok": False, "error": str(exc)}) except Exception as exc: self.send_json(500, {"ok": False, "error": str(exc)}) def revoke_delegated_user_sessions(self): try: payload = self.read_payload() auth = self.require_current_password(payload) user_id = str(payload.get("id") or "").strip() if not user_id: raise ValueError("Не указан пользователь") target = next((item for item in auth.get("delegated_users", []) if item.get("id") == user_id), None) if not target: raise ValueError("Пользователь не найден") target_username = str(target.get("username") or "").strip() removed = revoke_hub_sessions_for_username(target_username) self.send_json( 200, { "ok": True, "removed": removed, "message": "Сессии пользователя завершены" if removed else "У пользователя нет активных сессий", "auth": self.build_auth_meta(), }, ) except ValueError as exc: self.send_json(400, {"ok": False, "error": str(exc)}) except Exception as exc: self.send_json(500, {"ok": False, "error": str(exc)}) def save_social_provider_config(self, provider): try: payload = self.read_payload() auth = self.require_current_password(payload) provider = str(provider or "").strip().lower() if provider not in SOCIAL_PROVIDERS: raise ValueError("Неизвестный OAuth provider") client_id = str(payload.get("client_id") or "").strip() client_secret = str(payload.get("client_secret") or "").strip() def mutator(current): current = normalize_auth_state(current) current["social"][provider]["client_id"] = client_id current["social"][provider]["client_secret"] = client_secret return current save_auth_state(mutator(auth)) self.send_json( 200, { "ok": True, "auth": self.build_auth_meta(admin=True), "message": f"{social_provider_label(provider)} сохранен", }, ) except ValueError as exc: self.send_json(400, {"ok": False, "error": str(exc)}) except Exception as exc: self.send_json(500, {"ok": False, "error": str(exc)}) def begin_social_link(self, provider): try: payload = self.read_payload() auth = self.require_current_password(payload) provider = str(provider or "").strip().lower() redirect_uri = self.social_callback_url(provider) cfg = self.social_provider_config(provider, auth) if not social_provider_configured(provider, cfg): raise ValueError(social_provider_setup_message(provider)) flow_payload = { "provider": provider, "mode": "link", "redirect_uri": redirect_uri, } if provider == "vk": flow_payload["code_verifier"] = make_pkce_verifier() ticket = put_auth_flow(f"oauth-{provider}", flow_payload) self.send_json( 200, { "ok": True, "url": self.social_flow_authorize_url(provider, ticket, redirect_uri, flow=flow_payload), }, ) except ValueError as exc: self.send_json(400, {"ok": False, "error": str(exc)}) except Exception as exc: self.send_json(500, {"ok": False, "error": str(exc)}) def unlink_social_account(self, provider): try: payload = self.read_payload() auth = self.require_current_password(payload) provider = str(provider or "").strip().lower() account_id = str(payload.get("id") or "").strip() if not account_id: raise ValueError("Не указан аккаунт для отвязки") if not find_social_account_record(auth, provider, account_id): raise ValueError("Аккаунт уже отвязан") updated = save_auth_state(remove_social_account(auth, provider, account_id)) self.send_json( 200, { "ok": True, "auth": self.build_auth_meta(admin=True), "message": f"{social_provider_label(provider)} отвязан", }, ) except ValueError as exc: self.send_json(400, {"ok": False, "error": str(exc)}) except Exception as exc: self.send_json(500, {"ok": False, "error": str(exc)}) def start_social_login(self, provider): provider = str(provider or "").strip().lower() try: redirect_uri = self.social_callback_url(provider) cfg = self.social_provider_config(provider) if not social_provider_configured(provider, cfg): raise ValueError(social_provider_setup_message(provider)) if not cfg.get("accounts"): raise ValueError(f"Для {social_provider_label(provider)} пока нет привязанных аккаунтов") flow_payload = { "provider": provider, "mode": "login", "redirect_uri": redirect_uri, } if provider == "vk": flow_payload["code_verifier"] = make_pkce_verifier() ticket = put_auth_flow(f"oauth-{provider}", flow_payload) self.redirect(self.social_flow_authorize_url(provider, ticket, redirect_uri, flow=flow_payload)) except ValueError as exc: self.send_bytes(400, self.social_login_error_page(str(exc)).encode("utf-8"), "text/html; charset=utf-8") except Exception as exc: self.send_bytes(500, self.social_login_error_page(str(exc)).encode("utf-8"), "text/html; charset=utf-8") def finish_social_callback(self, provider): provider = str(provider or "").strip().lower() params = self.query() flow_state = str(params.get("state", [""])[0] or "") error_code = str(params.get("error", [""])[0] or "") error_text = str(params.get("error_description", [""])[0] or params.get("error_reason", [""])[0] or error_code or "") flow = None try: flow = pop_auth_flow(flow_state, f"oauth-{provider}") if not flow: raise ValueError("OAuth сессия истекла или уже была использована") if error_code: raise ValueError(error_text or f"{social_provider_label(provider)} вернул ошибку авторизации") code = str(params.get("code", [""])[0] or "").strip() if not code: raise ValueError("OAuth provider не вернул код авторизации") device_id = str(params.get("device_id", [""])[0] or "").strip() account = self.exchange_social_code( provider, code, str(flow.get("redirect_uri") or self.social_callback_url(provider)), flow=flow, flow_state=flow_state, device_id=device_id, ) if flow.get("mode") == "link": updated = save_auth_state(upsert_social_account(load_auth(), provider, account)) message = f"{social_provider_label(provider)} аккаунт {account.get('label') or account.get('id')} привязан" self.send_bytes( 200, self.oauth_popup_html(social_provider_label(provider), message, provider=provider, ok=True).encode("utf-8"), "text/html; charset=utf-8", ) return auth = load_auth() linked = find_social_account_record(auth, provider, account.get("id")) if not linked: raise ValueError("Этот аккаунт не привязан к Hub. Сначала привяжи его в разделе Доступ к Hub.") save_auth_state(touch_social_account_last_used(auth, provider, account.get("id"))) token, _ = self.create_login_session(current_username(), auth_method=provider) self.redirect("/", [("Set-Cookie", self.session_cookie(token))]) except ValueError as exc: if (flow or {}).get("mode") == "link": self.send_bytes( 400, self.oauth_popup_html(social_provider_label(provider), str(exc), provider=provider, ok=False).encode("utf-8"), "text/html; charset=utf-8", ) return self.send_bytes(400, self.social_login_error_page(str(exc)).encode("utf-8"), "text/html; charset=utf-8") except Exception as exc: self.send_bytes(500, self.social_login_error_page(str(exc)).encode("utf-8"), "text/html; charset=utf-8") def totp_setup(self): try: payload = self.read_payload() auth = self.require_current_password(payload) secret = generate_totp_secret() ticket = put_auth_flow("totp-setup", {"secret": secret, "username": auth.get("username", "admin")}) self.send_json( 200, { "ok": True, "ticket": ticket, "secret": secret, "otpauth_uri": totp_otpauth_uri(auth.get("username", "admin"), secret), "digits": TOTP_DIGITS, "period": TOTP_PERIOD_SECONDS, }, ) except Exception as exc: self.send_json(400, {"ok": False, "error": str(exc)}) def totp_enable(self): try: payload = self.read_payload() self.require_current_password(payload) ticket = payload.get("ticket", "") flow = get_auth_flow(ticket, "totp-setup") if not flow: raise ValueError("Сессия настройки 2FA истекла, начни заново") secret = flow.get("secret", "") if not verify_totp(secret, payload.get("code", "")): raise ValueError("Неверный код 2FA") pop_auth_flow(ticket, "totp-setup") auth = update_auth_state( lambda current: { **current, "totp": { **default_totp_state(), "enabled": True, "secret": secret, "digits": TOTP_DIGITS, "period": TOTP_PERIOD_SECONDS, "updated_at": now_ts(), }, } ) self.send_json(200, {"ok": True, "message": "2FA включена", "auth": admin_auth_meta(auth)}) except Exception as exc: self.send_json(400, {"ok": False, "error": str(exc)}) def totp_disable(self): try: payload = self.read_payload() auth = self.require_current_password(payload) if not auth.get("totp", {}).get("enabled"): raise ValueError("2FA уже выключена") if not verify_totp(auth.get("totp", {}).get("secret", ""), payload.get("code", "")): raise ValueError("Неверный код 2FA") auth = update_auth_state( lambda current: { **current, "totp": { **default_totp_state(), "updated_at": now_ts(), }, } ) self.send_json(200, {"ok": True, "message": "2FA выключена", "auth": admin_auth_meta(auth)}) except Exception as exc: self.send_json(400, {"ok": False, "error": str(exc)}) def begin_passkey_registration(self): try: payload = self.read_payload() auth = self.require_current_password(payload) server = self.build_webauthn_server() label = str(payload.get("label") or f"Passkey {len(auth.get('passkeys', [])) + 1}").strip()[:80] or "Passkey" options, state = server.register_begin( { "id": auth.get("username", "admin").encode("utf-8"), "name": auth.get("username", "admin"), "displayName": auth.get("username", "admin"), }, passkey_credentials(auth), resident_key_requirement=ResidentKeyRequirement.PREFERRED if ResidentKeyRequirement else None, user_verification=UserVerificationRequirement.PREFERRED if UserVerificationRequirement else None, ) ticket = put_auth_flow( "passkey-register", {"state": state, "label": label, "username": auth.get("username", "admin")}, ) self.send_json(200, {"ok": True, "ticket": ticket, "options": webauthn_json(dict(options))}) except Exception as exc: self.send_json(400, {"ok": False, "error": str(exc)}) def finish_passkey_registration(self): try: payload = self.read_payload() ticket = payload.get("ticket", "") response = payload.get("credential") if isinstance(payload.get("credential"), dict) else payload flow = pop_auth_flow(ticket, "passkey-register") if not flow: raise ValueError("Passkey-регистрация истекла, начни заново") server = self.build_webauthn_server() auth_data = server.register_complete(flow.get("state"), response) credential_data = auth_data.credential_data if not credential_data: raise ValueError("Не удалось прочитать credential data") key_id = b64url(credential_data.credential_id) label = str(flow.get("label") or "Passkey").strip()[:80] or "Passkey" def mutator(current): current = normalize_auth_state(current) rows = [item for item in current.get("passkeys", []) if item.get("id") != key_id] rows.append( { "id": key_id, "label": label, "credential_data": b64url(bytes(credential_data)), "created_at": now_ts(), "last_used_at": 0, "sign_count": int(auth_data.counter or 0), "transports": [str(value).strip() for value in payload.get("transports", []) if str(value).strip()], } ) current["passkeys"] = rows return current auth = update_auth_state(mutator) self.send_json(200, {"ok": True, "message": "Passkey добавлен", "auth": admin_auth_meta(auth)}) except Exception as exc: self.send_json(400, {"ok": False, "error": str(exc)}) def remove_passkey(self): try: payload = self.read_payload() self.require_current_password(payload) credential_id = str(payload.get("id") or "").strip() if not credential_id: raise ValueError("id passkey пустой") def mutator(current): current = normalize_auth_state(current) current["passkeys"] = [item for item in current.get("passkeys", []) if item.get("id") != credential_id] return current auth = update_auth_state(mutator) self.send_json(200, {"ok": True, "message": "Passkey удален", "auth": admin_auth_meta(auth)}) except Exception as exc: self.send_json(400, {"ok": False, "error": str(exc)}) def begin_passkey_login(self): try: auth = load_auth() passkey_info = passkey_inventory(auth) credentials = passkey_info.get("credentials", []) if not credentials: if passkey_info.get("invalid_count"): raise ValueError("Сохраненный passkey поврежден или записан в старом формате. Удали его в меню доступа и зарегистрируй заново") raise ValueError("Для входа Passkey пока не зарегистрирован") server = self.build_webauthn_server() options, state = server.authenticate_begin( credentials, user_verification=UserVerificationRequirement.PREFERRED if UserVerificationRequirement else None, ) ticket = put_auth_flow("passkey-login", {"state": state, "username": auth.get("username", "admin")}) self.send_json(200, {"ok": True, "ticket": ticket, "options": webauthn_json(dict(options))}) except Exception as exc: self.send_json(400, {"ok": False, "error": str(exc)}) def finish_passkey_login(self): try: payload = self.read_payload() ticket = payload.get("ticket", "") response = payload.get("credential") if isinstance(payload.get("credential"), dict) else payload flow = pop_auth_flow(ticket, "passkey-login") if not flow: raise ValueError("Passkey-челлендж истек, начни вход заново") auth = load_auth() passkey_info = passkey_inventory(auth) credentials = passkey_info.get("credentials", []) if not credentials: if passkey_info.get("invalid_count"): raise ValueError("Сохраненный passkey поврежден или записан в старом формате. Удали его в меню доступа и зарегистрируй заново") raise ValueError("Passkey не зарегистрирован") server = self.build_webauthn_server() credential = server.authenticate_complete(flow.get("state"), credentials, response) key_id = b64url(credential.credential_id) counter = 0 if AuthenticationResponse is not None: try: auth_response = AuthenticationResponse.from_dict(response) counter = int(auth_response.response.authenticator_data.counter or 0) except Exception: counter = 0 def mutator(current): current = normalize_auth_state(current) for item in current.get("passkeys", []): if item.get("id") == key_id: item["last_used_at"] = now_ts() item["sign_count"] = max(int(item.get("sign_count") or 0), counter) break return current update_auth_state(mutator) self.send_login_json(auth.get("username", "admin"), "passkey") except Exception as exc: self.send_json(400, {"ok": False, "error": str(exc)}) def add_ssh_key(self): try: payload = self.read_payload() self.require_current_password(payload) key = sanitize_ssh_key_record( { "id": payload.get("id", ""), "label": payload.get("label", ""), "public_key": payload.get("public_key", ""), "created_at": now_ts(), } ) if not key: raise ValueError("SSH ED25519 ключ не распознан") def mutator(current): current = normalize_auth_state(current) rows = [item for item in current.get("ssh_keys", []) if item.get("public_key") != key.get("public_key")] rows.append(key) current["ssh_keys"] = rows return current auth = update_auth_state(mutator) self.send_json(200, {"ok": True, "message": "SSH ED25519 ключ добавлен", "auth": admin_auth_meta(auth)}) except Exception as exc: self.send_json(400, {"ok": False, "error": str(exc)}) def remove_ssh_key(self): try: payload = self.read_payload() self.require_current_password(payload) key_id = str(payload.get("id") or "").strip() if not key_id: raise ValueError("id SSH ключа пустой") def mutator(current): current = normalize_auth_state(current) current["ssh_keys"] = [item for item in current.get("ssh_keys", []) if item.get("id") != key_id] return current auth = update_auth_state(mutator) self.send_json(200, {"ok": True, "message": "SSH ключ удален", "auth": admin_auth_meta(auth)}) except Exception as exc: self.send_json(400, {"ok": False, "error": str(exc)}) def begin_ssh_login(self): try: auth = load_auth() ssh_keys = auth.get("ssh_keys", []) if not ssh_keys: raise ValueError("Для входа ED25519 пока нет зарегистрированных ключей") issued_at = now_ts() host = self.request_host() ticket = put_auth_flow("ssh-login", {"username": auth.get("username", "admin"), "issued_at": issued_at, "host": host}) challenge = build_ssh_auth_message(ticket, auth.get("username", "admin"), host, issued_at) with AUTH_FLOW_LOCK: state = AUTH_FLOW_STATE.get(ticket) if state: state["challenge"] = challenge self.send_json( 200, { "ok": True, "ticket": ticket, "challenge": challenge, "namespace": ssh_auth_namespace(), "principal": ssh_auth_principal(auth.get("username", "admin")), "keys": public_auth_meta(auth).get("ssh_keys", []), }, ) except Exception as exc: self.send_json(400, {"ok": False, "error": str(exc)}) def finish_ssh_login(self): try: payload = self.read_payload() ticket = str(payload.get("ticket") or "").strip() flow = pop_auth_flow(ticket, "ssh-login") if not flow: raise ValueError("ED25519-челлендж истек, начни вход заново") auth = load_auth() challenge = str(flow.get("challenge") or "") if not challenge: challenge = build_ssh_auth_message( ticket, auth.get("username", "admin"), flow.get("host", "") or self.request_host(), flow.get("issued_at", 0), ) matched = verify_ssh_auth_signature(auth.get("ssh_keys", []), auth.get("username", "admin"), challenge, payload.get("signature", "")) def mutator(current): current = normalize_auth_state(current) for item in current.get("ssh_keys", []): if item.get("id") == matched.get("id"): item["last_used_at"] = now_ts() break return current update_auth_state(mutator) self.send_login_json(auth.get("username", "admin"), "ed25519") except Exception as exc: self.send_json(400, {"ok": False, "error": str(exc)}) def router_id_from_path(self, prefix): suffix = self.parsed().path[len(prefix):].strip("/") if not suffix: return "" return urllib.parse.unquote(suffix.split("/", 1)[0]) def ssh_page(self): router_id = self.router_id_from_path("/ssh/") if not self.require_router_access(router_id, "B"): return with self.app.conn() as conn: row = get_active_router(conn, router_id) if not row: self.send_text(404, "router not found") return if int(row["ssh_entry_port"] or 0) <= 0: self.send_text(400, "router has no ssh_entry_port") return ws_token = ssh_ws_token(self.app.session_token, router_id) self.send_bytes( 200, ssh_terminal_html_v2(row, ws_token).encode("utf-8"), "text/html; charset=utf-8", [("Set-Cookie", current_router_cookie(router_id))], ) def router_notes_page(self, router_id, error="", draft=None, status=200, edit_note_id=""): if not self.require_router_access(router_id, "A"): return profile = self.current_account_profile(touch=False) or {} with self.app.conn() as conn: row = get_active_router(conn, router_id) if not row: self.send_text(404, "router not found") return router = router_with_access(row_to_router(row), profile) saved = self.query().get("saved", [""])[0] if (router.get("permissions") or {}).get("notes_edit") and not edit_note_id: edit_note_id = self.query().get("edit", [""])[0] else: edit_note_id = "" body = router_notes_html( router, username=(profile or {}).get("username") or current_username(), saved="" if error else saved, error=error, draft=draft, edit_note_id=edit_note_id, ).encode("utf-8") self.send_bytes( status, body, "text/html; charset=utf-8", [("Set-Cookie", current_router_cookie(router_id))], ) def router_note_media_page(self, path): parts = path.strip("/").split("/") if len(parts) != 5 or parts[0] != "router" or parts[2] != "notes-media": self.send_text(404, "not found") return router_id = urllib.parse.unquote(parts[1]) note_id = urllib.parse.unquote(parts[3]) file_name = Path(urllib.parse.unquote(parts[4])).name if not self.require_router_access(router_id, "A"): return with self.app.conn() as conn: row = get_active_router(conn, router_id) if not row: self.send_text(404, "router not found") return entries = parse_router_notes_entries(row["notes"] or "", fallback_ts=row["updated_at"] or row["created_at"] or 0) image_meta = {} for item in entries: if str(item.get("id") or "") != note_id: continue for image in list(item.get("images") or []): if Path(str(image.get("file_name") or "")).name == file_name: image_meta = image break break if not image_meta: self.send_text(404, "image not found") return file_path = router_note_image_path(router_id, note_id, file_name) try: body = file_path.read_bytes() except FileNotFoundError: self.send_text(404, "image file not found") return self.send_bytes( 200, body, str(image_meta.get("content_type") or "application/octet-stream"), [("Cache-Control", "private, max-age=3600")], ) def router_notes_submit(self, router_id): payload = self.read_payload() action = str(payload.get("action") or "add").strip().lower() note_id = payload.get("note_id", "") notes = payload.get("note", payload.get("notes", "")) if action == "delete": if not self.owner_ok(): self.router_notes_page( router_id, error="Удаление заметок доступно только владельцу.", draft=notes, status=403, ) return elif not self.require_router_access(router_id, "G"): return uploads = payload_files(payload, "images") if action == "add" else [] try: with self.app.conn() as conn: if action == "delete": delete_router_note_entry(conn, router_id, note_id) saved = "deleted" elif action == "update": update_router_note_entry(conn, router_id, note_id, notes) saved = "updated" else: append_router_note(conn, router_id, notes, image_uploads=uploads) saved = "added" except Exception as exc: self.router_notes_page( router_id, error=str(exc), draft=notes, status=400, edit_note_id=note_id if action == "update" else "", ) return self.redirect(f"/router/{urllib.parse.quote(router_id)}/notes?saved={urllib.parse.quote(saved)}") def vps_terminal_page(self): if not self.require_owner(): return row = vps_terminal_row() ws_token = ssh_ws_token(self.app.session_token, row["id"]) public_host = urllib.parse.urlsplit(self.app.public_url).hostname if self.app.public_url else "" if not public_host: public_host = self.headers.get("Host", "").split(":", 1)[0] quick_commands_html = vps_quick_commands_html(public_host or "YOUR_VPS_IP") self.send_bytes(200, ssh_terminal_html_v2(row, ws_token, quick_commands_html).encode("utf-8"), "text/html; charset=utf-8") def ssh_ws(self): try: self.connection.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1) except OSError: pass router_id = self.router_id_from_path("/ssh-ws/") if self.ssh_token_ok(router_id): allowed = True elif is_vps_terminal_id(router_id): allowed = self.owner_ok() else: allowed = self.router_access_allowed(router_id, "B") if not allowed: self.send_response(403 if self.admin_ok() else 401) self.end_headers() return if not is_vps_terminal_id(router_id): with self.app.conn() as conn: row = get_active_router(conn, router_id) if not row: self.send_response(404) self.end_headers() return port = int(row["ssh_entry_port"] or 0) if port <= 0: self.send_response(400) self.end_headers() return key = self.headers.get("Sec-WebSocket-Key", "") if not key: self.send_response(400) self.end_headers() return self.send_response(101) self.send_header("Upgrade", "websocket") self.send_header("Connection", "Upgrade") self.send_header("Sec-WebSocket-Accept", ws_accept_value(key)) self.end_headers() self.close_connection = True if is_vps_terminal_id(router_id): self.run_vps_terminal_session() return self.run_ssh_session(router_id, port) def ssh_check(self): router_id = self.router_id_from_path("/api/ssh/") if router_id.endswith("/check"): router_id = router_id[:-6].rstrip("/") if self.ssh_token_ok(router_id): allowed = True elif is_vps_terminal_id(router_id): allowed = self.owner_ok() else: allowed = self.router_access_allowed(router_id, "B") if not allowed: self.send_json(403, {"ok": False, "error": "not authorized", "tcp_ok": False}) return if is_vps_terminal_id(router_id): self.send_json(200, {"ok": True, "router_id": router_id, "tcp_ok": True, "mode": "local-shell"}) return with self.app.conn() as conn: row = get_active_router(conn, router_id) if not row: self.send_json(404, {"ok": False, "error": "router not found", "tcp_ok": False}) return port = int(row["ssh_entry_port"] or 0) if port <= 0: self.send_json(200, {"ok": False, "error": "router has no ssh_entry_port", "tcp_ok": False}) return try: with socket.create_connection(("127.0.0.1", port), timeout=3): pass self.send_json(200, {"ok": True, "router_id": router_id, "port": port, "tcp_ok": True}) except Exception as exc: self.send_json(200, {"ok": False, "router_id": router_id, "port": port, "tcp_ok": False, "error": str(exc)}) def ssh_args(self, port): env = os.environ.copy() env["TERM"] = "xterm-256color" args = [ "ssh", "-tt", "-o", "StrictHostKeyChecking=no", "-o", "UserKnownHostsFile=/dev/null", "-o", "GlobalKnownHostsFile=/dev/null", "-o", "LogLevel=ERROR", "-o", "ServerAliveInterval=15", "-p", str(port), "root@127.0.0.1", ] return env, args def ssh_exec_args(self, port, allow_password=False): env = os.environ.copy() env.setdefault("LC_ALL", "C.UTF-8") args = [ "ssh", "-o", "StrictHostKeyChecking=no", "-o", "UserKnownHostsFile=/dev/null", "-o", "GlobalKnownHostsFile=/dev/null", "-o", "LogLevel=ERROR", "-o", "ConnectTimeout=8", "-o", "NumberOfPasswordPrompts=1", "-p", str(port), "root@127.0.0.1", ] if allow_password: args[1:1] = [ "-o", "PreferredAuthentications=publickey,password,keyboard-interactive", ] else: args[1:1] = ["-o", "BatchMode=yes"] return env, args def router_ssh_tcp_status(self, row, timeout=2): port = int(row["ssh_entry_port"] or 0) if row else 0 if port <= 0: return False, 0, "router has no ssh_entry_port" try: with socket.create_connection(("127.0.0.1", port), timeout=float(timeout)): pass return True, port, "" except Exception as exc: return False, port, str(exc) def prepare_ssh_askpass(self, env, ssh_password): password = str(ssh_password or "") if not password: return None askpass_dir = Path(tempfile.mkdtemp(prefix="owrt-askpass-")) askpass_script = askpass_dir / "askpass.sh" askpass_script.write_text( "#!/bin/sh\nprintf '%s\\n' \"$OWRT_REMOTE_SSH_PASSWORD\"\n", encoding="utf-8", ) os.chmod(askpass_script, 0o700) env["SSH_ASKPASS"] = str(askpass_script) env["SSH_ASKPASS_REQUIRE"] = "force" env["DISPLAY"] = env.get("DISPLAY") or "owrt-remote:0" env["OWRT_REMOTE_SSH_PASSWORD"] = password return askpass_dir def normalize_wol_mac(self, value): mac = str(value or "").strip().upper().replace("-", ":") if not mac: return "" compact = re.sub(r"[^0-9A-F]", "", mac) if len(compact) == 12: mac = ":".join(compact[idx : idx + 2] for idx in range(0, 12, 2)) if not re.fullmatch(r"(?:[0-9A-F]{2}:){5}[0-9A-F]{2}", mac): return "" if mac == "00:00:00:00:00:00": return "" return mac def run_router_ssh_script(self, row, script, script_args=None, timeout=15, ssh_password=""): port = int(row["ssh_entry_port"] or 0) if row else 0 if port <= 0: raise RuntimeError("router has no ssh_entry_port") password = str(ssh_password or "") env, args = self.ssh_exec_args(port, allow_password=bool(password)) askpass_dir = self.prepare_ssh_askpass(env, password) argv = args + ["sh", "-s", "--"] + [str(item) for item in (script_args or [])] try: result = subprocess.run( argv, input=str(script), text=True, capture_output=True, timeout=float(timeout), env=env, start_new_session=bool(password), ) except subprocess.TimeoutExpired as exc: raise RuntimeError(f"ssh command timeout after {int(timeout)}s") from exc finally: if askpass_dir: try: for child in askpass_dir.iterdir(): child.unlink(missing_ok=True) askpass_dir.rmdir() except OSError: pass if result.returncode != 0: message = (result.stderr or result.stdout or "").strip() raise RuntimeError(message or f"ssh command exited with code {result.returncode}") return result.stdout def wait_router_heartbeat(self, router_id, last_seen_before=0, timeout=6): deadline = time.time() + max(float(timeout), 0.0) seen_before = int(last_seen_before or 0) while time.time() <= deadline: with self.app.conn() as conn: row = get_active_router(conn, router_id) if row: try: last_seen = int(row["last_seen"] or 0) except (TypeError, ValueError): last_seen = 0 if last_seen > seen_before: return True, row time.sleep(1) with self.app.conn() as conn: row = get_active_router(conn, router_id) return False, row def apply_router_rebind_via_ssh(self, row, ssh_password="", request_origin=""): router_id = row_str_value(row, "id") last_seen_before = row_int_value(row, "last_seen", 0) tcp_ok, port, tcp_error = self.router_ssh_tcp_status(row) result = { "id": router_id, "name": row_str_value(row, "name", router_id), "port": port, "tcp_ok": bool(tcp_ok), "status": "pending", "heartbeat_confirmed": False, "error": "", } if not tcp_ok: result["status"] = "unreachable" result["error"] = tcp_error or "ssh tunnel is unreachable" return result hub_update, hub_url, config_vps_host = router_current_hub_bundle( row, self.app.public_url, request_origin, self.headers.get("Host", ""), ) script = make_openwrt_ssh_apply_script( row, hub_url, vps_host_override=config_vps_host, public_url_override=hub_update.get("public_url", ""), ) try: output = self.run_router_ssh_script( row, script, timeout=12, ssh_password=ssh_password, ).strip() result["status"] = "applied" if output: result["output"] = output except Exception as exc: result["status"] = "failed" result["error"] = str(exc) return result confirmed, fresh_row = self.wait_router_heartbeat(router_id, last_seen_before=last_seen_before, timeout=6) result["heartbeat_confirmed"] = bool(confirmed) result["status"] = "confirmed" if confirmed else "applied" if fresh_row: result["last_seen"] = row_int_value(fresh_row, "last_seen", 0) return result def discover_router_wol_devices(self, row, ssh_password=""): script = r""" set -eu tmp="${TMPDIR:-/tmp}/owrt-wol.$$.txt" cleanup() { rm -f "$tmp" } trap cleanup EXIT INT TERM : >"$tmp" if [ -f /tmp/dhcp.leases ]; then while read -r lease_ts mac ip host client_id; do [ -n "${mac:-}" ] || continue [ "${mac:-}" = "*" ] && continue [ "${host:-}" = "*" ] && host="" printf '%s\t%s\t%s\t%s\t%s\n' "$mac" "${ip:-}" "${host:-}" "" "dhcp" >>"$tmp" done /dev/null 2>&1; then uci -q show dhcp | sed -n "s/^\(dhcp\.[^=]*\)=host$/\1/p" | while IFS= read -r section; do [ -n "$section" ] || continue mac_list="$(uci -q get "$section.mac" 2>/dev/null || true)" ip_static="$(uci -q get "$section.ip" 2>/dev/null || true)" host_static="$(uci -q get "$section.name" 2>/dev/null || true)" [ -n "$mac_list" ] || continue old_ifs="$IFS" IFS=', ' for mac_item in $mac_list; do [ -n "$mac_item" ] || continue printf '%s\t%s\t%s\t%s\t%s\n' "$mac_item" "${ip_static:-}" "${host_static:-}" "" "static-dhcp" >>"$tmp" done IFS="$old_ifs" done fi if command -v ip >/dev/null 2>&1; then ip neigh show 2>/dev/null | awk ' BEGIN { OFS="\t" } { ip=""; dev=""; mac=""; if (NF >= 1) ip=$1; for (i = 1; i <= NF; i++) { if ($i == "dev" && i < NF) dev=$(i + 1); if ($i == "lladdr" && i < NF) mac=$(i + 1); } if (mac != "") print mac, ip, "", dev, "ip-neigh"; } ' >>"$tmp" fi if [ -r /proc/net/arp ]; then awk 'NR > 1 && $4 != "" && $4 != "00:00:00:00:00:00" { printf "%s\t%s\t\t%s\tarp\n", $4, $1, $6 }' /proc/net/arp >>"$tmp" fi cat "$tmp" """ raw = self.run_router_ssh_script(row, script, timeout=18, ssh_password=ssh_password) devices = {} for line in raw.splitlines(): if not line.strip(): continue parts = [part.strip() for part in line.split("\t")] while len(parts) < 5: parts.append("") mac = self.normalize_wol_mac(parts[0]) if not mac: continue ip_addr = parts[1] name = parts[2] iface = parts[3] source = parts[4] or "unknown" entry = devices.get(mac) if entry is None: entry = {"mac": mac, "ip": "", "name": "", "iface": "", "sources": []} devices[mac] = entry if ip_addr and not entry["ip"]: entry["ip"] = ip_addr if name and not entry["name"]: entry["name"] = name if iface and not entry["iface"]: entry["iface"] = iface if source and source not in entry["sources"]: entry["sources"].append(source) ordered = sorted( devices.values(), key=lambda item: ( str(item.get("name") or "").lower(), str(item.get("ip") or ""), str(item.get("mac") or ""), ), ) for item in ordered: label_parts = [] if item.get("name"): label_parts.append(item["name"]) if item.get("ip"): label_parts.append(item["ip"]) label_parts.append(item["mac"]) item["label"] = " | ".join(part for part in label_parts if part) item["source"] = ", ".join(item.pop("sources", [])) return ordered def discover_router_client_traffic(self, row, ssh_password=""): script = r""" set -eu tmp_clients="${TMPDIR:-/tmp}/owrt-clients.$$.txt" tmp_nft="${TMPDIR:-/tmp}/owrt-nft.$$.txt" tmp_conntrack="${TMPDIR:-/tmp}/owrt-conntrack.$$.txt" tmp_known_ips="${TMPDIR:-/tmp}/owrt-client-ips.$$.txt" tmp_rules="${TMPDIR:-/tmp}/owrt-client-rules.$$.txt" cleanup() { rm -f "$tmp_clients" "$tmp_nft" "$tmp_conntrack" "$tmp_known_ips" "$tmp_rules" } trap cleanup EXIT INT TERM : >"$tmp_clients" : >"$tmp_nft" : >"$tmp_conntrack" : >"$tmp_known_ips" : >"$tmp_rules" if [ -f /tmp/dhcp.leases ]; then while read -r lease_ts mac ip host client_id; do [ -n "${mac:-}" ] || continue [ "${mac:-}" = "*" ] && continue [ "${host:-}" = "*" ] && host="" printf '%s\t%s\t%s\t%s\t%s\t%s\n' "$mac" "${ip:-}" "${host:-}" "" "" "dhcp" >>"$tmp_clients" done /dev/null 2>&1; then uci -q show dhcp | sed -n "s/^\(dhcp\.[^=]*\)=host$/\1/p" | while IFS= read -r section; do [ -n "$section" ] || continue mac_list="$(uci -q get "$section.mac" 2>/dev/null || true)" ip_static="$(uci -q get "$section.ip" 2>/dev/null || true)" host_static="$(uci -q get "$section.name" 2>/dev/null || true)" [ -n "$mac_list" ] || continue old_ifs="$IFS" IFS=', ' for mac_item in $mac_list; do [ -n "$mac_item" ] || continue printf '%s\t%s\t%s\t%s\t%s\t%s\n' "$mac_item" "" "${host_static:-}" "${ip_static:-}" "" "static-dhcp" >>"$tmp_clients" done IFS="$old_ifs" done fi if command -v ip >/dev/null 2>&1; then ip neigh show 2>/dev/null | awk ' BEGIN { OFS="\t" } { ip=""; dev=""; mac=""; if (NF >= 1) ip=$1; for (i = 1; i <= NF; i++) { if ($i == "dev" && i < NF) dev=$(i + 1); if ($i == "lladdr" && i < NF) mac=$(i + 1); } if (mac != "") print mac, ip, "", "", dev, "ip-neigh"; } ' >>"$tmp_clients" fi if [ -r /proc/net/arp ]; then awk 'NR > 1 && $4 != "" && $4 != "00:00:00:00:00:00" { printf "%s\t%s\t\t\t%s\tarp\n", $4, $1, $6 }' /proc/net/arp >>"$tmp_clients" fi awk -F '\t' ' { if ($2 != "") print $2; if ($4 != "") print $4; } ' "$tmp_clients" | awk '!seen[$0]++ && $0 ~ /^[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+$/ { print }' >"$tmp_known_ips" traffic_source="none" has_nft=0 has_conntrack=0 if command -v nft >/dev/null 2>&1; then nft add table inet owrt_traffic >/dev/null 2>&1 || true nft 'add chain inet owrt_traffic client_prerouting { type filter hook prerouting priority filter; policy accept; }' >/dev/null 2>&1 || true nft 'add chain inet owrt_traffic client_postrouting { type filter hook postrouting priority filter; policy accept; }' >/dev/null 2>&1 || true nft list table inet owrt_traffic >"$tmp_rules" 2>/dev/null || true while IFS= read -r client_ip; do [ -n "${client_ip:-}" ] || continue grep -Fq "owrt-tx:$client_ip" "$tmp_rules" || nft add rule inet owrt_traffic client_prerouting ip saddr "$client_ip" counter comment "owrt-tx:$client_ip" >/dev/null 2>&1 || true grep -Fq "owrt-rx:$client_ip" "$tmp_rules" || nft add rule inet owrt_traffic client_postrouting ip daddr "$client_ip" counter comment "owrt-rx:$client_ip" >/dev/null 2>&1 || true done <"$tmp_known_ips" if nft list table inet owrt_traffic >"$tmp_nft" 2>/dev/null; then has_nft=1 fi fi if command -v conntrack >/dev/null 2>&1; then if conntrack -L -o extended >"$tmp_conntrack" 2>/dev/null; then has_conntrack=1 traffic_source="conntrack" fi fi if [ "$has_conntrack" -eq 0 ]; then for candidate in /proc/net/nf_conntrack /proc/net/ip_conntrack; do if [ -r "$candidate" ]; then cat "$candidate" >"$tmp_conntrack" has_conntrack=1 traffic_source="$(basename "$candidate")" break fi done fi if [ "$has_nft" -eq 1 ] && [ "$has_conntrack" -eq 1 ]; then traffic_source="nftables+${traffic_source}" elif [ "$has_nft" -eq 1 ]; then traffic_source="nftables" fi printf 'META\ttraffic_source\t%s\n' "${traffic_source:-none}" awk -F '\t' -v nft_file="$tmp_nft" -v conntrack_file="$tmp_conntrack" -v has_nft="$has_nft" -v has_conntrack="$has_conntrack" -v traffic_source="${traffic_source:-none}" ' function append_unique(existing, value, arr, idx) { if (value == "") return existing; if (existing == "") return value; split(existing, arr, /, /); for (idx in arr) if (arr[idx] == value) return existing; return existing ", " value; } FNR == NR { mac=toupper($1); ip=$2; host=$3; static_ip=$4; iface=$5; source=$6; if (mac == "") next; if (!(mac in seen)) { order[++count]=mac; seen[mac]=1; } if (ip != "" && ips[mac] == "") ips[mac]=ip; if (host != "" && hosts[mac] == "") hosts[mac]=host; if (static_ip != "" && statics[mac] == "") statics[mac]=static_ip; if (iface != "" && ifaces[mac] == "") ifaces[mac]=iface; sources[mac]=append_unique(sources[mac], source); if (ip != "") mac_by_ip[ip]=mac; if (static_ip != "") mac_by_ip[static_ip]=mac; next; } END { flow_hits=0; if ((has_nft + 0) > 0) { while ((getline line < nft_file) > 0) { bytes=0; ip=""; dir=""; quoted_count=split(line, quoted, "\""); for (q=1; q<=quoted_count; q++) { if (quoted[q] ~ /^owrt-(tx|rx):/) { marker_count=split(quoted[q], marker, ":"); if (marker_count >= 2) { if (marker[1] == "owrt-tx") dir="tx"; else if (marker[1] == "owrt-rx") dir="rx"; ip=marker[2]; } break; } } if (dir == "" || ip == "" || !(ip in mac_by_ip)) continue; n=split(line, parts, /[[:space:]]+/); for (i=1; i<=n; i++) { if (parts[i] == "bytes" && i < n) { bytes=parts[i + 1] + 0; break; } } if (dir == "tx") tx_nft[mac_by_ip[ip]] = bytes; else if (dir == "rx") rx_nft[mac_by_ip[ip]] = bytes; flow_hits++; } close(nft_file); } if ((has_conntrack + 0) > 0) { while ((getline line < conntrack_file) > 0) { src1=dst1=src2=dst2=""; bytes1=bytes2=0; src_count=0; dst_count=0; bytes_count=0; n=split(line, parts, /[[:space:]]+/); for (i=1; i<=n; i++) { token=parts[i]; if (token ~ /^src=/) { src_count++; if (src_count == 1) src1=substr(token, 5); else if (src_count == 2) src2=substr(token, 5); } else if (token ~ /^dst=/) { dst_count++; if (dst_count == 1) dst1=substr(token, 5); else if (dst_count == 2) dst2=substr(token, 5); } else if (token ~ /^bytes=/) { bytes_count++; if (bytes_count == 1) bytes1=substr(token, 7) + 0; else if (bytes_count == 2) bytes2=substr(token, 7) + 0; } } if (bytes1 > 0) { if (src1 in mac_by_ip) tx_conntrack[mac_by_ip[src1]] += bytes1; if (dst1 in mac_by_ip) rx_conntrack[mac_by_ip[dst1]] += bytes1; flow_hits++; } if (bytes2 > 0) { if (src2 in mac_by_ip) tx_conntrack[mac_by_ip[src2]] += bytes2; if (dst2 in mac_by_ip) rx_conntrack[mac_by_ip[dst2]] += bytes2; flow_hits++; } } close(conntrack_file); } printf "META\tflow_hits\t%d\n", flow_hits + 0; for (i=1; i<=count; i++) { mac=order[i]; rx_value=rx_nft[mac] + 0; tx_value=tx_nft[mac] + 0; if ((rx_conntrack[mac] + 0) > rx_value) rx_value=rx_conntrack[mac] + 0; if ((tx_conntrack[mac] + 0) > tx_value) tx_value=tx_conntrack[mac] + 0; total=rx_value + tx_value; printf "CLIENT\t%s\t%s\t%s\t%s\t%s\t%s\t%.0f\t%.0f\t%.0f\n", mac, ips[mac], hosts[mac], statics[mac], ifaces[mac], sources[mac], rx_value, tx_value, total; } } ' "$tmp_clients" """ raw = self.run_router_ssh_script(row, script, timeout=28, ssh_password=ssh_password) clients = [] traffic_source = "none" flow_hits = 0 for line in raw.splitlines(): if not line.strip(): continue parts = [part.strip() for part in line.split("\t")] if not parts: continue kind = parts[0] if kind == "META" and len(parts) >= 3: if parts[1] == "traffic_source": traffic_source = parts[2] or "none" elif parts[1] == "flow_hits": try: flow_hits = int(parts[2] or 0) except ValueError: flow_hits = 0 continue if kind != "CLIENT": continue while len(parts) < 10: parts.append("") mac = self.normalize_wol_mac(parts[1]) if not mac: continue ip_addr = parts[2] name = parts[3] static_ip = parts[4] iface = parts[5] source = parts[6] try: rx_bytes = int(float(parts[7] or 0)) except ValueError: rx_bytes = 0 try: tx_bytes = int(float(parts[8] or 0)) except ValueError: tx_bytes = 0 try: total_bytes = int(float(parts[9] or (rx_bytes + tx_bytes))) except ValueError: total_bytes = rx_bytes + tx_bytes clients.append( { "mac": mac, "ip": ip_addr, "name": name, "static_ip": static_ip, "iface": iface, "source": source, "rx_bytes": rx_bytes, "tx_bytes": tx_bytes, "total_bytes": total_bytes, "has_static": bool(static_ip), } ) clients = accumulate_traffic_clients(row["id"], clients) clients.sort( key=lambda item: ( -int(item.get("total_bytes") or 0), str(item.get("name") or "").lower(), str(item.get("ip") or ""), str(item.get("mac") or ""), ) ) return { "clients": clients, "traffic_source": traffic_source, "traffic_supported": traffic_source != "none", "flow_hits": flow_hits, } def reset_router_client_traffic(self, row, ssh_password=""): script = r""" set -eu install_conntrack() { pkg="" if command -v opkg >/dev/null 2>&1; then opkg update >/dev/null 2>&1 || true for pkg in conntrack conntrack-tools; do opkg install "$pkg" >/dev/null 2>&1 && return 0 done fi if command -v apk >/dev/null 2>&1; then apk update >/dev/null 2>&1 || true for pkg in conntrack conntrack-tools; do apk add "$pkg" >/dev/null 2>&1 && return 0 done fi return 1 } did_reset=0 conntrack_failed=0 if command -v nft >/dev/null 2>&1; then nft delete table inet owrt_traffic >/dev/null 2>&1 || true did_reset=1 fi if ! command -v conntrack >/dev/null 2>&1; then install_conntrack || true fi if ! command -v conntrack >/dev/null 2>&1; then echo "Не удалось найти или установить conntrack на роутере. Попробуй вручную: opkg install conntrack" >&2 exit 127 fi if ! conntrack -F >/dev/null 2>&1; then echo "Команда conntrack найдена, но очистить таблицу не удалось." >&2 exit 1 fi echo "Трафик сброшен. Conntrack очищен, новые счётчики начнут копиться заново." """ output = self.run_router_ssh_script(row, script, timeout=75, ssh_password=ssh_password).strip() return { "message": output or "Трафик сброшен. Conntrack очищен, новые счётчики начнут копиться заново." } def reset_router_client_traffic(self, row, ssh_password=""): script = r""" set -eu install_conntrack() { pkg="" if command -v opkg >/dev/null 2>&1; then opkg update >/dev/null 2>&1 || true for pkg in conntrack conntrack-tools; do opkg install "$pkg" >/dev/null 2>&1 && return 0 done fi if command -v apk >/dev/null 2>&1; then apk update >/dev/null 2>&1 || true for pkg in conntrack conntrack-tools; do apk add "$pkg" >/dev/null 2>&1 && return 0 done fi return 1 } did_reset=0 conntrack_failed=0 if command -v nft >/dev/null 2>&1; then nft delete table inet owrt_traffic >/dev/null 2>&1 || true did_reset=1 fi if ! command -v conntrack >/dev/null 2>&1; then install_conntrack || true fi if command -v conntrack >/dev/null 2>&1; then if conntrack -F >/dev/null 2>&1; then did_reset=1 else conntrack_failed=1 fi fi [ "$did_reset" -eq 1 ] || { echo "Failed to reset traffic counters: neither conntrack nor nftables could be cleared." >&2 exit 1 } if [ "$conntrack_failed" -eq 1 ]; then echo "Traffic counters partially reset: nft client counters were cleared, but conntrack flush failed." else echo "Traffic counters reset: conntrack flushed and nft client counters cleared." fi """ output = self.run_router_ssh_script(row, script, timeout=75, ssh_password=ssh_password).strip() clear_traffic_counters(row["id"]) return { "message": output or "Traffic counters reset: conntrack flushed and nft client counters cleared." } def ensure_router_wol_support(self, row, ssh_password=""): script = r""" set -eu has_wol_tool() { command -v etherwake >/dev/null 2>&1 || command -v wakeonlan >/dev/null 2>&1 || command -v wol >/dev/null 2>&1 } install_pkg() { pkg="$1" case "$PKG_MANAGER" in opkg) opkg install "$pkg" >/dev/null 2>&1 ;; apk) apk add "$pkg" >/dev/null 2>&1 ;; *) return 1 ;; esac } if has_wol_tool; then echo "WOL tool already present on router" exit 0 fi PKG_MANAGER="" if command -v apk >/dev/null 2>&1; then PKG_MANAGER="apk" elif command -v opkg >/dev/null 2>&1; then PKG_MANAGER="opkg" fi [ -n "$PKG_MANAGER" ] || { echo "No package manager found to install WOL support." >&2 exit 1 } case "$PKG_MANAGER" in opkg) opkg update >/dev/null 2>&1 || true ;; apk) apk update >/dev/null 2>&1 || true ;; esac install_pkg luci-app-wol || true install_pkg etherwake || true install_pkg wakeonlan || true install_pkg wol || true if has_wol_tool; then echo "WOL support installed via $PKG_MANAGER" exit 0 fi echo "WOL package installation finished, but no etherwake/wakeonlan/wol command is available." >&2 exit 1 """ return self.run_router_ssh_script(row, script, timeout=75, ssh_password=ssh_password).strip() def send_router_wol_packet(self, row, mac, iface="", ssh_password=""): clean_mac = self.normalize_wol_mac(mac) if not clean_mac: raise RuntimeError("invalid MAC address") script = r""" set -eu mac="$1" iface="${2:-}" if command -v etherwake >/dev/null 2>&1; then if [ -n "$iface" ]; then etherwake -i "$iface" "$mac" else etherwake "$mac" fi echo "Wake packet sent via etherwake" exit 0 fi if command -v wakeonlan >/dev/null 2>&1; then wakeonlan "$mac" echo "Wake packet sent via wakeonlan" exit 0 fi if command -v wol >/dev/null 2>&1; then wol "$mac" echo "Wake packet sent via wol" exit 0 fi echo "No WOL tool found on router. Install etherwake, wakeonlan or wol." >&2 exit 127 """ try: output = self.run_router_ssh_script( row, script, [clean_mac, str(iface or "")], timeout=12, ssh_password=ssh_password, ) except RuntimeError as exc: if "No WOL tool found on router" not in str(exc): raise install_output = self.ensure_router_wol_support(row, ssh_password=ssh_password) output = self.run_router_ssh_script( row, script, [clean_mac, str(iface or "")], timeout=18, ssh_password=ssh_password, ) if install_output: output = (install_output + "\n" + output).strip() return {"mac": clean_mac, "iface": str(iface or ""), "output": output.strip() or "Wake packet sent"} def vps_shell_args(self): env = os.environ.copy() env["TERM"] = "xterm-256color" shell = env.get("SHELL", "") if not shell: shell = "/bin/bash" if Path("/bin/bash").exists() else "/bin/sh" args = [shell] if os.path.basename(shell) in {"bash", "sh", "ash", "dash", "zsh", "ksh"}: args.append("-l") return env, args def spawn_terminal_pty(self, env, args, unavailable_message, open_message, exec_name): try: import pty except Exception as exc: raise RuntimeError(f"{unavailable_message}: {exc}") try: pid, fd = pty.fork() except Exception as exc: raise RuntimeError(f"{open_message}: {exc}") if pid == 0: try: os.execvpe(args[0], args, env) except Exception as exc: print(f"{exec_name} start failed: {exc}", flush=True) os._exit(127) return pid, fd def ssh_http_reader(self, sid): session = SSH_HTTP_SESSIONS.get(sid) if not session: return fd = session["fd"] try: while True: ready, _, _ = select.select([fd], [], [], 0.5) if fd not in ready: with session["lock"]: if not session["alive"]: break continue try: data = os.read(fd, 4096) except OSError as exc: with session["lock"]: session["buffer"].append(f"\r\n[{session.get('label', 'Terminal')} read error: {exc}]\r\n") break if not data: break with session["lock"]: session["buffer"].append(data.decode("utf-8", errors="replace")) session["last_seen"] = now_ts() finally: with session["lock"]: session["alive"] = False session["buffer"].append("\r\n[" + session.get("close_notice", "SSH соединение закрыто") + "]\r\n") try: os.close(fd) except OSError: pass try: os.waitpid(session["pid"], os.WNOHANG) except OSError: pass def start_ssh_http_session(self, router_id, port): env, args = self.ssh_args(port) pid, fd = self.spawn_terminal_pty(env, args, "pty недоступен на VPS", "не удалось открыть SSH pty", "ssh") sid = secrets.token_urlsafe(24) session = { "id": sid, "router_id": router_id, "port": port, "pid": pid, "fd": fd, "buffer": [], "alive": True, "created": now_ts(), "last_seen": now_ts(), "lock": threading.Lock(), "label": "SSH", "close_notice": "SSH соединение закрыто", } with SSH_HTTP_LOCK: SSH_HTTP_SESSIONS[sid] = session threading.Thread(target=self.ssh_http_reader, args=(sid,), daemon=True).start() return session def start_vps_http_session(self): env, args = self.vps_shell_args() pid, fd = self.spawn_terminal_pty(env, args, "pty недоступен на VPS", "не удалось открыть VPS pty", "vps-shell") sid = secrets.token_urlsafe(24) session = { "id": sid, "router_id": VPS_TERMINAL_ID, "port": 0, "pid": pid, "fd": fd, "buffer": [], "alive": True, "created": now_ts(), "last_seen": now_ts(), "lock": threading.Lock(), "label": "VPS terminal", "close_notice": "VPS terminal закрыт", } with SSH_HTTP_LOCK: SSH_HTTP_SESSIONS[sid] = session threading.Thread(target=self.ssh_http_reader, args=(sid,), daemon=True).start() return session def ssh_http_session(self): router_id = self.router_id_from_path("/api/ssh/") if self.ssh_token_ok(router_id): allowed = True elif is_vps_terminal_id(router_id): allowed = self.owner_ok() else: allowed = self.router_access_allowed(router_id, "B") if not allowed: self.send_json(403, {"ok": False, "error": "not authorized"}) return if is_vps_terminal_id(router_id): try: session = self.start_vps_http_session() query = self.query() set_pty_size(session["fd"], query.get("rows", ["24"])[0], query.get("cols", ["80"])[0]) self.send_json(200, {"ok": True, "sid": session["id"], "router_id": router_id, "mode": "local-shell"}) except Exception as exc: self.send_json(500, {"ok": False, "error": str(exc)}) return with self.app.conn() as conn: row = get_active_router(conn, router_id) if not row: self.send_json(404, {"ok": False, "error": "router not found"}) return port = int(row["ssh_entry_port"] or 0) if port <= 0: self.send_json(400, {"ok": False, "error": "router has no ssh_entry_port"}) return try: session = self.start_ssh_http_session(router_id, port) query = self.query() set_pty_size(session["fd"], query.get("rows", ["24"])[0], query.get("cols", ["80"])[0]) self.send_json(200, {"ok": True, "sid": session["id"], "router_id": router_id, "port": port}) except Exception as exc: self.send_json(500, {"ok": False, "error": str(exc)}) def ssh_http_read(self, sid): with SSH_HTTP_LOCK: session = SSH_HTTP_SESSIONS.get(sid) if not session: self.send_json(404, {"ok": False, "error": "terminal session not found", "alive": False, "data": ""}) return with session["lock"]: data = "".join(session["buffer"]) session["buffer"].clear() alive = bool(session["alive"]) session["last_seen"] = now_ts() self.send_json(200, {"ok": True, "alive": alive, "data": data}) def ssh_http_write(self, sid, payload=None): with SSH_HTTP_LOCK: session = SSH_HTTP_SESSIONS.get(sid) if not session: self.send_json(404, {"ok": False, "error": "terminal session not found"}) return if payload is None: payload = self.read_payload() data = payload.get("data", "") if not isinstance(data, str): data = str(data) with session["lock"]: alive = bool(session["alive"]) fd = session["fd"] if not alive: self.send_json(409, {"ok": False, "error": "terminal session closed"}) return try: write_pty_all(fd, data) self.send_json(200, {"ok": True}) except Exception as exc: self.send_json(500, {"ok": False, "error": str(exc)}) def ssh_http_resize(self, sid, payload=None): with SSH_HTTP_LOCK: session = SSH_HTTP_SESSIONS.get(sid) if not session: self.send_json(404, {"ok": False, "error": "terminal session not found"}) return if payload is None: payload = self.read_payload() ok = set_pty_size(session["fd"], payload.get("rows", 24), payload.get("cols", 80)) self.send_json(200, {"ok": bool(ok)}) def ssh_http_write_short(self): payload = self.read_payload() sid = payload.get("sid", "") if not sid: sid = self.query().get("sid", [""])[0] if not sid: self.send_json(400, {"ok": False, "error": "terminal sid is empty"}) return self.ssh_http_write(sid, payload) def ssh_http_close(self, sid): with SSH_HTTP_LOCK: session = SSH_HTTP_SESSIONS.pop(sid, None) if not session: self.send_json(200, {"ok": True}) return with session["lock"]: session["alive"] = False try: os.kill(session["pid"], signal.SIGHUP) except OSError: pass self.send_json(200, {"ok": True}) def ssh_session_action(self, path): parts = path.strip("/").split("/") if len(parts) != 4 or parts[0] != "api" or parts[1] != "ssh-session": self.send_json(404, {"ok": False, "error": "terminal route not found"}) return sid = urllib.parse.unquote(parts[2]) action = parts[3] with SSH_HTTP_LOCK: session = SSH_HTTP_SESSIONS.get(sid) if not session: self.send_json(404, {"ok": False, "error": "terminal session not found"}) return router_id = str(session.get("router_id") or "") if is_vps_terminal_id(router_id): allowed = self.owner_ok() else: allowed = self.router_access_allowed(router_id, "B") if not allowed: self.send_json(403, {"ok": False, "error": "not authorized"}) return if action == "read": self.ssh_http_read(sid) return if action == "write": self.ssh_http_write(sid) return if action == "resize": self.ssh_http_resize(sid) return if action == "close": self.ssh_http_close(sid) return self.send_json(404, {"ok": False, "error": "terminal action not found"}) def run_terminal_session(self, env, args, unavailable_message, open_message, exec_name, error_label): ensure_state() try: pid, fd = self.spawn_terminal_pty(env, args, unavailable_message, open_message, exec_name) except Exception as exc: ws_send_frame(self.connection, f"{exc}\r\n") return ws_send_frame(self.connection, "") try: while True: ready, _, _ = select.select([self.connection, fd], [], [], 0.25) if fd in ready: try: data = os.read(fd, 4096) except OSError: break if not data: break ws_send_frame(self.connection, data.decode("utf-8", errors="replace")) if self.connection in ready: try: opcode, payload = ws_read_frame(self.connection) except Exception: break if opcode == 8: break if opcode == 9: ws_send_frame(self.connection, payload, opcode=10) continue if opcode == 1 and payload: resize = parse_resize_payload(payload) if resize: set_pty_size(fd, resize[0], resize[1]) continue if opcode in (1, 2) and payload: write_pty_all(fd, payload) except Exception as exc: try: ws_send_frame(self.connection, f"\r\n[{error_label}: {exc}]\r\n") except Exception: pass finally: try: os.kill(pid, signal.SIGHUP) except OSError: pass try: os.close(fd) except OSError: pass try: os.waitpid(pid, os.WNOHANG) except OSError: pass def run_ssh_session(self, router_id, port): env, args = self.ssh_args(port) self.run_terminal_session(env, args, "pty недоступен на VPS", "не удалось открыть SSH pty", "ssh", "SSH error") def run_vps_terminal_session(self): env, args = self.vps_shell_args() self.run_terminal_session(env, args, "pty недоступен на VPS", "не удалось открыть VPS pty", "vps-shell", "VPS terminal error") def backup_download(self): with tempfile.TemporaryDirectory(prefix="owrt-hub-download-") as tmp_name: filename = backup_filename() archive = Path(tmp_name) / filename create_hub_backup(archive, self.app.db_path) body = archive.read_bytes() self.send_bytes( 200, body, "application/gzip", [("Content-Disposition", f'attachment; filename="{filename}"')], ) def backup_restore(self): try: payload = self.read_payload() archive_b64 = str(payload.get("archive_b64") or "") if not archive_b64: self.send_json(400, {"ok": False, "error": "archive_b64 is empty"}) return if len(archive_b64) > 80 * 1024 * 1024: self.send_json(413, {"ok": False, "error": "backup archive is too large"}) return raw = base64.b64decode(archive_b64.encode("ascii"), validate=True) with tempfile.TemporaryDirectory(prefix="owrt-hub-upload-") as tmp_name: archive = Path(tmp_name) / "restore.tar.gz" archive.write_bytes(raw) result = restore_hub_backup( archive, self.app.db_path, payload.get("vps_host", ""), payload.get("public_url", ""), ) self.app.session_token = session_token() self.app.agent_token = agent_token() add_notification( "backup-restore", "Hub backup восстановлен", "Состояние Hub восстановлено из резервной копии. Перезапусти owrt-remote на VPS для чистого применения.", "warn", result.get("warnings", []), {"rewritten": result.get("rewritten", {})}, ) self.send_json(200, {"ok": True, **result}) except Exception as exc: self.send_json(400, {"ok": False, "error": str(exc)}) def router_endpoints_rewrite(self): try: payload = self.read_payload() vps_host = str(payload.get("vps_host") or "").strip() public_url = str(payload.get("public_url") or "").strip() apply_live = bool(payload.get("apply_live", True)) ssh_password = str(payload.get("ssh_password") or "") if not vps_host and not public_url: self.send_json(400, {"ok": False, "error": "vps_host or public_url is required"}) return with self.app.conn() as conn: rewritten = rewrite_router_endpoints( conn, vps_host=vps_host, public_url=public_url, preserve_vps_fallback=bool(payload.get("preserve_vps_fallback", True)), ) rows = list_router_rows(conn) total = len(rows) auto_apply = { "requested": bool(apply_live), "attempted": 0, "confirmed": 0, "applied": 0, "unreachable": 0, "failed": 0, "results": [], } if apply_live: for row in rows: result = self.apply_router_rebind_via_ssh(row, ssh_password=ssh_password, request_origin=self.request_origin()) auto_apply["results"].append(result) auto_apply["attempted"] += 1 status = str(result.get("status") or "") if status == "confirmed": auto_apply["confirmed"] += 1 auto_apply["applied"] += 1 elif status == "applied": auto_apply["applied"] += 1 elif status == "unreachable": auto_apply["unreachable"] += 1 else: auto_apply["failed"] += 1 add_notification( "router-endpoints-rewrite", "Router endpoints updated", "Hub updated router endpoint settings and tried to push the new config over SSH to reachable routers.", "warn", [ f"rewritten: {', '.join(f'{k}={v}' for k, v in rewritten.items()) or 'none'}", f"auto-apply confirmed: {auto_apply['confirmed']}/{total}", f"auto-apply applied: {auto_apply['applied']}/{total}", f"auto-apply unreachable: {auto_apply['unreachable']}/{total}", f"auto-apply failed: {auto_apply['failed']}/{total}", ], {"rewritten": rewritten, "routers": total, "auto_apply": auto_apply}, ) self.send_json(200, {"ok": True, "rewritten": rewritten, "routers": total, "auto_apply": auto_apply}) except Exception as exc: self.send_json(400, {"ok": False, "error": str(exc)}) def do_GET(self): path = self.parsed().path if path == "/health": self.send_json(200, {"ok": True}) return if path == "/favicon.ico": self.send_local_asset(FAVICON_ICO_FILE, "image/x-icon") return if path == "/favicon-32.png": self.send_local_asset(FAVICON_PNG_32_FILE, "image/png") return if path == "/favicon-192.png": self.send_local_asset(FAVICON_PNG_192_FILE, "image/png") return if path == "/favicon-512.png": self.send_local_asset(FAVICON_PNG_512_FILE, "image/png") return if path == "/apple-touch-icon.png": self.send_local_asset(APPLE_TOUCH_ICON_FILE, "image/png") return if path == "/favicon.svg": self.send_bytes(200, favicon_svg().encode("utf-8"), "image/svg+xml; charset=utf-8") return if path == "/sw.js": self.send_bytes( 200, service_worker_js().encode("utf-8"), "application/javascript; charset=utf-8", [("Service-Worker-Allowed", "/")], ) return if path == "/manifest.webmanifest": self.send_bytes(200, web_manifest_json().encode("utf-8"), "application/manifest+json; charset=utf-8") return if path == "/api/auth/meta": self.auth_meta() return if path == "/oauth/github/start": self.start_social_login("github") return if path == "/oauth/vk/start": self.start_social_login("vk") return if path == "/oauth/github/callback": self.finish_social_callback("github") return if path == "/oauth/vk/callback": self.finish_social_callback("vk") return if path.startswith("/.well-known/acme-challenge/"): self.serve_acme_challenge(path) return if path == "/login": query = self.query() force_local_captcha = sanitize_captcha_mode((query.get("captcha") or [""])[-1]) == CAPTCHA_MODE_DIGITS login_error = "" if force_local_captcha and ((query.get("reason") or [""])[-1] == "recaptcha-timeout"): login_error = "Google reCAPTCHA зависла или недоступна с VPS. Для входа ниже включена локальная цифровая капча." self.send_bytes( 200, login_html(login_error, force_local_captcha=force_local_captcha).encode("utf-8"), "text/html; charset=utf-8", ) return if path == "/ssh-key-manual/": self.send_bytes(200, ssh_key_manual_html().encode("utf-8"), "text/html; charset=utf-8") return if path == "/logout": revoke_hub_session(token=self.current_session_token()) self.redirect("/login", [("Set-Cookie", self.clear_session_cookie())]) return if path == "/vps-terminal": self.redirect("/vps-terminal/") return if path == "/vps-terminal/": self.vps_terminal_page() return if path.startswith("/api/ssh/") and path.endswith("/check"): self.ssh_check() return if path.startswith("/api/ssh/") and path.endswith("/session"): self.ssh_http_session() return if path == "/api/ssh-session-write": self.ssh_http_write_short() return if path.startswith("/api/ssh-session/"): self.ssh_session_action(path) return if path.startswith("/ssh-ws/"): self.ssh_ws() return if path.startswith("/ssh/"): self.ssh_page() return if path.startswith("/access/"): self.proxy_access(path) return if self.maybe_proxy_luci_absolute(path): return if not self.require_admin(): return if path == "/" or path == "": extra_headers = [] session_token_value = self.current_session_token() profile = self.current_account_profile(touch=False) if self.legacy_admin_ok() and not self.current_hub_session(touch=False): session_token_value, session = make_hub_session(current_username(), self.client_ip(), self.headers.get("User-Agent", "")) add_notification( "login", "Вход в Hub", f"{session.get('client', 'устройство')} · IP {session.get('ip', 'unknown')}", "warn", [session.get("user_agent", "")], {"session_id": session.get("id", ""), "ip": session.get("ip", ""), "legacy": True}, ) extra_headers.append(("Set-Cookie", self.session_cookie(session_token_value))) with self.app.conn() as conn: routers = self.visible_routers(conn, profile) self.send_bytes( 200, dashboard_html( routers, (profile or {}).get("username") or current_username(), list_hub_sessions(session_token_value, self.current_or_owner_session_scope()), list_notifications(0, 40) if not profile or profile.get("is_owner") else [], ).encode("utf-8"), "text/html; charset=utf-8", extra_headers, ) return if path == "/api/routers": with self.app.conn() as conn: routers = self.visible_routers(conn) self.send_json(200, {"routers": routers}) return if path == "/api/backup/download": if not self.require_owner(): return self.backup_download() return if path == "/api/sessions": self.send_json(200, {"sessions": list_hub_sessions(self.current_session_token(), self.current_or_owner_session_scope())}) return if path == "/api/notifications": if not self.require_owner(json_mode=True): return query = self.query() self.send_json( 200, { "notifications": list_notifications( query.get("after", ["0"])[0], query.get("limit", ["60"])[0], query.get("after_serial", ["0"])[0], ), "serial": latest_notification_serial(), }, ) return if path == "/api/notifications/wait": if not self.require_owner(json_mode=True): return query = self.query() self.send_json( 200, { "notifications": wait_for_notifications( query.get("after_serial", ["0"])[0], query.get("timeout", ["25"])[0], query.get("limit", ["60"])[0], ), "serial": latest_notification_serial(), }, ) return if path == "/api/push/vapid-public-key": if not self.require_owner(json_mode=True): return backend = web_push_backend_status() if not backend.get("ready"): self.send_json( 503, { "ok": False, "error": backend.get("error") or "На VPS не готов Web Push backend.", "reason": backend.get("reason", ""), "subject": backend.get("subject", ""), "publicKey": backend.get("public_key", ""), }, ) return self.send_json(200, {"ok": True, "publicKey": backend.get("public_key", ""), "subject": backend.get("subject", "")}) return if path == "/api/push/status": if not self.require_owner(json_mode=True): return self.send_json(200, push_status_snapshot()) return if path.startswith("/api/router/") and path.endswith("/wol/devices"): parts = path.strip("/").split("/") if len(parts) != 5 or parts[0] != "api" or parts[1] != "router" or parts[3] != "wol" or parts[4] != "devices": self.send_text(404, "not found") return router_id = urllib.parse.unquote(parts[2]) if not self.require_router_access(router_id, "G", json_mode=True): return with self.app.conn() as conn: row = get_active_router(conn, router_id) if not row: self.send_json(404, {"ok": False, "error": "router not found"}) return try: devices = self.discover_router_wol_devices(row) self.send_json(200, {"ok": True, "router_id": router_id, "devices": devices}) except Exception as exc: self.send_json(400, {"ok": False, "error": str(exc), "router_id": router_id, "devices": []}) return if path.startswith("/router/"): if "/notes-media/" in path: self.router_note_media_page(path) return if path.endswith("/notes"): self.router_notes_page(self.router_id_from_path("/router/")) return self.router_asset(path) return self.send_text(404, "not found") def do_HEAD(self): self.do_GET() def do_POST(self): path = self.parsed().path if path == "/login": self.login() return if path == "/api/login/passkey/begin": self.begin_passkey_login() return if path == "/api/login/passkey/finish": self.finish_passkey_login() return if path == "/api/login/ssh/begin": self.begin_ssh_login() return if path == "/api/login/ssh/finish": self.finish_ssh_login() return if path == "/api/ssh-session-write": self.ssh_http_write_short() return if path.startswith("/api/ssh-session/"): self.ssh_session_action(path) return if path == "/api/heartbeat": if not self.agent_ok(): self.send_json(401, {"ok": False, "error": "bad agent token"}) return try: payload = self.read_payload() with self.app.conn() as conn: router = heartbeat(conn, payload) if router and router.pop("_became_online", False): notify_router_online(router) xray_reload = None if router and router.pop("_xray_reload_required", False): try: xray_reload = reload_vps_xray(self.app.db_path) except Exception as exc: self.log_message("heartbeat xray reload error: %s", exc) xray_reload = {"error": str(exc)} xray_restart = None if payload.get("event") == "wan-reconnect": try: xray_restart = maybe_restart_vps_xray_after_wan_reconnect(router["id"]) except Exception as exc: self.log_message("wan reconnect xray restart error: %s", exc) xray_restart = {"error": str(exc)} self.send_json( 200, { "ok": True, "router": router, "hub_update": canonical_router_hub_update(router, self.app.public_url, self.request_origin()), "xray_reload": xray_reload, "xray_restart": xray_restart, }, ) except Exception as exc: self.log_message("heartbeat error: %s", exc) self.send_json(400, {"ok": False, "error": str(exc)}) return if path.startswith("/access/"): self.proxy_access(path) return if self.maybe_proxy_luci_absolute(path): return if not self.require_admin(): return if path == "/api/auth": if not self.require_owner(): return self.update_auth() return if path == "/api/auth/users/save": if not self.require_owner(json_mode=True): return self.save_delegated_user() return if path == "/api/auth/users/delete": if not self.require_owner(json_mode=True): return self.delete_delegated_user() return if path == "/api/auth/users/revoke-sessions": if not self.require_owner(json_mode=True): return self.revoke_delegated_user_sessions() return if path == "/api/auth/totp/setup": if not self.require_owner(json_mode=True): return self.totp_setup() return if path == "/api/auth/totp/enable": if not self.require_owner(json_mode=True): return self.totp_enable() return if path == "/api/auth/totp/disable": if not self.require_owner(json_mode=True): return self.totp_disable() return if path == "/api/auth/passkeys/begin": if not self.require_owner(json_mode=True): return self.begin_passkey_registration() return if path == "/api/auth/passkeys/finish": if not self.require_owner(json_mode=True): return self.finish_passkey_registration() return if path == "/api/auth/passkeys/remove": if not self.require_owner(json_mode=True): return self.remove_passkey() return if path == "/api/auth/ssh-keys/add": if not self.require_owner(json_mode=True): return self.add_ssh_key() return if path == "/api/auth/ssh-keys/remove": if not self.require_owner(json_mode=True): return self.remove_ssh_key() return if path == "/api/auth/social/github/save": if not self.require_owner(json_mode=True): return self.save_social_provider_config("github") return if path == "/api/auth/social/vk/save": if not self.require_owner(json_mode=True): return self.save_social_provider_config("vk") return if path == "/api/auth/social/github/link": if not self.require_owner(json_mode=True): return self.begin_social_link("github") return if path == "/api/auth/social/vk/link": if not self.require_owner(json_mode=True): return self.begin_social_link("vk") return if path == "/api/auth/social/github/unlink": if not self.require_owner(json_mode=True): return self.unlink_social_account("github") return if path == "/api/auth/social/vk/unlink": if not self.require_owner(json_mode=True): return self.unlink_social_account("vk") return if path == "/api/session/client-hint": payload = self.read_payload() session = update_hub_session_client_hint(self.current_session_token(), payload.get("client_hint", "")) if not session: self.send_json(400, {"ok": False, "error": "session not found"}) return self.send_json(200, {"ok": True, "client": session.get("client", ""), "hint": normalize_client_hint(payload.get("client_hint", ""))}) return if path == "/api/session/revoke": payload = self.read_payload() session_id = payload.get("id", "") if not session_id: self.send_text(400, "session id is empty") return current = self.current_hub_session(touch=False) if current and session_id == current.get("id"): self.send_text(400, "Текущую сессию заверши кнопкой Выйти") return if not self.owner_ok(): session_allowed = next( ( session for session in list_hub_sessions(self.current_session_token(), self.current_or_owner_session_scope()) if session.get("id") == session_id ), None, ) if not session_allowed: self.send_json(403, {"ok": False, "error": "not authorized"}) return removed = revoke_hub_session(session_id=session_id) self.send_json(200, {"ok": True, "removed": removed}) return if path == "/api/session/revoke-others": current = self.current_hub_session(touch=False) current_id = current.get("id", "") if current else "" removed = 0 for session in list_hub_sessions(self.current_session_token(), self.current_or_owner_session_scope()): if session.get("id") != current_id: removed += revoke_hub_session(session_id=session.get("id", "")) self.send_json(200, {"ok": True, "removed": removed}) return if path == "/api/notifications/clear": if not self.require_owner(json_mode=True): return clear_notifications() self.send_json(200, {"ok": True}) return if path == "/api/backup/restore": if not self.require_owner(json_mode=True): return self.backup_restore() return if path == "/api/routers/rewrite-endpoints": if not self.require_owner(json_mode=True): return self.router_endpoints_rewrite() return if path == "/api/push/subscribe": if not self.require_owner(json_mode=True): return payload = {} session = self.current_hub_session(touch=False) or {} username = session.get("username", current_username()) user_agent = self.headers.get("User-Agent", "") client_ip = self.client_ip() try: payload = self.read_payload() subscription = save_push_subscription( payload, username, client_ip, user_agent, ) test_payload = { "title": APP_NAME, "body": "Push включён на этом устройстве.", "tag": "owrt-push-test", "url": "/", "kind": "push-test", "ts": now_ts(), } test_payload["web_push"] = 8030 test_payload["notification"] = { "title": test_payload["title"], "body": test_payload["body"], "tag": test_payload["tag"], "navigate": test_payload["url"], "silent": False, } result = send_web_push(subscription, test_payload) remember_push_delivery( test_payload, [ { "client": subscription.get("client") or "браузер", "endpoint_host": push_endpoint_host(subscription.get("endpoint", "")), "result": result, } ], "ok" if result == "ok" else "partial", ) if result == "gone": remove_push_subscription(subscription.get("endpoint", "")) if result != "ok": self.send_json(503, {"ok": False, "error": push_result_message(result, subscription), "delivery": result, "subscription": {"id": subscription.get("id"), "client": subscription.get("client")}}) return self.send_json(200, {"ok": True, "delivery": result, "subscription": {"id": subscription.get("id"), "client": subscription.get("client")}}) except Exception as exc: detail = " ".join(str(exc).split())[:160] or exc.__class__.__name__ client = client_label(user_agent, normalize_client_hint((payload or {}).get("client_hint", ""))) remember_push_delivery( { "title": APP_NAME, "body": "Не удалось сохранить push-подписку.", "tag": "owrt-push-test", "url": "/", "kind": "push-test", "ts": now_ts(), }, [ { "client": client or "браузер", "endpoint_host": push_endpoint_host((payload or {}).get("endpoint", "")), "result": f"subscribe_error:{detail}", } ], "subscribe_error", ) self.log_message("push subscribe error: %s", detail) self.send_json(400, {"ok": False, "error": str(exc)}) return if path == "/api/push/unsubscribe": if not self.require_owner(json_mode=True): return try: payload = self.read_payload() removed = remove_push_subscription(payload.get("endpoint", "")) self.send_json(200, {"ok": True, "removed": removed}) except Exception as exc: self.send_json(400, {"ok": False, "error": str(exc)}) return if path == "/api/xray/reload": if not self.require_owner(json_mode=True): return try: result = reload_vps_xray(self.app.db_path) self.send_json(200, {"ok": True, **result}) except Exception as exc: self.send_text(500, str(exc)) return if path == "/api/xray/restart": if not self.require_owner(json_mode=True): return try: result = restart_vps_xray() self.send_json(200, {"ok": True, **result}) except Exception as exc: self.send_text(500, str(exc)) return if path == "/api/router": if not self.require_add_router(json_mode=True): return try: current = self.current_account_profile(touch=False) or {} payload = self.read_payload() router_id = clean_router_id(payload.get("id")) entry_port = int(payload.get("entry_port") or 0) ssh_entry_port = int(payload.get("ssh_entry_port") or (entry_port + 1000)) if entry_port <= 0: self.send_text(400, "entry_port должен быть больше 0") return with self.app.conn() as conn: existing = get_router(conn, router_id) if existing and not router_deleted(existing): self.send_text( 409, f"Router ID '{router_id}' уже есть. Для второго роутера укажи новый ID, например node-2 или main123.", ) return port_owner = get_router_by_any_port(conn, entry_port, router_id) if port_owner: self.send_text( 409, f"entry_port {entry_port} уже занят роутером '{port_owner['id']}'. Для следующего роутера поставь другой порт, например {entry_port + 10}.", ) return ssh_port_owner = get_router_by_any_port(conn, ssh_entry_port, router_id) if ssh_port_owner: self.send_text( 409, f"ssh_entry_port {ssh_entry_port} уже занят роутером '{ssh_port_owner['id']}'. Поставь entry_port так, чтобы entry_port + 1000 был свободен.", ) return payload["ssh_entry_port"] = ssh_entry_port row = upsert_router(conn, payload) router = row_to_router(row) if current and not current.get("is_owner"): grant_delegated_router_flag(load_auth(), current.get("username", ""), router_id, "G") self.send_json(200, {"ok": True, "router": router, "auth": self.build_auth_meta()}) except Exception as exc: self.send_text(400, str(exc)) return if path.startswith("/api/router/") and path.endswith("/wol/devices"): parts = path.strip("/").split("/") if len(parts) != 5 or parts[0] != "api" or parts[1] != "router" or parts[3] != "wol" or parts[4] != "devices": self.send_text(404, "not found") return router_id = urllib.parse.unquote(parts[2]) if not self.require_router_access(router_id, "G", json_mode=True): return try: payload = self.read_payload() with self.app.conn() as conn: row = get_active_router(conn, router_id) if not row: self.send_json(404, {"ok": False, "error": "router not found"}) return devices = self.discover_router_wol_devices(row, payload.get("ssh_password", "")) self.send_json(200, {"ok": True, "router_id": router_id, "devices": devices}) except Exception as exc: self.send_json(400, {"ok": False, "error": str(exc), "router_id": router_id, "devices": []}) return if path.startswith("/api/router/") and path.endswith("/traffic/clients"): parts = path.strip("/").split("/") if len(parts) != 5 or parts[0] != "api" or parts[1] != "router" or parts[3] != "traffic" or parts[4] != "clients": self.send_text(404, "not found") return router_id = urllib.parse.unquote(parts[2]) if not self.require_router_access(router_id, "G", json_mode=True): return try: payload = self.read_payload() with self.app.conn() as conn: row = get_active_router(conn, router_id) if not row: self.send_json(404, {"ok": False, "error": "router not found"}) return result = self.discover_router_client_traffic(row, payload.get("ssh_password", "")) self.send_json(200, {"ok": True, "router_id": router_id, **result}) except Exception as exc: self.send_json( 400, { "ok": False, "error": str(exc), "router_id": router_id, "clients": [], "traffic_source": "none", "traffic_supported": False, "flow_hits": 0, }, ) return if path.startswith("/api/router/") and path.endswith("/traffic/reset"): parts = path.strip("/").split("/") if len(parts) != 5 or parts[0] != "api" or parts[1] != "router" or parts[3] != "traffic" or parts[4] != "reset": self.send_text(404, "not found") return router_id = urllib.parse.unquote(parts[2]) if not self.require_router_access(router_id, "G", json_mode=True): return try: payload = self.read_payload() with self.app.conn() as conn: row = get_active_router(conn, router_id) if not row: self.send_json(404, {"ok": False, "error": "router not found"}) return result = self.reset_router_client_traffic(row, payload.get("ssh_password", "")) self.send_json(200, {"ok": True, "router_id": router_id, **result}) except Exception as exc: self.send_json(400, {"ok": False, "error": str(exc), "router_id": router_id}) return if path.startswith("/api/router/") and path.endswith("/wol"): parts = path.strip("/").split("/") if len(parts) != 4 or parts[0] != "api" or parts[1] != "router" or parts[3] != "wol": self.send_text(404, "not found") return router_id = urllib.parse.unquote(parts[2]) if not self.require_router_access(router_id, "G", json_mode=True): return try: payload = self.read_payload() with self.app.conn() as conn: row = get_active_router(conn, router_id) if not row: self.send_json(404, {"ok": False, "error": "router not found"}) return result = self.send_router_wol_packet( row, payload.get("mac"), payload.get("iface", ""), payload.get("ssh_password", ""), ) self.send_json(200, {"ok": True, "router_id": router_id, **result}) except Exception as exc: self.send_json(400, {"ok": False, "error": str(exc), "router_id": router_id}) return if path.startswith("/api/router/") and path.endswith("/rename"): try: router_id = urllib.parse.unquote(path.split("/")[3]) if not self.require_router_access(router_id, "G", json_mode=True): return payload = self.read_payload() with self.app.conn() as conn: row = rename_router(conn, router_id, payload.get("name")) self.send_json(200, {"ok": True, "router": row_to_router(row)}) except Exception as exc: self.send_text(400, str(exc)) return if path.startswith("/api/router/") and path.endswith("/notes"): try: router_id = urllib.parse.unquote(path.split("/")[3]) if not self.require_router_access(router_id, "G", json_mode=True): return payload = self.read_payload() with self.app.conn() as conn: row = update_router_notes(conn, router_id, payload.get("notes", "")) router = router_with_access(row_to_router(row), self.current_account_profile()) self.send_json(200, {"ok": True, "router": router}) except Exception as exc: self.send_text(400, str(exc)) return if path.startswith("/router/") and path.endswith("/notes"): self.router_notes_submit(self.router_id_from_path("/router/")) return if path.startswith("/api/router/") and path.endswith("/delete"): router_id = urllib.parse.unquote(path.split("/")[3]) if not self.require_owner(json_mode=True): return deleted = False xray_result = None warnings = [] with self.app.conn() as conn: row = get_router(conn, router_id) if row and not router_deleted(row): ts = now_ts() conn.execute( "update routers set deleted_at = ?, updated_at = ? where id = ?", (ts, ts, router_id), ) conn.commit() deleted = True if deleted: try: xray_result = reload_vps_xray(self.app.db_path) except Exception as exc: warnings.append(f"xray reload skipped: {exc}") self.send_json(200, {"ok": True, "deleted": deleted, "xray": xray_result, "warnings": warnings}) return self.send_text(404, "not found") def router_asset(self, path): parts = path.strip("/").split("/") if len(parts) != 3: self.send_text(404, "not found") return _, router_id, asset = parts router_id = urllib.parse.unquote(router_id) if asset == "config": if not self.require_router_access(router_id, "G"): return elif asset == "xray-client.json": if not self.require_router_access(router_id, "G", json_mode=True): return else: self.send_text(404, "not found") return with self.app.conn() as conn: row = get_active_router(conn, router_id) if not row: self.send_text(404, "router not found") return hub_update, hub_url, config_vps_host = router_current_hub_bundle( row, self.app.public_url, self.request_origin(), self.headers.get("Host", ""), ) if asset == "config": self.send_text( 200, make_openwrt_config( row, hub_url, vps_host_override=config_vps_host, public_url_override=hub_update.get("public_url", ""), ), ) return if asset == "xray-client.json": self.send_json(200, make_router_xray_config(row)) return self.send_text(404, "not found") def proxy_access(self, path): parts = path.split("/", 3) if len(parts) < 3 or not parts[2]: self.redirect("/") return router_id = urllib.parse.unquote(parts[2]) if not self.require_router_access(router_id, "A"): return rest = "/" + parts[3] if len(parts) == 4 else "/" with self.app.conn() as conn: row = get_active_router(conn, router_id) if not row: self.send_text(404, "router not found") return port = int(row["entry_port"] or 0) if port <= 0: self.send_text(400, "router has no entry_port") return query = urllib.parse.parse_qsl(self.parsed().query, keep_blank_values=True) query = list(query) target = rest if query: target += "?" + urllib.parse.urlencode(query) is_static = self.command in ("GET", "HEAD") and is_luci_static_target(target) cache_key = static_cache_key(router_id, target) if is_static else None if cache_key: cached = static_cache_get(cache_key) if cached: status, resp_body, content_type, resp_headers = cached resp_headers.append(("X-OWRT-Static-Cache", "hit")) self.send_raw_bytes(status, resp_body, content_type, resp_headers) return body = self.read_body() if self.command in ("POST", "PUT", "PATCH") else None headers = {} skip = {"host", "connection", "keep-alive", "proxy-authenticate", "proxy-authorization", "te", "trailers", "transfer-encoding", "upgrade", "content-length", "accept-encoding"} for key, value in self.headers.items(): if key.lower() in skip: continue if key.lower() == "cookie": value = clean_forward_cookie(value) if not value: continue elif key.lower() == "referer": value = rewrite_forward_url(value, router_id, port) elif key.lower() == "origin": value = f"http://127.0.0.1:{port}" headers[key] = value headers["Host"] = f"127.0.0.1:{port}" headers["Connection"] = "close" headers["X-Forwarded-Host"] = self.headers.get("Host", "") headers["X-Forwarded-Prefix"] = f"/access/{urllib.parse.quote(router_id)}" headers["X-Forwarded-Proto"] = "http" if body is not None: headers["Content-Length"] = str(len(body)) limiter = None if is_static else router_proxy_limiter(router_id) acquired = False try: if limiter is not None: acquired = limiter.acquire(timeout=PROXY_TIMEOUT) if not acquired: self.send_text(503, "proxy busy: router is handling too many requests") return attempts = 4 if is_static and self.command == "GET" else 1 last_exc = None for attempt in range(attempts): backend = None try: backend = http.client.HTTPConnection("127.0.0.1", port, timeout=PROXY_TIMEOUT) backend.request(self.command, target, body=body, headers=headers) resp = backend.getresponse() resp_status = resp.status resp_raw_headers = resp.getheaders() resp_body = resp.read() content_type = resp.getheader("Content-Type", "") last_exc = None break except Exception as exc: last_exc = exc if attempt + 1 < attempts: time.sleep(0.12 * (attempt + 1)) continue finally: if backend is not None: backend.close() if last_exc is not None: raise last_exc resp_headers = [] prefix = f"/access/{urllib.parse.quote(router_id)}" public_hosts = normalize_public_hosts( self.headers.get("Host", ""), self.app.public_url, "127.0.0.1", f"127.0.0.1:{port}", "localhost", f"localhost:{port}", row["admin_host"], f"{row['admin_host']}:{row['admin_port']}", ) for key, value in resp_raw_headers: low = key.lower() if low in {"cache-control", "connection", "content-length", "content-type", "keep-alive", "proxy-authenticate", "proxy-authorization", "te", "trailers", "transfer-encoding", "upgrade"}: continue if low == "location": value = rewrite_location(value, prefix, port) if low == "set-cookie": value = rewrite_cookie_path(value, "/") resp_headers.append((key, value)) if should_rewrite_body(content_type): resp_body = rewrite_html(resp_body, prefix, content_type, public_hosts) if cache_key and self.command == "GET": static_cache_put( cache_key, resp_status, resp_body, content_type or "application/octet-stream", static_cache_headers(resp_headers), ) if not is_static: resp_headers.append(("Set-Cookie", current_router_cookie(router_id))) if is_static: self.send_raw_bytes( resp_status, resp_body, content_type or "application/octet-stream", resp_headers + [("X-OWRT-Static-Cache", "miss")], ) else: self.send_bytes( resp_status, resp_body, content_type or "application/octet-stream", resp_headers, ) except Exception as exc: self.send_text(502, f"proxy error: {exc}") finally: if acquired: limiter.release() def rewrite_location(value, prefix, port): if value.startswith("/"): return prefix + value for base in (f"http://127.0.0.1:{port}", f"http://localhost:{port}"): if value.startswith(base + "/"): return prefix + value[len(base):] return value def rewrite_cookie_path(value, path): chunks = value.split(";") changed = [] saw_path = False for chunk in chunks: if chunk.strip().lower().startswith("path="): changed.append(" Path=" + path) saw_path = True else: changed.append(chunk) if not saw_path: changed.append(" Path=" + path) return ";".join(changed) def proxy_runtime_script(prefix): prefix_json = json.dumps(prefix) return """""" % prefix_json def protect_luci_resource_root(text): protected = [] def protect_value(match): token = f"__OWRT_REMOTE_LUCI_RESOURCE_{len(protected)}__" protected.append(match.group(0)) return token patterns = ( r"""((?:"resource"|'resource'|resource)\s*[:=]\s*)(["'])(/luci-static/resources)(\2)""", r"""((?:"resource"|'resource'|resource)\s*[:=]\s*)(["'])(\\/luci-static\\/resources)(\2)""", ) for pattern in patterns: text = re.sub(pattern, protect_value, text) return text, protected def restore_luci_resource_root(text, protected): for index, value in enumerate(protected): text = text.replace(f"__OWRT_REMOTE_LUCI_RESOURCE_{index}__", value) return text def normalize_public_hosts(*values): hosts = set() for value in values: if not value: continue raw = str(value).strip() if not raw: continue parsed = urllib.parse.urlsplit(raw if "://" in raw else f"//{raw}") netloc = parsed.netloc or parsed.path.split("/", 1)[0] netloc = netloc.split("@", 1)[-1].strip().lower() if not netloc: continue hosts.add(netloc) if ":" not in netloc: hosts.add(f"{netloc}:80") hosts.add(f"{netloc}:443") hosts.add(f"{netloc}:8088") return sorted(hosts, key=len, reverse=True) def rewrite_public_absolute_urls(text, prefix, public_hosts): escaped_prefix = prefix.replace("/", "\\/") for host in public_hosts or []: for scheme in ("http", "https"): for root in ("/ubus", "/cgi-bin/luci", "/luci-static"): text = text.replace(f"{scheme}://{host}{root}", f"{prefix}{root}") escaped_root = root.replace("/", "\\/") text = text.replace(f"{scheme}:\\/\\/{host}{escaped_root}", f"{escaped_prefix}{escaped_root}") return text def rewrite_remaining_luci_roots(text, prefix): roots = ("/ubus", "/cgi-bin/luci", "/luci-static") escaped_prefix = prefix.replace("/", "\\/") for root in roots: key = root.strip("/").replace("/", "_") marker = f"__OWRT_REMOTE_RAW_ROOT_{key}__" escaped_marker = f"__OWRT_REMOTE_ESC_ROOT_{key}__" escaped_root = root.replace("/", "\\/") escaped_prefixed = f"{escaped_prefix}{escaped_root}" text = text.replace(escaped_prefixed, escaped_marker) text = text.replace(escaped_root, escaped_prefixed) text = text.replace(escaped_prefixed, escaped_marker) prefixed = f"{prefix}{root}" text = text.replace(prefixed, marker) text = text.replace(root, prefixed) text = text.replace(marker, prefixed) text = text.replace(escaped_marker, escaped_prefixed) return text def rewrite_html(body, prefix, content_type="", public_hosts=None): text = body.decode("utf-8", errors="ignore") escaped_prefix = prefix.replace("/", "\\/") text, protected_resource_roots = protect_luci_resource_root(text) replacements = { 'href="/': f'href="{prefix}/', 'src="/': f'src="{prefix}/', 'action="/': f'action="{prefix}/', 'data-url="/': f'data-url="{prefix}/', "href=/": f"href={prefix}/", "src=/": f"src={prefix}/", "action=/": f"action={prefix}/", "data-url=/": f"data-url={prefix}/", "href='/": f"href='{prefix}/", "src='/": f"src='{prefix}/", "action='/": f"action='{prefix}/", "data-url='/": f"data-url='{prefix}/", 'url("/': f'url("{prefix}/', "url('/": f"url('{prefix}/", "url(/": f"url({prefix}/", '"/ubus"': f'"{prefix}/ubus"', "'/ubus'": f"'{prefix}/ubus'", "`/ubus`": f"`{prefix}/ubus`", '"/cgi-bin/luci"': f'"{prefix}/cgi-bin/luci"', "'/cgi-bin/luci'": f"'{prefix}/cgi-bin/luci'", "`/cgi-bin/luci`": f"`{prefix}/cgi-bin/luci`", '"/cgi-bin/luci': f'"{prefix}/cgi-bin/luci', '"/ubus/': f'"{prefix}/ubus/', '"/luci-static/': f'"{prefix}/luci-static/', "'/cgi-bin/luci": f"'{prefix}/cgi-bin/luci", "'/ubus/": f"'{prefix}/ubus/", "'/luci-static/": f"'{prefix}/luci-static/", "`/cgi-bin/luci": f"`{prefix}/cgi-bin/luci", "`/ubus/": f"`{prefix}/ubus/", "`/luci-static/": f"`{prefix}/luci-static/", '"\\/ubus"': f'"{escaped_prefix}\\/ubus"', "'\\/ubus'": f"'{escaped_prefix}\\/ubus'", "`\\/ubus`": f"`{escaped_prefix}\\/ubus`", '"\\/cgi-bin\\/luci"': f'"{escaped_prefix}\\/cgi-bin\\/luci"', "'\\/cgi-bin\\/luci'": f"'{escaped_prefix}\\/cgi-bin\\/luci'", "`\\/cgi-bin\\/luci`": f"`{escaped_prefix}\\/cgi-bin\\/luci`", '"\\/cgi-bin\\/luci': f'"{escaped_prefix}\\/cgi-bin\\/luci', '"\\/ubus\\/': f'"{escaped_prefix}\\/ubus\\/', '"\\/luci-static\\/': f'"{escaped_prefix}\\/luci-static\\/', "'\\/cgi-bin\\/luci": f"'{escaped_prefix}\\/cgi-bin\\/luci", "'\\/ubus\\/": f"'{escaped_prefix}\\/ubus\\/", "'\\/luci-static\\/": f"'{escaped_prefix}\\/luci-static\\/", "`\\/cgi-bin\\/luci": f"`{escaped_prefix}\\/cgi-bin\\/luci", "`\\/ubus\\/": f"`{escaped_prefix}\\/ubus\\/", "`\\/luci-static\\/": f"`{escaped_prefix}\\/luci-static\\/", } for old, new in replacements.items(): text = text.replace(old, new) text = rewrite_public_absolute_urls(text, prefix, public_hosts or []) text = rewrite_remaining_luci_roots(text, prefix) text = restore_luci_resource_root(text, protected_resource_roots) if "text/html" in (content_type or "").lower(): script = proxy_runtime_script(prefix) head_match = re.search(r"]*>", text, flags=re.IGNORECASE) if head_match: text = text[: head_match.end()] + "\n" + script + text[head_match.end() :] elif "" in text: text = text.replace("", script + "\n", 1) elif "" in text: text = text.replace("", script + "\n", 1) else: text += script return text.encode("utf-8") def should_rewrite_body(content_type): content_type = (content_type or "").lower() return ( "text/html" in content_type or "text/css" in content_type ) def cmd_init(args): with connect(args.db) as conn: init_db(conn) auth = load_auth() print(f"DB: {args.db}") print(f"HUB_LOGIN: {auth.get('username', 'admin')}") print(f"AGENT_TOKEN: {agent_token()}") hint = STATE_DIR / "hub-login.txt" if hint.exists(): print(f"HUB_PASSWORD_FILE: {hint}") def cmd_set_login(args): save_auth(args.username, args.password) print(f"HUB_LOGIN: {args.username}") print("HUB_PASSWORD: updated") def cmd_add_router(args): with connect(args.db) as conn: init_db(conn) row = upsert_router( conn, { "id": args.id, "name": args.name, "role": args.role, "entry_port": args.entry_port, "vps_host": args.vps_host, "vless_port": args.vless_port, "vless_uuid": args.vless_uuid, "vless_encryption": args.vless_encryption, "vless_decryption": args.vless_decryption, "vless_flow": args.vless_flow, "reverse_tag": args.reverse_tag, "public_url": args.public_url, "admin_host": args.admin_host, "admin_port": args.admin_port, "ssh_entry_port": args.ssh_entry_port or args.entry_port + 1000, "ssh_vless_uuid": args.ssh_vless_uuid, "ssh_reverse_tag": args.ssh_reverse_tag, "ssh_host": args.ssh_host, "ssh_port": args.ssh_port, }, ) router = row_to_router(row) print(json.dumps(router, ensure_ascii=False, indent=2)) def cmd_set_entry_port(args): router_id = clean_router_id(args.id) with connect(args.db) as conn: init_db(conn) row = get_router(conn, router_id) if not row: raise SystemExit(f"router not found: {router_id}") old_entry = int(row["entry_port"] or 0) old_ssh_entry = int(row["ssh_entry_port"] or 0) new_entry = int(args.entry_port) new_ssh_entry = new_entry + 1000 if old_ssh_entry in (0, old_entry + 1000) else old_ssh_entry owner = get_router_by_any_port(conn, new_entry, router_id) if owner: raise SystemExit(f"entry_port {new_entry} already used by {owner['id']}") owner = get_router_by_any_port(conn, new_ssh_entry, router_id) if owner: raise SystemExit(f"ssh_entry_port {new_ssh_entry} already used by {owner['id']}") conn.execute( "update routers set entry_port = ?, ssh_entry_port = ?, updated_at = ? where id = ?", (new_entry, new_ssh_entry, now_ts(), router_id), ) conn.commit() row = get_router(conn, router_id) router = row_to_router(row) print(json.dumps(router, ensure_ascii=False, indent=2)) def cmd_list(args): with connect(args.db) as conn: init_db(conn) rows = [row_to_router(r) for r in list_router_rows(conn)] print(json.dumps(rows, ensure_ascii=False, indent=2)) def cmd_render_xray(args): with connect(args.db) as conn: init_db(conn) rows = list_router_rows(conn) config = make_server_xray_config(rows, args.listen_host, args.listen_port, args.decryption) text = json.dumps(config, ensure_ascii=False, indent=2) + "\n" if args.out == "-": print(text, end="") else: out = Path(args.out) out.parent.mkdir(parents=True, exist_ok=True) out.write_text(text, encoding="utf-8") try: os.chmod(out, 0o600) except OSError: pass print(f"written: {out}") def cmd_print_openwrt(args): with connect(args.db) as conn: init_db(conn) row = get_router(conn, args.id) if not row: raise SystemExit(f"router not found: {args.id}") hub_url = args.hub_url or router_fallback_hub_url(row, args.vps_host, args.port) print(make_openwrt_config(row, hub_url), end="") def cmd_backup(args): out = Path(args.out) if args.out else STATE_DIR / backup_filename() result = create_hub_backup(out, args.db) print(json.dumps(result, ensure_ascii=False, indent=2)) def cmd_restore(args): result = restore_hub_backup(args.file, args.db, args.vps_host, args.public_url) print(json.dumps(result, ensure_ascii=False, indent=2)) print("Restart Hub after restore: systemctl restart owrt-remote") def cmd_rewrite_endpoints(args): with connect(args.db) as conn: init_db(conn) rewritten = rewrite_router_endpoints( conn, args.vps_host, args.public_url, preserve_vps_fallback=bool(args.preserve_vps_fallback), ) total = conn.execute("select count(*) from routers where deleted_at = 0").fetchone()[0] print(json.dumps({"ok": True, "rewritten": rewritten, "routers": total}, ensure_ascii=False, indent=2)) def parse_extra_ports(value): ports = [] for item in str(value or "").replace(";", ",").split(","): item = item.strip() if not item: continue try: port = int(item) except ValueError: continue if 0 < port < 65536 and port not in ports: ports.append(port) return ports class HubHTTPServer(ThreadingHTTPServer): request_queue_size = REQUEST_QUEUE_SIZE daemon_threads = True allow_reuse_address = True def get_request(self): request, client_address = super().get_request() try: request.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1) except OSError: pass return request, client_address def make_http_server(app, host, port, tls_cert="", tls_key=""): server = HubHTTPServer((host, port), Handler) server.app = app server.is_tls = False if tls_cert and tls_key: context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER) context.set_alpn_protocols(["http/1.1"]) context.load_cert_chain(tls_cert, tls_key) server.socket = context.wrap_socket( server.socket, server_side=True, do_handshake_on_connect=False, ) server.is_tls = True return server def cmd_serve(args): app = App(args.db, session_token(), agent_token(), args.public_url) with app.conn(): pass record_hub_start_event() app.start_router_state_monitor() auth = load_auth() server = make_http_server(app, args.host, args.port) extra_servers = [] tls_ports = parse_extra_ports(args.tls_ports) if args.tls_cert and args.tls_key else [] tls_port_set = set(tls_ports) for port in parse_extra_ports(args.extra_ports): if port == args.port: continue if port in tls_port_set: print(f"WARNING: port {port} skipped for plain HTTP because TLS is enabled on it", file=sys.stderr) continue try: extra_server = make_http_server(app, args.host, port) except OSError as exc: print(f"WARNING: extra port {port} not started: {exc}", file=sys.stderr) continue extra_servers.append(extra_server) thread = threading.Thread(target=extra_server.serve_forever, daemon=True) thread.start() print(f"{APP_NAME} also listening on http://{args.host}:{port}") if args.tls_cert and args.tls_key: for port in tls_ports: try: tls_server = make_http_server(app, args.host, port, args.tls_cert, args.tls_key) except OSError as exc: print(f"WARNING: HTTPS port {port} not started: {exc}", file=sys.stderr) continue except ssl.SSLError as exc: print(f"WARNING: HTTPS cert/key error: {exc}", file=sys.stderr) continue extra_servers.append(tls_server) thread = threading.Thread(target=tls_server.serve_forever, daemon=True) thread.start() print(f"{APP_NAME} also listening on https://{args.host}:{port}") print(f"{APP_NAME} listening on http://{args.host}:{args.port}") print(f"HUB_LOGIN: {auth.get('username', 'admin')}") print(f"AGENT_TOKEN: {app.agent_token}") try: server.serve_forever() except KeyboardInterrupt: print("") finally: app.stop_router_state_monitor() for extra_server in extra_servers: extra_server.shutdown() def parser(): p = argparse.ArgumentParser(description=APP_NAME) p.add_argument("--db", default=str(DB_PATH), help="SQLite DB path") sub = p.add_subparsers(dest="cmd", required=True) init = sub.add_parser("init", help="initialize state and tokens") init.set_defaults(func=cmd_init) auth = sub.add_parser("set-login", help="set dashboard username and password") auth.add_argument("--username", required=True) auth.add_argument("--password", required=True) auth.set_defaults(func=cmd_set_login) add = sub.add_parser("add-router", help="add or update router") add.add_argument("--id", required=True) add.add_argument("--name", required=True) add.add_argument("--role", default="node") add.add_argument("--entry-port", type=int, required=True) add.add_argument("--vps-host", required=True) add.add_argument("--vless-port", type=int, default=DEFAULT_VLESS_PORT) add.add_argument("--vless-uuid", default="") add.add_argument("--vless-encryption", default="none") add.add_argument("--vless-decryption", default="none") add.add_argument("--vless-flow", default="") add.add_argument("--reverse-tag", default="reverse-in") add.add_argument("--public-url", default="") add.add_argument("--admin-host", default="127.0.0.1") add.add_argument("--admin-port", type=int, default=80) add.add_argument("--ssh-entry-port", type=int, default=0) add.add_argument("--ssh-vless-uuid", default="") add.add_argument("--ssh-reverse-tag", default="") add.add_argument("--ssh-host", default="127.0.0.1") add.add_argument("--ssh-port", type=int, default=22) add.set_defaults(func=cmd_add_router) sep = sub.add_parser("set-entry-port", help="set router VPS entry port without changing UUID") sep.add_argument("--id", required=True) sep.add_argument("--entry-port", type=int, required=True) sep.set_defaults(func=cmd_set_entry_port) ls = sub.add_parser("list-routers", help="print routers") ls.set_defaults(func=cmd_list) rx = sub.add_parser("render-xray", help="render VPS Xray config") rx.add_argument("--listen-host", default="0.0.0.0") rx.add_argument("--listen-port", type=int, default=DEFAULT_VLESS_PORT) rx.add_argument("--decryption", default="none") rx.add_argument("--out", default="-") rx.set_defaults(func=cmd_render_xray) ow = sub.add_parser("print-openwrt-config", help="print UCI commands for router") ow.add_argument("--id", required=True) ow.add_argument("--hub-url", default="") ow.add_argument("--vps-host", default="127.0.0.1") ow.add_argument("--port", type=int, default=8088) ow.set_defaults(func=cmd_print_openwrt) backup = sub.add_parser("backup", help="create Hub backup archive") backup.add_argument("--out", default="", help="output .tar.gz path") backup.set_defaults(func=cmd_backup) restore = sub.add_parser("restore", help="restore Hub backup archive") restore.add_argument("--file", required=True, help="backup .tar.gz path") restore.add_argument("--vps-host", default="", help="rewrite routers to new VPS host/IP") restore.add_argument("--public-url", default="", help="rewrite routers to new public Hub URL") restore.set_defaults(func=cmd_restore) rewrite = sub.add_parser("rewrite-endpoints", help="rewrite active router endpoint settings in Hub DB") rewrite.add_argument("--vps-host", default="", help="new VPS host/IP for active routers") rewrite.add_argument("--public-url", default="", help="new public Hub URL for active routers") rewrite.add_argument( "--preserve-vps-fallback", action="store_true", help="keep current router vps_host values when public_url and vps_host point to the same host, preserving old IP fallback during same-VPS domain migration", ) rewrite.set_defaults(func=cmd_rewrite_endpoints) serve = sub.add_parser("serve", help="run web dashboard") serve.add_argument("--host", default=os.environ.get("OWRT_REMOTE_BIND", "0.0.0.0")) serve.add_argument("--port", type=int, default=int(os.environ.get("OWRT_REMOTE_PORT", "8088"))) serve.add_argument("--extra-ports", default=os.environ.get("OWRT_REMOTE_EXTRA_PORTS", "")) serve.add_argument("--tls-ports", default=os.environ.get("OWRT_REMOTE_TLS_PORTS", "")) serve.add_argument("--tls-cert", default=os.environ.get("OWRT_REMOTE_TLS_CERT", "")) serve.add_argument("--tls-key", default=os.environ.get("OWRT_REMOTE_TLS_KEY", "")) serve.add_argument("--public-url", default=os.environ.get("OWRT_REMOTE_PUBLIC_URL", "")) serve.set_defaults(func=cmd_serve) return p def main(): args = parser().parse_args() args.func(args) if __name__ == "__main__": main()