#!/usr/bin/env python3
import argparse
import base64
import datetime as dt
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 sys
import tarfile
import tempfile
import threading
import time
import urllib.parse
import uuid
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
from pathlib import Path
try:
from pywebpush import WebPushException, webpush
except Exception:
WebPushException = None
webpush = None
APP_NAME = "OpenWrt Remote Hub"
RAW_REPO_BASE = "https://raw.githubusercontent.com/kzolotarev95/luci-app-owrt-remote/main"
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"
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"
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)))
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
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()
STATIC_CACHE = {}
STATIC_CACHE_BYTES = 0
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,
)
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 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 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")
data = {
"username": username,
"password": password_digest(password),
"updated_at": now_ts(),
}
write_json_private(AUTH_FILE, data)
return data
def load_auth():
ensure_state()
if AUTH_FILE.exists():
return json.loads(AUTH_FILE.read_text(encoding="utf-8"))
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()
stored_user = auth.get("username", "")
stored = auth.get("password", {})
digest = password_digest(password or "", stored.get("salt"), stored.get("iterations", PBKDF2_ITERATIONS))
except Exception:
return False
return secrets.compare_digest(username or "", stored_user) and secrets.compare_digest(
digest["hash"],
stored.get("hash", ""),
)
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):
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,
}
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 list_hub_sessions(current_token=""):
current_hash = session_hash(current_token) if current_token else ""
rows = []
for session in sorted(load_sessions(), key=lambda item: int(item.get("last_seen") or 0), reverse=True):
rows.append(
{
"id": session.get("id", ""),
"username": session.get("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),
"current": bool(current_hash and secrets.compare_digest(session.get("token_hash", ""), current_hash)),
}
)
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 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 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 webpush is not None and WebPushException is not None and bool(vapid_public_key())
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):
return {
"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()),
}
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:
return
def worker():
gone = []
for subscription in subscriptions:
result = send_web_push(subscription, payload)
if result == "gone":
gone.append(subscription.get("endpoint", ""))
for endpoint in gone:
remove_push_subscription(endpoint)
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('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 title = data.title || 'OpenWrt Remote Hub';
const options = {
body: data.body || '',
tag: data.tag || 'owrt-remote-hub',
renotify: true,
data: {url: data.url || '/'},
badge: data.badge || undefined,
icon: data.icon || undefined
};
event.waitUntil(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(
{
"name": "OpenWrt Remote Hub",
"short_name": "Wrt Hub",
"start_url": "/",
"scope": "/",
"display": "standalone",
"background_color": "#10081c",
"theme_color": "#7c3aed",
"description": "Удаленный доступ к OpenWrt через свой VPS",
"icons": [
{
"src": "/favicon.svg",
"sizes": "any",
"type": "image/svg+xml",
"purpose": "any maskable",
}
],
},
ensure_ascii=False,
separators=(",", ":"),
)
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 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]
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,
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")
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 = {}
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 service_enabled and now_ts() - int(last_seen) <= ONLINE_AFTER_SECONDS)
data["status"] = status
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["xray_client_url"] = f"/router/{urllib.parse.quote(data['id'])}/xray-client.json"
data.pop("status_json", None)
return data
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 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)
if vps_host:
conn.execute("update routers set vps_host = ?, updated_at = ?", (str(vps_host).strip(), now_ts()))
rewritten["vps_host"] = str(vps_host).strip()
if public_url:
conn.execute("update routers set public_url = ?, updated_at = ?", (str(public_url).strip(), now_ts()))
rewritten["public_url"] = str(public_url).strip()
conn.commit()
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")
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),
"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,
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,
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,
: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 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 make_openwrt_config(row, hub_url):
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(row['id'])}'",
f"uci set owrtremote.main.router_name='{sh_quote(row['name'])}'",
f"uci set owrtremote.main.role='{sh_quote(row['role'])}'",
f"uci set owrtremote.main.hub_url='{sh_quote(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(row['vps_host'])}'",
f"uci set owrtremote.main.vps_port='{int(row['vless_port'])}'",
f"uci set owrtremote.main.vless_uuid='{sh_quote(row['vless_uuid'])}'",
f"uci set owrtremote.main.vless_encryption='{sh_quote(row['vless_encryption'])}'",
f"uci set owrtremote.main.vless_flow='{sh_quote(row['vless_flow'])}'",
f"uci set owrtremote.main.reverse_tag='{sh_quote(row['reverse_tag'])}'",
f"uci set owrtremote.main.ssh_vless_uuid='{sh_quote(row['ssh_vless_uuid'])}'",
f"uci set owrtremote.main.ssh_reverse_tag='{sh_quote(row['ssh_reverse_tag'] or (row['reverse_tag'] + '-ssh'))}'",
f"uci set owrtremote.main.admin_host='{sh_quote(row['admin_host'])}'",
f"uci set owrtremote.main.admin_port='{int(row['admin_port'])}'",
f"uci set owrtremote.main.ssh_host='{sh_quote(row['ssh_host'] or '127.0.0.1')}'",
f"uci set owrtremote.main.ssh_port='{int(row['ssh_port'] or 22)}'",
f"uci set owrtremote.main.public_url='{sh_quote(row['public_url'])}'",
"uci commit owrtremote",
"owrt-remote render-client",
"/etc/init.d/owrt-remote enable",
"/etc/init.d/owrt-remote restart",
"owrt-remote heartbeat",
]
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):
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)
safe_username = html.escape(username, quote=True)
return f"""
{APP_NAME}
Эффекты
Эффекты Hub
Выкл
Снег
Дождь
Космос
Искры
Орбиты
Призма
Пульс
Лучи
Открыть добавление
Открыть статистику
Диагностика
Выбери роутер и напиши проблему своими словами. Можно свободно: 502, пустая панель, не работает Xray, не открывается терминал.
Скрыть
Что работает
Какие проблемы
Что уже пробовал
Запустить диагностику
"""
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"""
SSH {safe_name}
__QUICK_COMMANDS_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"""
SSH __SAFE_NAME__
__QUICK_COMMANDS_HTML__
Terminal
Копировать
Очистить
Переподключить
Загрузка терминала...
Отправить
"""
return (
page.replace("__SAFE_NAME__", safe_name)
.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 login_html(error=""):
error_html = f"{html.escape(error)}
" if error else ""
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"""
OpenWrt Remote Hub
"""
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 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_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 "{}")
parsed = urllib.parse.parse_qs(body.decode("utf-8"))
return {k: v[-1] for k, v in parsed.items()}
def session_cookie(self, token):
return f"{SESSION_COOKIE}={token}; HttpOnly; SameSite=Lax; Path=/; Max-Age={SESSION_TTL_SECONDS}"
def clear_session_cookie(self):
return f"{SESSION_COOKIE}=; HttpOnly; SameSite=Lax; Path=/; Max-Age=0"
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", "")
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
if verify_login(username, password):
token, session = make_hub_session(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", "")},
)
self.redirect("/", [("Set-Cookie", self.session_cookie(token))])
return
self.send_bytes(401, login_html("Неверный логин или пароль").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
auth["updated_at"] = now_ts()
write_json_private(AUTH_FILE, auth)
self.send_text(200, "Доступ к Hub обновлен")
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):
if not self.require_admin():
return
router_id = self.router_id_from_path("/ssh/")
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 vps_terminal_page(self):
if not self.require_admin():
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 not (self.admin_ok() or self.ssh_token_ok(router_id)):
self.send_response(403)
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 not (self.admin_ok() or self.ssh_token_ok(router_id)):
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 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 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 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 not (self.admin_ok() or self.ssh_token_ok(router_id)):
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]
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 do_GET(self):
path = self.parsed().path
if path == "/health":
self.send_json(200, {"ok": True})
return
if path == "/favicon.svg":
self.send_bytes(200, favicon_svg().encode("utf-8"), "image/svg+xml; charset=utf-8")
return
if path == "/favicon.ico":
self.send_response(302)
self.send_header("Location", "/favicon.svg")
self.end_headers()
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.startswith("/.well-known/acme-challenge/"):
self.serve_acme_challenge(path)
return
if path == "/login":
self.send_bytes(200, login_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()
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 = [row_to_router(r) for r in list_router_rows(conn)]
self.send_bytes(
200,
dashboard_html(
routers,
current_username(),
list_hub_sessions(session_token_value),
list_notifications(0, 40),
).encode("utf-8"),
"text/html; charset=utf-8",
extra_headers,
)
return
if path == "/api/routers":
with self.app.conn() as conn:
routers = [row_to_router(r) for r in list_router_rows(conn)]
self.send_json(200, {"routers": routers})
return
if path == "/api/backup/download":
self.backup_download()
return
if path == "/api/sessions":
self.send_json(200, {"sessions": list_hub_sessions(self.current_session_token())})
return
if path == "/api/notifications":
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":
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":
public_key = vapid_public_key()
if not webpush:
self.send_json(503, {"ok": False, "error": "На VPS не установлен Web Push модуль. Запусти свежий install-vps.sh.", "publicKey": public_key})
return
if not public_key:
self.send_json(503, {"ok": False, "error": "Не смог создать VAPID ключи на VPS", "publicKey": ""})
return
self.send_json(200, {"ok": True, "publicKey": public_key})
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])
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/"):
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/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,
"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":
self.update_auth()
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
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()):
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":
clear_notifications()
self.send_json(200, {"ok": True})
return
if path == "/api/backup/restore":
self.backup_restore()
return
if path == "/api/push/subscribe":
try:
payload = self.read_payload()
session = self.current_hub_session(touch=False) or {}
subscription = save_push_subscription(
payload,
session.get("username", current_username()),
self.client_ip(),
self.headers.get("User-Agent", ""),
)
test_payload = {
"title": APP_NAME,
"body": "Push включён на этом устройстве.",
"tag": "owrt-push-test",
"url": "/",
"kind": "push-test",
"ts": now_ts(),
}
result = send_web_push(subscription, test_payload)
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:
self.send_json(400, {"ok": False, "error": str(exc)})
return
if path == "/api/push/unsubscribe":
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":
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":
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":
try:
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)
self.send_json(200, {"ok": True, "router": router})
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])
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("/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])
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])
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("/delete"):
router_id = urllib.parse.unquote(path.split("/")[3])
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)
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_url = self.app.public_url or f"http://{self.headers.get('Host')}"
if asset == "config":
self.send_text(200, make_openwrt_config(row, hub_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):
if not self.require_admin():
return
parts = path.split("/", 3)
if len(parts) < 3 or not parts[2]:
self.redirect("/")
return
router_id = urllib.parse.unquote(parts[2])
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 "