Архив переносит БД роутеров, логин, токены Hub/агента, push-ключи и уведомления. Для переезда на другой IP укажи новый VPS host/Public URL перед восстановлением.
Открой Hub, зайди в Доступ к Hub, блок SSH ED25519. Введи текущий пароль от Hub, укажи метку, например Windows-PC, вставь строку из файла .pub и нажми Добавить SSH ED25519.
5. Получи challenge на экране логина Hub
Нажми Получить challenge, скопируй текст и сохрани его в файл на Windows ПК. Проще всего открыть Блокнот этой командой:
PowerShell
notepad $env:TEMP\\hub-challenge.txt
Вставь туда challenge из Hub, сохрани файл и закрой Блокнот.
6. Подпиши challenge приватным ключом
Подписывать нужно файлом без .pub, то есть именно приватным ключом id_ed25519_hub.
.*?',
replacement,
page,
count=1,
flags=re.S,
)
if count and ".captchaSectionRecaptcha" not in page:
page = page.replace(
".captchaRefresh:active{transform:translateY(1px)}",
".captchaRefresh:active{transform:translateY(1px)}"
".captchaSectionRecaptcha{gap:12px}"
".captchaHint{color:var(--muted);font-size:12px;line-height:1.45}"
".recaptchaBox{display:flex;justify-content:center;overflow-x:auto;padding:4px 0}",
1,
)
script = login_recaptcha_script(auth)
if script and script not in page:
page = page.replace("", f"{script}\n", 1)
return page
class App:
def __init__(self, db_path, session, agent, public_url):
self.db_path = Path(db_path)
self.session_token = session
self.agent_token = agent
self.public_url = public_url.rstrip("/")
self.router_state_lock = threading.Lock()
self.router_state_snapshot = {}
self.router_monitor_stop = threading.Event()
self.router_monitor_thread = None
def conn(self):
conn = connect(self.db_path)
init_db(conn)
return conn
def snapshot_router_states(self):
with self.conn() as conn:
routers = [row_to_router(row) for row in list_router_rows(conn)]
return {
str(router.get("id") or ""): {
"online": bool(router.get("online")),
"router": router,
}
for router in routers
if str(router.get("id") or "").strip()
}
def prime_router_state_snapshot(self):
snapshot = self.snapshot_router_states()
with self.router_state_lock:
self.router_state_snapshot = snapshot
def check_router_state_changes(self):
current = self.snapshot_router_states()
with self.router_state_lock:
previous = dict(self.router_state_snapshot)
self.router_state_snapshot = current
for router_id, old in previous.items():
new = current.get(router_id)
if not new:
continue
if bool(old.get("online")) and not bool(new.get("online")):
notify_router_offline(new.get("router") or {})
def router_state_monitor_loop(self):
interval = max(3, int(os.environ.get("OWRT_REMOTE_ROUTER_NOTIFY_POLL", "5")))
self.prime_router_state_snapshot()
while not self.router_monitor_stop.wait(interval):
try:
self.check_router_state_changes()
except Exception as exc:
print(f"WARNING: router state monitor error: {exc}", file=sys.stderr)
def start_router_state_monitor(self):
if self.router_monitor_thread and self.router_monitor_thread.is_alive():
return
self.router_monitor_stop.clear()
self.router_monitor_thread = threading.Thread(target=self.router_state_monitor_loop, daemon=True)
self.router_monitor_thread.start()
def stop_router_state_monitor(self):
self.router_monitor_stop.set()
class Handler(BaseHTTPRequestHandler):
server_version = "owrt-remote-hub/1.0"
protocol_version = "HTTP/1.1"
@property
def app(self):
return self.server.app
def log_message(self, fmt, *args):
sys.stderr.write("%s - - [%s] %s\n" % (self.address_string(), self.log_date_time_string(), fmt % args))
def parsed(self):
return urllib.parse.urlsplit(self.path)
def query(self):
return urllib.parse.parse_qs(self.parsed().query)
def maybe_proxy_luci_absolute(self, path):
if not any(path == root or path.startswith(root + "/") for root in LUCI_ABSOLUTE_ROOTS):
return False
router_id = ""
ref_path = urllib.parse.urlsplit(self.headers.get("Referer", "")).path
parts = ref_path.split("/", 3)
if len(parts) >= 3 and parts[1] == "access" and parts[2]:
router_id = parts[2]
if not router_id:
router_id = urllib.parse.unquote(parse_cookies(self.headers.get("Cookie", "")).get(ROUTER_COOKIE, ""))
if router_id:
self.proxy_access(f"/access/{router_id}{path}")
return True
return False
def client_ip(self):
forwarded = self.headers.get("X-Forwarded-For", "")
if forwarded:
return forwarded.split(",", 1)[0].strip()
try:
return self.client_address[0]
except Exception:
return ""
def current_session_token(self):
return parse_cookies(self.headers.get("Cookie", "")).get(SESSION_COOKIE, "")
def current_hub_session(self, touch=True):
return verify_hub_session(
self.current_session_token(),
touch=touch,
ip=self.client_ip() if touch else "",
user_agent=self.headers.get("User-Agent", "") if touch else "",
)
def legacy_admin_ok(self):
return secrets.compare_digest(self.current_session_token(), self.app.session_token)
def admin_ok(self):
return bool(self.current_hub_session()) or self.legacy_admin_ok()
def current_account_profile(self, touch=True):
auth = normalize_auth_state(load_auth())
if self.legacy_admin_ok():
return account_profile(auth, auth.get("username", "admin"))
session = self.current_hub_session(touch=touch)
if not session:
return None
return account_profile(auth, session.get("username", ""))
def owner_ok(self):
profile = self.current_account_profile(touch=False)
return bool(profile and profile.get("is_owner"))
def can_add_router(self):
profile = self.current_account_profile(touch=False)
return bool(profile and account_can_add_router(profile))
def require_owner(self, json_mode=False):
if self.owner_ok():
return True
if not self.admin_ok():
if json_mode:
self.send_json(401, {"ok": False, "error": "not authorized"})
else:
self.send_bytes(401, login_html().encode("utf-8"), "text/html; charset=utf-8")
return False
if json_mode:
self.send_json(403, {"ok": False, "error": "Недостаточно прав"})
else:
self.send_text(403, "Недостаточно прав")
return False
def require_add_router(self, json_mode=False):
if self.can_add_router():
return True
if not self.admin_ok():
if json_mode:
self.send_json(401, {"ok": False, "error": "not authorized"})
else:
self.send_bytes(401, login_html().encode("utf-8"), "text/html; charset=utf-8")
return False
if json_mode:
self.send_json(403, {"ok": False, "error": "Недостаточно прав для добавления роутера"})
else:
self.send_text(403, "Недостаточно прав для добавления роутера")
return False
def router_access_allowed(self, router_id, flag):
profile = self.current_account_profile()
return bool(profile and account_has_router_flag(profile, router_id, flag))
def require_router_access(self, router_id, flag, json_mode=False):
if self.router_access_allowed(router_id, flag):
return True
if not self.admin_ok():
if json_mode:
self.send_json(401, {"ok": False, "error": "not authorized"})
else:
self.send_bytes(401, login_html().encode("utf-8"), "text/html; charset=utf-8")
return False
if json_mode:
self.send_json(403, {"ok": False, "error": "Недостаточно прав для этого роутера"})
else:
self.send_text(403, "Недостаточно прав для этого роутера")
return False
def current_or_owner_session_scope(self):
profile = self.current_account_profile(touch=False)
if not profile or profile.get("is_owner"):
return ""
return str(profile.get("username") or "")
def visible_routers(self, conn, account=None):
profile = account or self.current_account_profile()
routers = [row_to_router(r) for r in list_router_rows(conn)]
if profile and not profile.get("is_owner"):
allowed = set(profile.get("router_ids") or [])
routers = [router for router in routers if str(router.get("id") or "") in allowed]
return [router_with_access(router, profile) for router in routers]
def ssh_token_ok(self, router_id):
token = self.query().get("t", [""])[0]
if not token:
return False
return secrets.compare_digest(token, ssh_ws_token(self.app.session_token, router_id))
def agent_ok(self):
auth = self.headers.get("Authorization", "")
if auth.startswith("Bearer "):
return secrets.compare_digest(auth[7:].strip(), self.app.agent_token)
return False
def send_bytes(self, status, body, content_type="text/plain; charset=utf-8", extra_headers=None):
self.close_connection = True
self.send_response(status)
self.send_header("Content-Type", content_type)
self.send_header("Cache-Control", "no-store")
self.send_header("Connection", "close")
if extra_headers:
for key, value in extra_headers:
if key.lower() in {"connection", "content-length", "content-type", "cache-control"}:
continue
self.send_header(key, value)
self.send_header("Content-Length", str(len(body)))
self.end_headers()
if self.command != "HEAD":
try:
self.wfile.write(body)
self.wfile.flush()
except (BrokenPipeError, ConnectionResetError, ssl.SSLError):
pass
def send_raw_bytes(self, status, body, content_type="application/octet-stream", extra_headers=None):
self.close_connection = True
reason = self.responses.get(status, ("OK",))[0]
headers = [
f"{self.protocol_version} {status} {reason}",
f"Server: {self.version_string()}",
f"Date: {self.date_time_string()}",
f"Content-Type: {content_type}",
"Cache-Control: no-store",
"Connection: close",
f"Content-Length: {len(body)}",
]
if extra_headers:
for key, value in extra_headers:
low = key.lower()
if low in {"connection", "content-length", "content-type", "cache-control"}:
continue
safe_key = str(key).replace("\r", "").replace("\n", "")
safe_value = str(value).replace("\r", "").replace("\n", "")
headers.append(f"{safe_key}: {safe_value}")
raw = ("\r\n".join(headers) + "\r\n\r\n").encode("iso-8859-1", "replace")
if self.command != "HEAD":
raw += body
try:
self.request.sendall(raw)
self.log_request(status, len(body))
except (BrokenPipeError, ConnectionResetError, ssl.SSLError):
pass
def send_text(self, status, text, content_type="text/plain; charset=utf-8"):
self.send_bytes(status, text.encode("utf-8"), content_type)
def send_local_asset(self, file_path, content_type):
try:
body = Path(file_path).read_bytes()
except FileNotFoundError:
self.send_text(404, "asset not found")
return
self.send_bytes(200, body, content_type)
def send_json(self, status, payload):
body = json.dumps(payload, ensure_ascii=False, separators=(",", ":")).encode("utf-8")
self.send_bytes(status, body, "application/json; charset=utf-8")
def require_admin(self):
if self.admin_ok():
return True
self.send_bytes(401, login_html().encode("utf-8"), "text/html; charset=utf-8")
return False
def read_body(self):
if self.headers.get("Transfer-Encoding", "").lower() == "chunked":
chunks = []
while True:
line = self.rfile.readline().strip()
if not line:
continue
size = int(line.split(b";", 1)[0], 16)
if size == 0:
while self.rfile.readline().strip():
pass
break
chunks.append(self.rfile.read(size))
self.rfile.read(2)
return b"".join(chunks)
length = int(self.headers.get("Content-Length", "0") or "0")
return self.rfile.read(length) if length else b""
def read_payload(self):
body = self.read_body()
ctype = self.headers.get("Content-Type", "")
if "application/json" in ctype:
return json.loads(body.decode("utf-8") or "{}")
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 request_scheme(self):
forwarded = str(self.headers.get("X-Forwarded-Proto", "")).split(",", 1)[0].strip().lower()
if forwarded in {"http", "https"}:
return forwarded
return "https" if isinstance(self.request, ssl.SSLSocket) else "http"
def request_host(self):
return str(self.headers.get("X-Forwarded-Host") or self.headers.get("Host") or "").split(",", 1)[0].strip()
def request_origin(self):
return origin_from_parts(self.request_scheme(), self.request_host())
def request_host_name(self):
try:
return urllib.parse.urlsplit(self.request_origin()).hostname or ""
except Exception:
return ""
def webauthn_rp_id(self):
return public_url_rp_id(self.app.public_url) or self.request_host_name()
def webauthn_allowed_origins(self):
values = []
for item in (public_url_origin(self.app.public_url), self.request_origin()):
if item and item not in values:
values.append(item)
return values
def build_webauthn_server(self):
if not passkey_supported():
raise ValueError("На сервере не установлен модуль Passkey/WebAuthn")
rp_id = self.webauthn_rp_id()
origins = set(self.webauthn_allowed_origins())
if not rp_id or not origins:
raise ValueError("Не удалось определить origin/RP ID для Passkey")
def verify_origin(origin):
try:
parts = urllib.parse.urlsplit(str(origin or ""))
return origin_from_parts(parts.scheme, parts.netloc) in origins
except Exception:
return False
return Fido2Server({"id": rp_id, "name": APP_NAME}, verify_origin=verify_origin)
def require_current_password(self, payload, auth=None):
auth = normalize_auth_state(auth or load_auth())
current_password = str((payload or {}).get("current_password") or "")
if not verify_login(auth.get("username", ""), current_password):
raise ValueError("Текущий пароль неверный")
return auth
def verify_login_captcha(self, payload, auth=None):
auth = normalize_auth_state(auth or load_auth())
state = effective_captcha_state(auth)
if state.get("effective_mode") == CAPTCHA_MODE_RECAPTCHA:
token = (
(payload or {}).get("g-recaptcha-response")
or (payload or {}).get("recaptcha_token")
or ""
)
return verify_recaptcha_token(
state.get("secret_key", ""),
token,
remote_ip=self.client_ip(),
expected_hostname=self.request_host_name(),
)
captcha_token = (payload or {}).get("captcha_token", "")
captcha_answer = (payload or {}).get("captcha_answer", "")
if verify_captcha(captcha_token, captcha_answer):
return True, ""
return False, "Неверная капча"
def create_login_session(self, username="", auth_method="password"):
session_username = str(username or current_username()).strip()
token, session = make_hub_session(
session_username,
self.client_ip(),
self.headers.get("User-Agent", ""),
auth_method=auth_method,
)
add_notification(
"login",
"Вход в Hub",
f"{session.get('client', 'устройство')} · {auth_method_label(auth_method)} · IP {session.get('ip', 'unknown')}",
"warn",
[session.get("user_agent", "")],
{
"session_id": session.get("id", ""),
"username": session_username,
"ip": session.get("ip", ""),
"client": session.get("client", ""),
"user_agent": session.get("user_agent", ""),
"auth_method": auth_method,
},
)
return token, session
def send_login_json(self, username="", auth_method="password"):
token, _ = self.create_login_session(username, auth_method)
body = {
"ok": True,
"redirect": "/",
"auth_method": auth_method,
"username": username or current_username(),
}
self.send_bytes(
200,
json.dumps(body, ensure_ascii=False, separators=(",", ":")).encode("utf-8"),
"application/json; charset=utf-8",
[("Set-Cookie", self.session_cookie(token))],
)
def social_callback_url(self, provider):
provider = str(provider or "").strip().lower()
base = public_url_origin(self.app.public_url) or self.request_origin()
if not base:
raise ValueError("Не удалось определить внешний URL Hub для OAuth callback")
return f"{base}/oauth/{provider}/callback"
def social_provider_config(self, provider, auth=None):
provider = str(provider or "").strip().lower()
if provider not in SOCIAL_PROVIDERS:
raise ValueError("Неизвестный OAuth provider")
auth = normalize_auth_state(auth or load_auth())
return sanitize_social_provider_state(provider, auth.get("social", {}).get(provider))
def social_flow_authorize_url(self, provider, state, redirect_uri, flow=None):
provider = str(provider or "").strip().lower()
cfg = self.social_provider_config(provider)
if not social_provider_configured(provider, cfg):
raise ValueError(social_provider_setup_message(provider))
flow = dict(flow or {})
if provider == "github":
query = {
"client_id": cfg["client_id"],
"redirect_uri": redirect_uri,
"scope": "read:user user:email",
"state": state,
"allow_signup": "false",
}
elif provider == "vk":
code_verifier = str(flow.get("code_verifier") or "").strip()
if not code_verifier:
raise ValueError("VK ID flow не подготовлен")
query = {
"client_id": cfg["client_id"],
"redirect_uri": redirect_uri,
"response_type": "code",
"scope": "email vkid.personal_info",
"state": state,
"code_challenge": make_pkce_challenge(code_verifier),
"code_challenge_method": "S256",
}
else:
raise ValueError("Неизвестный OAuth provider")
return f"{SOCIAL_PROVIDERS[provider]['authorize_url']}?{urllib.parse.urlencode(query)}"
def oauth_popup_html(self, title, message, provider="", ok=False):
tone = "ok" if ok else "bad"
provider = str(provider or "").strip().lower()
payload = json.dumps({"type": "owrt-social-linked", "provider": provider, "ok": bool(ok)}, ensure_ascii=False)
safe_title = html.escape(title or APP_NAME)
safe_message = html.escape(message or "")
return f"""
{branding_head_tags(include_manifest=False)}
{safe_title}
{'Готово' if ok else 'Ошибка'}
{safe_title}
{safe_message}
{'Вернуться в Hub' if ok else 'Открыть вход в Hub'}
"""
def social_login_error_page(self, message):
safe_message = html.escape(message or "Не удалось завершить OAuth вход")
return f"""
{branding_head_tags(include_manifest=False)}
OAuth ошибка
OAuth вход не завершен
{safe_message}
Вернуться на страницу входа
"""
def exchange_social_code(self, provider, code, redirect_uri, flow=None, flow_state="", device_id=""):
provider = str(provider or "").strip().lower()
cfg = self.social_provider_config(provider)
flow = dict(flow or {})
if provider == "github":
token = oauth_fetch_json(
SOCIAL_PROVIDERS[provider]["token_url"],
method="POST",
headers={
"Accept": "application/json",
"Content-Type": "application/x-www-form-urlencoded",
},
data={
"client_id": cfg["client_id"],
"client_secret": cfg["client_secret"],
"code": code,
"redirect_uri": redirect_uri,
},
)
access_token = str(token.get("access_token") or "").strip()
if not access_token:
raise ValueError(token.get("error_description") or token.get("error") or "GitHub не вернул access token")
profile = oauth_fetch_json(
"https://api.github.com/user",
headers={
"Accept": "application/vnd.github+json",
"Authorization": f"Bearer {access_token}",
},
)
emails = oauth_fetch_json(
"https://api.github.com/user/emails",
headers={
"Accept": "application/vnd.github+json",
"Authorization": f"Bearer {access_token}",
},
)
primary_email = ""
if isinstance(emails, list):
for row in emails:
if row.get("primary"):
primary_email = str(row.get("email") or "").strip()
break
if not primary_email and emails:
primary_email = str(emails[0].get("email") or "").strip()
account_id = str(profile.get("id") or "").strip()
if not account_id:
raise ValueError("GitHub не вернул ID пользователя")
return {
"id": account_id,
"label": str(profile.get("name") or profile.get("login") or primary_email or account_id),
"login": str(profile.get("login") or "").strip(),
"name": str(profile.get("name") or "").strip(),
"email": primary_email,
"profile_url": str(profile.get("html_url") or "").strip(),
"avatar_url": str(profile.get("avatar_url") or "").strip(),
}
if provider == "vk":
code_verifier = str(flow.get("code_verifier") or "").strip()
if not code_verifier:
raise ValueError("VK ID flow истек. Запусти вход еще раз")
device_id = str(device_id or "").strip()
if not device_id:
raise ValueError("VK ID не вернул device_id")
token_payload = {
"grant_type": "authorization_code",
"client_id": cfg["client_id"],
"code": code,
"redirect_uri": redirect_uri,
"code_verifier": code_verifier,
"device_id": device_id,
"state": str(flow_state or "").strip(),
}
service_token = str(cfg.get("client_secret") or "").strip()
if service_token:
token_payload["service_token"] = service_token
token = oauth_fetch_json(
SOCIAL_PROVIDERS[provider]["token_url"],
method="POST",
headers={"Accept": "application/json"},
data=token_payload,
)
access_token = str(token.get("access_token") or "").strip()
if not access_token:
raise ValueError(token.get("error_description") or token.get("error") or "VK ID не вернул access token")
token_state = str(token.get("state") or "").strip()
if token_state and token_state != str(flow_state or "").strip():
raise ValueError("VK ID вернул неожиданный state")
profile = oauth_fetch_json(
SOCIAL_PROVIDERS[provider]["api_url"],
method="POST",
headers={"Accept": "application/json"},
data={
"client_id": cfg["client_id"],
"access_token": access_token,
},
)
user = profile.get("user") if isinstance(profile.get("user"), dict) else {}
account_id = str(token.get("user_id") or user.get("user_id") or "").strip()
if not account_id:
raise ValueError("VK ID не вернул ID пользователя")
first_name = str(user.get("first_name") or "").strip()
last_name = str(user.get("last_name") or "").strip()
full_name = " ".join(part for part in (first_name, last_name) if part).strip()
email = str(user.get("email") or "").strip()
return {
"id": account_id,
"label": full_name or email or f"VK ID {account_id}",
"login": "",
"name": full_name,
"email": email,
"profile_url": f"https://vk.com/id{account_id}",
"avatar_url": str(user.get("avatar") or "").strip(),
}
raise ValueError("Неизвестный OAuth provider")
def serve_acme_challenge(self, path):
prefix = "/.well-known/acme-challenge/"
token = urllib.parse.unquote(path[len(prefix):])
if not token or "/" in token or "\\" in token:
self.send_text(404, "not found")
return
challenge_path = ACME_WEBROOT / ".well-known" / "acme-challenge" / token
try:
body = challenge_path.read_bytes()
except OSError:
self.send_text(404, "not found")
return
self.send_bytes(200, body, "text/plain; charset=utf-8")
def redirect(self, location, extra_headers=None):
self.close_connection = True
self.send_response(302)
self.send_header("Location", location)
self.send_header("Content-Length", "0")
self.send_header("Connection", "close")
if extra_headers:
for key, value in extra_headers:
self.send_header(key, value)
self.end_headers()
def login(self):
payload = self.read_payload()
username = payload.get("username", "")
password = payload.get("password", "")
otp = payload.get("otp", "")
captcha_token = payload.get("captcha_token", "")
captcha_answer = payload.get("captcha_answer", "")
if not verify_captcha(captcha_token, captcha_answer):
self.send_bytes(401, login_html("Неверная капча").encode("utf-8"), "text/html; charset=utf-8")
return
ok, error_text, auth, auth_method = verify_password_login(username, password, otp)
if ok:
token, _ = self.create_login_session((auth or {}).get("username", username), auth_method)
self.redirect("/", [("Set-Cookie", self.session_cookie(token))])
return
self.send_bytes(401, login_html(error_text or "Неверный логин или пароль").encode("utf-8"), "text/html; charset=utf-8")
def login(self):
payload = self.read_payload()
username = payload.get("username", "")
password = payload.get("password", "")
otp = payload.get("otp", "")
captcha_ok, captcha_error = self.verify_login_captcha(payload)
if not captcha_ok:
self.send_bytes(401, login_html(captcha_error or "Неверная капча").encode("utf-8"), "text/html; charset=utf-8")
return
ok, error_text, auth, auth_method = verify_password_login(username, password, otp)
if ok:
token, _ = self.create_login_session((auth or {}).get("username", username), auth_method)
self.redirect("/", [("Set-Cookie", self.session_cookie(token))])
return
self.send_bytes(401, login_html(error_text or "Неверный логин или пароль").encode("utf-8"), "text/html; charset=utf-8")
def update_auth(self):
payload = self.read_payload()
auth = load_auth()
current_password = payload.get("current_password", "")
if not verify_login(auth.get("username", ""), current_password):
self.send_text(403, "Текущий пароль неверный")
return
username = payload.get("username", auth.get("username", "admin"))
new_password = payload.get("password", "")
confirm = payload.get("password_confirm", "")
if new_password:
if new_password != confirm:
self.send_text(400, "Новый пароль и повтор не совпадают")
return
if len(new_password) < MIN_PASSWORD_LENGTH:
self.send_text(400, f"Новый пароль должен быть минимум {MIN_PASSWORD_LENGTH} символа")
return
save_auth(username, new_password)
else:
clean = clean_username(username)
auth["username"] = clean
save_auth_state(auth)
self.send_text(200, "Доступ к Hub обновлен")
def update_auth(self):
payload = self.read_payload()
auth = normalize_auth_state(load_auth())
current_password = payload.get("current_password", "")
if not verify_login(auth.get("username", ""), current_password):
self.send_text(403, "Текущий пароль неверный")
return
username = payload.get("username", auth.get("username", "admin"))
new_password = payload.get("password", "")
confirm = payload.get("password_confirm", "")
captcha_mode = sanitize_captcha_mode(payload.get("captcha_mode"))
captcha_site_key = str(payload.get("captcha_site_key") or "").strip()
captcha_secret_key = str(payload.get("captcha_secret_key") or "").strip()
if new_password:
if new_password != confirm:
self.send_text(400, "Новый пароль и повтор не совпадают")
return
if len(new_password) < MIN_PASSWORD_LENGTH:
self.send_text(400, f"Новый пароль должен быть минимум {MIN_PASSWORD_LENGTH} символа")
return
if captcha_mode == CAPTCHA_MODE_RECAPTCHA and not (captcha_site_key and captcha_secret_key):
self.send_text(400, "Для Google reCAPTCHA нужны Site Key и Secret Key")
return
auth["username"] = clean_username(username)
if new_password:
auth["password"] = password_digest(new_password)
auth["captcha"] = sanitize_captcha_state(
{
"mode": captcha_mode,
"site_key": captcha_site_key,
"secret_key": captcha_secret_key,
}
)
auth["updated_at"] = now_ts()
save_auth_state(auth)
self.send_text(200, "Доступ к Hub обновлен")
def build_auth_meta(self):
auth = normalize_auth_state(load_auth())
current = self.current_account_profile(touch=False) if self.admin_ok() else None
if current and current.get("is_owner"):
meta = admin_auth_meta(auth)
with self.app.conn() as conn:
router_rows = list_router_rows(conn)
session_rows_by_username = {}
for session in list_hub_sessions("", ""):
username = str(session.get("username") or "")
if not username:
continue
session_rows_by_username.setdefault(username, []).append(session)
login_rows_by_username = {}
for event in list_login_events(""):
username = str(event.get("username") or "")
if not username:
continue
login_rows_by_username.setdefault(username, []).append(event)
meta["username"] = current.get("username", auth.get("username", "admin"))
meta["is_owner"] = True
meta["can_add_router"] = True
meta["current_user"] = {
"username": current.get("username", auth.get("username", "admin")),
"is_owner": True,
}
meta["router_options"] = [
{
"id": router.get("id", ""),
"name": router.get("name", ""),
"role": router.get("role", "node"),
}
for router in [row_to_router(row) for row in router_rows]
]
meta["delegated_users"] = [
item
for item in (
serialize_delegated_user(
auth,
user,
router_rows,
session_rows_by_username.get(str((user or {}).get("username") or ""), []),
login_rows_by_username.get(str((user or {}).get("username") or ""), []),
)
for user in auth.get("delegated_users", [])
)
if item
]
elif current:
with self.app.conn() as conn:
router_rows = list_router_rows(conn)
meta = delegated_auth_meta(auth, current, router_rows)
else:
meta = public_auth_meta(auth)
meta["can_add_router"] = False
social = meta.get("social") if isinstance(meta.get("social"), dict) else {}
for provider, item in social.items():
if not isinstance(item, dict):
continue
item["redirect_uri"] = self.social_callback_url(provider)
return meta
def auth_meta(self):
self.send_json(200, {"ok": True, "auth": self.build_auth_meta()})
def save_delegated_user(self):
try:
payload = self.read_payload()
auth = self.require_current_password(payload)
username = clean_username(payload.get("username", ""))
if secrets.compare_digest(username, auth.get("username", "")):
raise ValueError("Главный аккаунт нельзя превратить в ограниченный")
user_id = str(payload.get("id") or "").strip()
password = str(payload.get("password") or "")
password_confirm = str(payload.get("password_confirm") or "")
if password:
if password != password_confirm:
raise ValueError("Пароль и повтор не совпадают")
if len(password) < MIN_PASSWORD_LENGTH:
raise ValueError(f"Пароль должен быть минимум {MIN_PASSWORD_LENGTH} символа")
next_password = password_digest(password)
else:
next_password = None
router_flags = sanitize_router_access_map(payload.get("router_flags"))
enabled = bool(payload.get("enabled", True))
existing = None
for item in auth.get("delegated_users", []):
if user_id and item.get("id") == user_id:
existing = item
break
for item in auth.get("delegated_users", []):
if existing and item.get("id") == existing.get("id"):
continue
if secrets.compare_digest(item.get("username", ""), username):
raise ValueError("Пользователь с таким логином уже существует")
if existing is None and next_password is None:
raise ValueError("Для нового пользователя нужен пароль")
updated_users = []
replaced = False
for item in auth.get("delegated_users", []):
if existing and item.get("id") == existing.get("id"):
updated_users.append(
{
**item,
"username": username,
"password": next_password or item.get("password", {}),
"enabled": enabled,
"router_flags": router_flags,
"updated_at": now_ts(),
}
)
replaced = True
continue
updated_users.append(item)
if not replaced:
updated_users.append(
{
"id": user_id or secrets.token_hex(8),
"username": username,
"password": next_password,
"enabled": enabled,
"router_flags": router_flags,
"created_at": now_ts(),
"updated_at": now_ts(),
}
)
auth = save_auth_state({**auth, "delegated_users": updated_users})
self.send_json(200, {"ok": True, "message": "Пользователь сохранен", "auth": self.build_auth_meta()})
except ValueError as exc:
self.send_json(400, {"ok": False, "error": str(exc)})
except Exception as exc:
self.send_json(500, {"ok": False, "error": str(exc)})
def delete_delegated_user(self):
try:
payload = self.read_payload()
auth = self.require_current_password(payload)
user_id = str(payload.get("id") or "").strip()
if not user_id:
raise ValueError("Не указан пользователь")
removed = 0
removed_username = ""
kept = []
for item in auth.get("delegated_users", []):
if item.get("id") == user_id:
removed += 1
removed_username = str(item.get("username") or "")
continue
kept.append(item)
if not removed:
raise ValueError("Пользователь уже удален")
revoke_hub_sessions_for_username(removed_username)
auth = save_auth_state({**auth, "delegated_users": kept})
self.send_json(200, {"ok": True, "message": "Пользователь удален", "auth": self.build_auth_meta()})
except ValueError as exc:
self.send_json(400, {"ok": False, "error": str(exc)})
except Exception as exc:
self.send_json(500, {"ok": False, "error": str(exc)})
def revoke_delegated_user_sessions(self):
try:
payload = self.read_payload()
auth = self.require_current_password(payload)
user_id = str(payload.get("id") or "").strip()
if not user_id:
raise ValueError("Не указан пользователь")
target = next((item for item in auth.get("delegated_users", []) if item.get("id") == user_id), None)
if not target:
raise ValueError("Пользователь не найден")
target_username = str(target.get("username") or "").strip()
removed = revoke_hub_sessions_for_username(target_username)
self.send_json(
200,
{
"ok": True,
"removed": removed,
"message": "Сессии пользователя завершены" if removed else "У пользователя нет активных сессий",
"auth": self.build_auth_meta(),
},
)
except ValueError as exc:
self.send_json(400, {"ok": False, "error": str(exc)})
except Exception as exc:
self.send_json(500, {"ok": False, "error": str(exc)})
def save_social_provider_config(self, provider):
try:
payload = self.read_payload()
auth = self.require_current_password(payload)
provider = str(provider or "").strip().lower()
if provider not in SOCIAL_PROVIDERS:
raise ValueError("Неизвестный OAuth provider")
client_id = str(payload.get("client_id") or "").strip()
client_secret = str(payload.get("client_secret") or "").strip()
def mutator(current):
current = normalize_auth_state(current)
current["social"][provider]["client_id"] = client_id
current["social"][provider]["client_secret"] = client_secret
return current
save_auth_state(mutator(auth))
self.send_json(
200,
{
"ok": True,
"auth": self.build_auth_meta(admin=True),
"message": f"{social_provider_label(provider)} сохранен",
},
)
except ValueError as exc:
self.send_json(400, {"ok": False, "error": str(exc)})
except Exception as exc:
self.send_json(500, {"ok": False, "error": str(exc)})
def begin_social_link(self, provider):
try:
payload = self.read_payload()
auth = self.require_current_password(payload)
provider = str(provider or "").strip().lower()
redirect_uri = self.social_callback_url(provider)
cfg = self.social_provider_config(provider, auth)
if not social_provider_configured(provider, cfg):
raise ValueError(social_provider_setup_message(provider))
flow_payload = {
"provider": provider,
"mode": "link",
"redirect_uri": redirect_uri,
}
if provider == "vk":
flow_payload["code_verifier"] = make_pkce_verifier()
ticket = put_auth_flow(f"oauth-{provider}", flow_payload)
self.send_json(
200,
{
"ok": True,
"url": self.social_flow_authorize_url(provider, ticket, redirect_uri, flow=flow_payload),
},
)
except ValueError as exc:
self.send_json(400, {"ok": False, "error": str(exc)})
except Exception as exc:
self.send_json(500, {"ok": False, "error": str(exc)})
def unlink_social_account(self, provider):
try:
payload = self.read_payload()
auth = self.require_current_password(payload)
provider = str(provider or "").strip().lower()
account_id = str(payload.get("id") or "").strip()
if not account_id:
raise ValueError("Не указан аккаунт для отвязки")
if not find_social_account_record(auth, provider, account_id):
raise ValueError("Аккаунт уже отвязан")
updated = save_auth_state(remove_social_account(auth, provider, account_id))
self.send_json(
200,
{
"ok": True,
"auth": self.build_auth_meta(admin=True),
"message": f"{social_provider_label(provider)} отвязан",
},
)
except ValueError as exc:
self.send_json(400, {"ok": False, "error": str(exc)})
except Exception as exc:
self.send_json(500, {"ok": False, "error": str(exc)})
def start_social_login(self, provider):
provider = str(provider or "").strip().lower()
try:
redirect_uri = self.social_callback_url(provider)
cfg = self.social_provider_config(provider)
if not social_provider_configured(provider, cfg):
raise ValueError(social_provider_setup_message(provider))
if not cfg.get("accounts"):
raise ValueError(f"Для {social_provider_label(provider)} пока нет привязанных аккаунтов")
flow_payload = {
"provider": provider,
"mode": "login",
"redirect_uri": redirect_uri,
}
if provider == "vk":
flow_payload["code_verifier"] = make_pkce_verifier()
ticket = put_auth_flow(f"oauth-{provider}", flow_payload)
self.redirect(self.social_flow_authorize_url(provider, ticket, redirect_uri, flow=flow_payload))
except ValueError as exc:
self.send_bytes(400, self.social_login_error_page(str(exc)).encode("utf-8"), "text/html; charset=utf-8")
except Exception as exc:
self.send_bytes(500, self.social_login_error_page(str(exc)).encode("utf-8"), "text/html; charset=utf-8")
def finish_social_callback(self, provider):
provider = str(provider or "").strip().lower()
params = self.query()
flow_state = str(params.get("state", [""])[0] or "")
error_code = str(params.get("error", [""])[0] or "")
error_text = str(params.get("error_description", [""])[0] or params.get("error_reason", [""])[0] or error_code or "")
flow = None
try:
flow = pop_auth_flow(flow_state, f"oauth-{provider}")
if not flow:
raise ValueError("OAuth сессия истекла или уже была использована")
if error_code:
raise ValueError(error_text or f"{social_provider_label(provider)} вернул ошибку авторизации")
code = str(params.get("code", [""])[0] or "").strip()
if not code:
raise ValueError("OAuth provider не вернул код авторизации")
device_id = str(params.get("device_id", [""])[0] or "").strip()
account = self.exchange_social_code(
provider,
code,
str(flow.get("redirect_uri") or self.social_callback_url(provider)),
flow=flow,
flow_state=flow_state,
device_id=device_id,
)
if flow.get("mode") == "link":
updated = save_auth_state(upsert_social_account(load_auth(), provider, account))
message = f"{social_provider_label(provider)} аккаунт {account.get('label') or account.get('id')} привязан"
self.send_bytes(
200,
self.oauth_popup_html(social_provider_label(provider), message, provider=provider, ok=True).encode("utf-8"),
"text/html; charset=utf-8",
)
return
auth = load_auth()
linked = find_social_account_record(auth, provider, account.get("id"))
if not linked:
raise ValueError("Этот аккаунт не привязан к Hub. Сначала привяжи его в разделе Доступ к Hub.")
save_auth_state(touch_social_account_last_used(auth, provider, account.get("id")))
token, _ = self.create_login_session(current_username(), auth_method=provider)
self.redirect("/", [("Set-Cookie", self.session_cookie(token))])
except ValueError as exc:
if (flow or {}).get("mode") == "link":
self.send_bytes(
400,
self.oauth_popup_html(social_provider_label(provider), str(exc), provider=provider, ok=False).encode("utf-8"),
"text/html; charset=utf-8",
)
return
self.send_bytes(400, self.social_login_error_page(str(exc)).encode("utf-8"), "text/html; charset=utf-8")
except Exception as exc:
self.send_bytes(500, self.social_login_error_page(str(exc)).encode("utf-8"), "text/html; charset=utf-8")
def totp_setup(self):
try:
payload = self.read_payload()
auth = self.require_current_password(payload)
secret = generate_totp_secret()
ticket = put_auth_flow("totp-setup", {"secret": secret, "username": auth.get("username", "admin")})
self.send_json(
200,
{
"ok": True,
"ticket": ticket,
"secret": secret,
"otpauth_uri": totp_otpauth_uri(auth.get("username", "admin"), secret),
"digits": TOTP_DIGITS,
"period": TOTP_PERIOD_SECONDS,
},
)
except Exception as exc:
self.send_json(400, {"ok": False, "error": str(exc)})
def totp_enable(self):
try:
payload = self.read_payload()
self.require_current_password(payload)
ticket = payload.get("ticket", "")
flow = get_auth_flow(ticket, "totp-setup")
if not flow:
raise ValueError("Сессия настройки 2FA истекла, начни заново")
secret = flow.get("secret", "")
if not verify_totp(secret, payload.get("code", "")):
raise ValueError("Неверный код 2FA")
pop_auth_flow(ticket, "totp-setup")
auth = update_auth_state(
lambda current: {
**current,
"totp": {
**default_totp_state(),
"enabled": True,
"secret": secret,
"digits": TOTP_DIGITS,
"period": TOTP_PERIOD_SECONDS,
"updated_at": now_ts(),
},
}
)
self.send_json(200, {"ok": True, "message": "2FA включена", "auth": admin_auth_meta(auth)})
except Exception as exc:
self.send_json(400, {"ok": False, "error": str(exc)})
def totp_disable(self):
try:
payload = self.read_payload()
auth = self.require_current_password(payload)
if not auth.get("totp", {}).get("enabled"):
raise ValueError("2FA уже выключена")
if not verify_totp(auth.get("totp", {}).get("secret", ""), payload.get("code", "")):
raise ValueError("Неверный код 2FA")
auth = update_auth_state(
lambda current: {
**current,
"totp": {
**default_totp_state(),
"updated_at": now_ts(),
},
}
)
self.send_json(200, {"ok": True, "message": "2FA выключена", "auth": admin_auth_meta(auth)})
except Exception as exc:
self.send_json(400, {"ok": False, "error": str(exc)})
def begin_passkey_registration(self):
try:
payload = self.read_payload()
auth = self.require_current_password(payload)
server = self.build_webauthn_server()
label = str(payload.get("label") or f"Passkey {len(auth.get('passkeys', [])) + 1}").strip()[:80] or "Passkey"
options, state = server.register_begin(
{
"id": auth.get("username", "admin").encode("utf-8"),
"name": auth.get("username", "admin"),
"displayName": auth.get("username", "admin"),
},
passkey_credentials(auth),
resident_key_requirement=ResidentKeyRequirement.PREFERRED if ResidentKeyRequirement else None,
user_verification=UserVerificationRequirement.PREFERRED if UserVerificationRequirement else None,
)
ticket = put_auth_flow(
"passkey-register",
{"state": state, "label": label, "username": auth.get("username", "admin")},
)
self.send_json(200, {"ok": True, "ticket": ticket, "options": webauthn_json(dict(options))})
except Exception as exc:
self.send_json(400, {"ok": False, "error": str(exc)})
def finish_passkey_registration(self):
try:
payload = self.read_payload()
ticket = payload.get("ticket", "")
response = payload.get("credential") if isinstance(payload.get("credential"), dict) else payload
flow = pop_auth_flow(ticket, "passkey-register")
if not flow:
raise ValueError("Passkey-регистрация истекла, начни заново")
server = self.build_webauthn_server()
auth_data = server.register_complete(flow.get("state"), response)
credential_data = auth_data.credential_data
if not credential_data:
raise ValueError("Не удалось прочитать credential data")
key_id = b64url(credential_data.credential_id)
label = str(flow.get("label") or "Passkey").strip()[:80] or "Passkey"
def mutator(current):
current = normalize_auth_state(current)
rows = [item for item in current.get("passkeys", []) if item.get("id") != key_id]
rows.append(
{
"id": key_id,
"label": label,
"credential_data": b64url(bytes(credential_data)),
"created_at": now_ts(),
"last_used_at": 0,
"sign_count": int(auth_data.counter or 0),
"transports": [str(value).strip() for value in payload.get("transports", []) if str(value).strip()],
}
)
current["passkeys"] = rows
return current
auth = update_auth_state(mutator)
self.send_json(200, {"ok": True, "message": "Passkey добавлен", "auth": admin_auth_meta(auth)})
except Exception as exc:
self.send_json(400, {"ok": False, "error": str(exc)})
def remove_passkey(self):
try:
payload = self.read_payload()
self.require_current_password(payload)
credential_id = str(payload.get("id") or "").strip()
if not credential_id:
raise ValueError("id passkey пустой")
def mutator(current):
current = normalize_auth_state(current)
current["passkeys"] = [item for item in current.get("passkeys", []) if item.get("id") != credential_id]
return current
auth = update_auth_state(mutator)
self.send_json(200, {"ok": True, "message": "Passkey удален", "auth": admin_auth_meta(auth)})
except Exception as exc:
self.send_json(400, {"ok": False, "error": str(exc)})
def begin_passkey_login(self):
try:
auth = load_auth()
passkey_info = passkey_inventory(auth)
credentials = passkey_info.get("credentials", [])
if not credentials:
if passkey_info.get("invalid_count"):
raise ValueError("Сохраненный passkey поврежден или записан в старом формате. Удали его в меню доступа и зарегистрируй заново")
raise ValueError("Для входа Passkey пока не зарегистрирован")
server = self.build_webauthn_server()
options, state = server.authenticate_begin(
credentials,
user_verification=UserVerificationRequirement.PREFERRED if UserVerificationRequirement else None,
)
ticket = put_auth_flow("passkey-login", {"state": state, "username": auth.get("username", "admin")})
self.send_json(200, {"ok": True, "ticket": ticket, "options": webauthn_json(dict(options))})
except Exception as exc:
self.send_json(400, {"ok": False, "error": str(exc)})
def finish_passkey_login(self):
try:
payload = self.read_payload()
ticket = payload.get("ticket", "")
response = payload.get("credential") if isinstance(payload.get("credential"), dict) else payload
flow = pop_auth_flow(ticket, "passkey-login")
if not flow:
raise ValueError("Passkey-челлендж истек, начни вход заново")
auth = load_auth()
passkey_info = passkey_inventory(auth)
credentials = passkey_info.get("credentials", [])
if not credentials:
if passkey_info.get("invalid_count"):
raise ValueError("Сохраненный passkey поврежден или записан в старом формате. Удали его в меню доступа и зарегистрируй заново")
raise ValueError("Passkey не зарегистрирован")
server = self.build_webauthn_server()
credential = server.authenticate_complete(flow.get("state"), credentials, response)
key_id = b64url(credential.credential_id)
counter = 0
if AuthenticationResponse is not None:
try:
auth_response = AuthenticationResponse.from_dict(response)
counter = int(auth_response.response.authenticator_data.counter or 0)
except Exception:
counter = 0
def mutator(current):
current = normalize_auth_state(current)
for item in current.get("passkeys", []):
if item.get("id") == key_id:
item["last_used_at"] = now_ts()
item["sign_count"] = max(int(item.get("sign_count") or 0), counter)
break
return current
update_auth_state(mutator)
self.send_login_json(auth.get("username", "admin"), "passkey")
except Exception as exc:
self.send_json(400, {"ok": False, "error": str(exc)})
def add_ssh_key(self):
try:
payload = self.read_payload()
self.require_current_password(payload)
key = sanitize_ssh_key_record(
{
"id": payload.get("id", ""),
"label": payload.get("label", ""),
"public_key": payload.get("public_key", ""),
"created_at": now_ts(),
}
)
if not key:
raise ValueError("SSH ED25519 ключ не распознан")
def mutator(current):
current = normalize_auth_state(current)
rows = [item for item in current.get("ssh_keys", []) if item.get("public_key") != key.get("public_key")]
rows.append(key)
current["ssh_keys"] = rows
return current
auth = update_auth_state(mutator)
self.send_json(200, {"ok": True, "message": "SSH ED25519 ключ добавлен", "auth": admin_auth_meta(auth)})
except Exception as exc:
self.send_json(400, {"ok": False, "error": str(exc)})
def remove_ssh_key(self):
try:
payload = self.read_payload()
self.require_current_password(payload)
key_id = str(payload.get("id") or "").strip()
if not key_id:
raise ValueError("id SSH ключа пустой")
def mutator(current):
current = normalize_auth_state(current)
current["ssh_keys"] = [item for item in current.get("ssh_keys", []) if item.get("id") != key_id]
return current
auth = update_auth_state(mutator)
self.send_json(200, {"ok": True, "message": "SSH ключ удален", "auth": admin_auth_meta(auth)})
except Exception as exc:
self.send_json(400, {"ok": False, "error": str(exc)})
def begin_ssh_login(self):
try:
auth = load_auth()
ssh_keys = auth.get("ssh_keys", [])
if not ssh_keys:
raise ValueError("Для входа ED25519 пока нет зарегистрированных ключей")
issued_at = now_ts()
host = self.request_host()
ticket = put_auth_flow("ssh-login", {"username": auth.get("username", "admin"), "issued_at": issued_at, "host": host})
challenge = build_ssh_auth_message(ticket, auth.get("username", "admin"), host, issued_at)
with AUTH_FLOW_LOCK:
state = AUTH_FLOW_STATE.get(ticket)
if state:
state["challenge"] = challenge
self.send_json(
200,
{
"ok": True,
"ticket": ticket,
"challenge": challenge,
"namespace": ssh_auth_namespace(),
"principal": ssh_auth_principal(auth.get("username", "admin")),
"keys": public_auth_meta(auth).get("ssh_keys", []),
},
)
except Exception as exc:
self.send_json(400, {"ok": False, "error": str(exc)})
def finish_ssh_login(self):
try:
payload = self.read_payload()
ticket = str(payload.get("ticket") or "").strip()
flow = pop_auth_flow(ticket, "ssh-login")
if not flow:
raise ValueError("ED25519-челлендж истек, начни вход заново")
auth = load_auth()
challenge = str(flow.get("challenge") or "")
if not challenge:
challenge = build_ssh_auth_message(
ticket,
auth.get("username", "admin"),
flow.get("host", "") or self.request_host(),
flow.get("issued_at", 0),
)
matched = verify_ssh_auth_signature(auth.get("ssh_keys", []), auth.get("username", "admin"), challenge, payload.get("signature", ""))
def mutator(current):
current = normalize_auth_state(current)
for item in current.get("ssh_keys", []):
if item.get("id") == matched.get("id"):
item["last_used_at"] = now_ts()
break
return current
update_auth_state(mutator)
self.send_login_json(auth.get("username", "admin"), "ed25519")
except Exception as exc:
self.send_json(400, {"ok": False, "error": str(exc)})
def router_id_from_path(self, prefix):
suffix = self.parsed().path[len(prefix):].strip("/")
if not suffix:
return ""
return urllib.parse.unquote(suffix.split("/", 1)[0])
def ssh_page(self):
router_id = self.router_id_from_path("/ssh/")
if not self.require_router_access(router_id, "B"):
return
with self.app.conn() as conn:
row = get_active_router(conn, router_id)
if not row:
self.send_text(404, "router not found")
return
if int(row["ssh_entry_port"] or 0) <= 0:
self.send_text(400, "router has no ssh_entry_port")
return
ws_token = ssh_ws_token(self.app.session_token, router_id)
self.send_bytes(
200,
ssh_terminal_html_v2(row, ws_token).encode("utf-8"),
"text/html; charset=utf-8",
[("Set-Cookie", current_router_cookie(router_id))],
)
def vps_terminal_page(self):
if not self.require_owner():
return
row = vps_terminal_row()
ws_token = ssh_ws_token(self.app.session_token, row["id"])
public_host = urllib.parse.urlsplit(self.app.public_url).hostname if self.app.public_url else ""
if not public_host:
public_host = self.headers.get("Host", "").split(":", 1)[0]
quick_commands_html = vps_quick_commands_html(public_host or "YOUR_VPS_IP")
self.send_bytes(200, ssh_terminal_html_v2(row, ws_token, quick_commands_html).encode("utf-8"), "text/html; charset=utf-8")
def ssh_ws(self):
try:
self.connection.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
except OSError:
pass
router_id = self.router_id_from_path("/ssh-ws/")
if self.ssh_token_ok(router_id):
allowed = True
elif is_vps_terminal_id(router_id):
allowed = self.owner_ok()
else:
allowed = self.router_access_allowed(router_id, "B")
if not allowed:
self.send_response(403 if self.admin_ok() else 401)
self.end_headers()
return
if not is_vps_terminal_id(router_id):
with self.app.conn() as conn:
row = get_active_router(conn, router_id)
if not row:
self.send_response(404)
self.end_headers()
return
port = int(row["ssh_entry_port"] or 0)
if port <= 0:
self.send_response(400)
self.end_headers()
return
key = self.headers.get("Sec-WebSocket-Key", "")
if not key:
self.send_response(400)
self.end_headers()
return
self.send_response(101)
self.send_header("Upgrade", "websocket")
self.send_header("Connection", "Upgrade")
self.send_header("Sec-WebSocket-Accept", ws_accept_value(key))
self.end_headers()
self.close_connection = True
if is_vps_terminal_id(router_id):
self.run_vps_terminal_session()
return
self.run_ssh_session(router_id, port)
def ssh_check(self):
router_id = self.router_id_from_path("/api/ssh/")
if router_id.endswith("/check"):
router_id = router_id[:-6].rstrip("/")
if self.ssh_token_ok(router_id):
allowed = True
elif is_vps_terminal_id(router_id):
allowed = self.owner_ok()
else:
allowed = self.router_access_allowed(router_id, "B")
if not allowed:
self.send_json(403, {"ok": False, "error": "not authorized", "tcp_ok": False})
return
if is_vps_terminal_id(router_id):
self.send_json(200, {"ok": True, "router_id": router_id, "tcp_ok": True, "mode": "local-shell"})
return
with self.app.conn() as conn:
row = get_active_router(conn, router_id)
if not row:
self.send_json(404, {"ok": False, "error": "router not found", "tcp_ok": False})
return
port = int(row["ssh_entry_port"] or 0)
if port <= 0:
self.send_json(200, {"ok": False, "error": "router has no ssh_entry_port", "tcp_ok": False})
return
try:
with socket.create_connection(("127.0.0.1", port), timeout=3):
pass
self.send_json(200, {"ok": True, "router_id": router_id, "port": port, "tcp_ok": True})
except Exception as exc:
self.send_json(200, {"ok": False, "router_id": router_id, "port": port, "tcp_ok": False, "error": str(exc)})
def ssh_args(self, port):
env = os.environ.copy()
env["TERM"] = "xterm-256color"
args = [
"ssh",
"-tt",
"-o",
"StrictHostKeyChecking=no",
"-o",
"UserKnownHostsFile=/dev/null",
"-o",
"GlobalKnownHostsFile=/dev/null",
"-o",
"LogLevel=ERROR",
"-o",
"ServerAliveInterval=15",
"-p",
str(port),
"root@127.0.0.1",
]
return env, args
def ssh_exec_args(self, port, allow_password=False):
env = os.environ.copy()
env.setdefault("LC_ALL", "C.UTF-8")
args = [
"ssh",
"-o",
"StrictHostKeyChecking=no",
"-o",
"UserKnownHostsFile=/dev/null",
"-o",
"GlobalKnownHostsFile=/dev/null",
"-o",
"LogLevel=ERROR",
"-o",
"ConnectTimeout=8",
"-o",
"NumberOfPasswordPrompts=1",
"-p",
str(port),
"root@127.0.0.1",
]
if allow_password:
args[1:1] = [
"-o",
"PreferredAuthentications=publickey,password,keyboard-interactive",
]
else:
args[1:1] = ["-o", "BatchMode=yes"]
return env, args
def router_ssh_tcp_status(self, row, timeout=2):
port = int(row["ssh_entry_port"] or 0) if row else 0
if port <= 0:
return False, 0, "router has no ssh_entry_port"
try:
with socket.create_connection(("127.0.0.1", port), timeout=float(timeout)):
pass
return True, port, ""
except Exception as exc:
return False, port, str(exc)
def prepare_ssh_askpass(self, env, ssh_password):
password = str(ssh_password or "")
if not password:
return None
askpass_dir = Path(tempfile.mkdtemp(prefix="owrt-askpass-"))
askpass_script = askpass_dir / "askpass.sh"
askpass_script.write_text(
"#!/bin/sh\nprintf '%s\\n' \"$OWRT_REMOTE_SSH_PASSWORD\"\n",
encoding="utf-8",
)
os.chmod(askpass_script, 0o700)
env["SSH_ASKPASS"] = str(askpass_script)
env["SSH_ASKPASS_REQUIRE"] = "force"
env["DISPLAY"] = env.get("DISPLAY") or "owrt-remote:0"
env["OWRT_REMOTE_SSH_PASSWORD"] = password
return askpass_dir
def normalize_wol_mac(self, value):
mac = str(value or "").strip().upper().replace("-", ":")
if not mac:
return ""
compact = re.sub(r"[^0-9A-F]", "", mac)
if len(compact) == 12:
mac = ":".join(compact[idx : idx + 2] for idx in range(0, 12, 2))
if not re.fullmatch(r"(?:[0-9A-F]{2}:){5}[0-9A-F]{2}", mac):
return ""
if mac == "00:00:00:00:00:00":
return ""
return mac
def run_router_ssh_script(self, row, script, script_args=None, timeout=15, ssh_password=""):
port = int(row["ssh_entry_port"] or 0) if row else 0
if port <= 0:
raise RuntimeError("router has no ssh_entry_port")
password = str(ssh_password or "")
env, args = self.ssh_exec_args(port, allow_password=bool(password))
askpass_dir = self.prepare_ssh_askpass(env, password)
argv = args + ["sh", "-s", "--"] + [str(item) for item in (script_args or [])]
try:
result = subprocess.run(
argv,
input=str(script),
text=True,
capture_output=True,
timeout=float(timeout),
env=env,
start_new_session=bool(password),
)
except subprocess.TimeoutExpired as exc:
raise RuntimeError(f"ssh command timeout after {int(timeout)}s") from exc
finally:
if askpass_dir:
try:
for child in askpass_dir.iterdir():
child.unlink(missing_ok=True)
askpass_dir.rmdir()
except OSError:
pass
if result.returncode != 0:
message = (result.stderr or result.stdout or "").strip()
raise RuntimeError(message or f"ssh command exited with code {result.returncode}")
return result.stdout
def wait_router_heartbeat(self, router_id, last_seen_before=0, timeout=6):
deadline = time.time() + max(float(timeout), 0.0)
seen_before = int(last_seen_before or 0)
while time.time() <= deadline:
with self.app.conn() as conn:
row = get_active_router(conn, router_id)
if row:
try:
last_seen = int(row["last_seen"] or 0)
except (TypeError, ValueError):
last_seen = 0
if last_seen > seen_before:
return True, row
time.sleep(1)
with self.app.conn() as conn:
row = get_active_router(conn, router_id)
return False, row
def apply_router_rebind_via_ssh(self, row, ssh_password="", request_origin=""):
router_id = row_str_value(row, "id")
last_seen_before = row_int_value(row, "last_seen", 0)
tcp_ok, port, tcp_error = self.router_ssh_tcp_status(row)
result = {
"id": router_id,
"name": row_str_value(row, "name", router_id),
"port": port,
"tcp_ok": bool(tcp_ok),
"status": "pending",
"heartbeat_confirmed": False,
"error": "",
}
if not tcp_ok:
result["status"] = "unreachable"
result["error"] = tcp_error or "ssh tunnel is unreachable"
return result
hub_update, hub_url, config_vps_host = router_current_hub_bundle(
row,
self.app.public_url,
request_origin,
self.headers.get("Host", ""),
)
script = make_openwrt_ssh_apply_script(
row,
hub_url,
vps_host_override=config_vps_host,
public_url_override=hub_update.get("public_url", ""),
)
try:
output = self.run_router_ssh_script(
row,
script,
timeout=12,
ssh_password=ssh_password,
).strip()
result["status"] = "applied"
if output:
result["output"] = output
except Exception as exc:
result["status"] = "failed"
result["error"] = str(exc)
return result
confirmed, fresh_row = self.wait_router_heartbeat(router_id, last_seen_before=last_seen_before, timeout=6)
result["heartbeat_confirmed"] = bool(confirmed)
result["status"] = "confirmed" if confirmed else "applied"
if fresh_row:
result["last_seen"] = row_int_value(fresh_row, "last_seen", 0)
return result
def discover_router_wol_devices(self, row, ssh_password=""):
script = r"""
set -eu
tmp="${TMPDIR:-/tmp}/owrt-wol.$$.txt"
cleanup() {
rm -f "$tmp"
}
trap cleanup EXIT INT TERM
: >"$tmp"
if [ -f /tmp/dhcp.leases ]; then
while read -r lease_ts mac ip host client_id; do
[ -n "${mac:-}" ] || continue
[ "${mac:-}" = "*" ] && continue
[ "${host:-}" = "*" ] && host=""
printf '%s\t%s\t%s\t%s\t%s\n' "$mac" "${ip:-}" "${host:-}" "" "dhcp" >>"$tmp"
done /dev/null 2>&1; then
uci -q show dhcp | sed -n "s/^\(dhcp\.[^=]*\)=host$/\1/p" | while IFS= read -r section; do
[ -n "$section" ] || continue
mac_list="$(uci -q get "$section.mac" 2>/dev/null || true)"
ip_static="$(uci -q get "$section.ip" 2>/dev/null || true)"
host_static="$(uci -q get "$section.name" 2>/dev/null || true)"
[ -n "$mac_list" ] || continue
old_ifs="$IFS"
IFS=', '
for mac_item in $mac_list; do
[ -n "$mac_item" ] || continue
printf '%s\t%s\t%s\t%s\t%s\n' "$mac_item" "${ip_static:-}" "${host_static:-}" "" "static-dhcp" >>"$tmp"
done
IFS="$old_ifs"
done
fi
if command -v ip >/dev/null 2>&1; then
ip neigh show 2>/dev/null | awk '
BEGIN { OFS="\t" }
{
ip="";
dev="";
mac="";
if (NF >= 1) ip=$1;
for (i = 1; i <= NF; i++) {
if ($i == "dev" && i < NF) dev=$(i + 1);
if ($i == "lladdr" && i < NF) mac=$(i + 1);
}
if (mac != "") print mac, ip, "", dev, "ip-neigh";
}
' >>"$tmp"
fi
if [ -r /proc/net/arp ]; then
awk 'NR > 1 && $4 != "" && $4 != "00:00:00:00:00:00" {
printf "%s\t%s\t\t%s\tarp\n", $4, $1, $6
}' /proc/net/arp >>"$tmp"
fi
cat "$tmp"
"""
raw = self.run_router_ssh_script(row, script, timeout=18, ssh_password=ssh_password)
devices = {}
for line in raw.splitlines():
if not line.strip():
continue
parts = [part.strip() for part in line.split("\t")]
while len(parts) < 5:
parts.append("")
mac = self.normalize_wol_mac(parts[0])
if not mac:
continue
ip_addr = parts[1]
name = parts[2]
iface = parts[3]
source = parts[4] or "unknown"
entry = devices.get(mac)
if entry is None:
entry = {"mac": mac, "ip": "", "name": "", "iface": "", "sources": []}
devices[mac] = entry
if ip_addr and not entry["ip"]:
entry["ip"] = ip_addr
if name and not entry["name"]:
entry["name"] = name
if iface and not entry["iface"]:
entry["iface"] = iface
if source and source not in entry["sources"]:
entry["sources"].append(source)
ordered = sorted(
devices.values(),
key=lambda item: (
str(item.get("name") or "").lower(),
str(item.get("ip") or ""),
str(item.get("mac") or ""),
),
)
for item in ordered:
label_parts = []
if item.get("name"):
label_parts.append(item["name"])
if item.get("ip"):
label_parts.append(item["ip"])
label_parts.append(item["mac"])
item["label"] = " | ".join(part for part in label_parts if part)
item["source"] = ", ".join(item.pop("sources", []))
return ordered
def discover_router_client_traffic(self, row, ssh_password=""):
script = r"""
set -eu
tmp_clients="${TMPDIR:-/tmp}/owrt-clients.$$.txt"
tmp_nft="${TMPDIR:-/tmp}/owrt-nft.$$.txt"
tmp_conntrack="${TMPDIR:-/tmp}/owrt-conntrack.$$.txt"
tmp_known_ips="${TMPDIR:-/tmp}/owrt-client-ips.$$.txt"
tmp_rules="${TMPDIR:-/tmp}/owrt-client-rules.$$.txt"
cleanup() {
rm -f "$tmp_clients" "$tmp_nft" "$tmp_conntrack" "$tmp_known_ips" "$tmp_rules"
}
trap cleanup EXIT INT TERM
: >"$tmp_clients"
: >"$tmp_nft"
: >"$tmp_conntrack"
: >"$tmp_known_ips"
: >"$tmp_rules"
if [ -f /tmp/dhcp.leases ]; then
while read -r lease_ts mac ip host client_id; do
[ -n "${mac:-}" ] || continue
[ "${mac:-}" = "*" ] && continue
[ "${host:-}" = "*" ] && host=""
printf '%s\t%s\t%s\t%s\t%s\t%s\n' "$mac" "${ip:-}" "${host:-}" "" "" "dhcp" >>"$tmp_clients"
done /dev/null 2>&1; then
uci -q show dhcp | sed -n "s/^\(dhcp\.[^=]*\)=host$/\1/p" | while IFS= read -r section; do
[ -n "$section" ] || continue
mac_list="$(uci -q get "$section.mac" 2>/dev/null || true)"
ip_static="$(uci -q get "$section.ip" 2>/dev/null || true)"
host_static="$(uci -q get "$section.name" 2>/dev/null || true)"
[ -n "$mac_list" ] || continue
old_ifs="$IFS"
IFS=', '
for mac_item in $mac_list; do
[ -n "$mac_item" ] || continue
printf '%s\t%s\t%s\t%s\t%s\t%s\n' "$mac_item" "" "${host_static:-}" "${ip_static:-}" "" "static-dhcp" >>"$tmp_clients"
done
IFS="$old_ifs"
done
fi
if command -v ip >/dev/null 2>&1; then
ip neigh show 2>/dev/null | awk '
BEGIN { OFS="\t" }
{
ip="";
dev="";
mac="";
if (NF >= 1) ip=$1;
for (i = 1; i <= NF; i++) {
if ($i == "dev" && i < NF) dev=$(i + 1);
if ($i == "lladdr" && i < NF) mac=$(i + 1);
}
if (mac != "") print mac, ip, "", "", dev, "ip-neigh";
}
' >>"$tmp_clients"
fi
if [ -r /proc/net/arp ]; then
awk 'NR > 1 && $4 != "" && $4 != "00:00:00:00:00:00" {
printf "%s\t%s\t\t\t%s\tarp\n", $4, $1, $6
}' /proc/net/arp >>"$tmp_clients"
fi
awk -F '\t' '
{
if ($2 != "") print $2;
if ($4 != "") print $4;
}
' "$tmp_clients" | awk '!seen[$0]++ && $0 ~ /^[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+$/ { print }' >"$tmp_known_ips"
traffic_source="none"
has_nft=0
has_conntrack=0
if command -v nft >/dev/null 2>&1; then
nft add table inet owrt_traffic >/dev/null 2>&1 || true
nft 'add chain inet owrt_traffic client_prerouting { type filter hook prerouting priority filter; policy accept; }' >/dev/null 2>&1 || true
nft 'add chain inet owrt_traffic client_postrouting { type filter hook postrouting priority filter; policy accept; }' >/dev/null 2>&1 || true
nft list table inet owrt_traffic >"$tmp_rules" 2>/dev/null || true
while IFS= read -r client_ip; do
[ -n "${client_ip:-}" ] || continue
grep -Fq "owrt-tx:$client_ip" "$tmp_rules" || nft add rule inet owrt_traffic client_prerouting ip saddr "$client_ip" counter comment "owrt-tx:$client_ip" >/dev/null 2>&1 || true
grep -Fq "owrt-rx:$client_ip" "$tmp_rules" || nft add rule inet owrt_traffic client_postrouting ip daddr "$client_ip" counter comment "owrt-rx:$client_ip" >/dev/null 2>&1 || true
done <"$tmp_known_ips"
if nft list table inet owrt_traffic >"$tmp_nft" 2>/dev/null; then
has_nft=1
fi
fi
if command -v conntrack >/dev/null 2>&1; then
if conntrack -L -o extended >"$tmp_conntrack" 2>/dev/null; then
has_conntrack=1
traffic_source="conntrack"
fi
fi
if [ "$has_conntrack" -eq 0 ]; then
for candidate in /proc/net/nf_conntrack /proc/net/ip_conntrack; do
if [ -r "$candidate" ]; then
cat "$candidate" >"$tmp_conntrack"
has_conntrack=1
traffic_source="$(basename "$candidate")"
break
fi
done
fi
if [ "$has_nft" -eq 1 ] && [ "$has_conntrack" -eq 1 ]; then
traffic_source="nftables+${traffic_source}"
elif [ "$has_nft" -eq 1 ]; then
traffic_source="nftables"
fi
printf 'META\ttraffic_source\t%s\n' "${traffic_source:-none}"
awk -F '\t' -v nft_file="$tmp_nft" -v conntrack_file="$tmp_conntrack" -v has_nft="$has_nft" -v has_conntrack="$has_conntrack" -v traffic_source="${traffic_source:-none}" '
function append_unique(existing, value, arr, idx) {
if (value == "") return existing;
if (existing == "") return value;
split(existing, arr, /, /);
for (idx in arr) if (arr[idx] == value) return existing;
return existing ", " value;
}
FNR == NR {
mac=toupper($1);
ip=$2;
host=$3;
static_ip=$4;
iface=$5;
source=$6;
if (mac == "") next;
if (!(mac in seen)) {
order[++count]=mac;
seen[mac]=1;
}
if (ip != "" && ips[mac] == "") ips[mac]=ip;
if (host != "" && hosts[mac] == "") hosts[mac]=host;
if (static_ip != "" && statics[mac] == "") statics[mac]=static_ip;
if (iface != "" && ifaces[mac] == "") ifaces[mac]=iface;
sources[mac]=append_unique(sources[mac], source);
if (ip != "") mac_by_ip[ip]=mac;
if (static_ip != "") mac_by_ip[static_ip]=mac;
next;
}
END {
flow_hits=0;
if ((has_nft + 0) > 0) {
while ((getline line < nft_file) > 0) {
bytes=0;
ip="";
dir="";
quoted_count=split(line, quoted, "\"");
for (q=1; q<=quoted_count; q++) {
if (quoted[q] ~ /^owrt-(tx|rx):/) {
marker_count=split(quoted[q], marker, ":");
if (marker_count >= 2) {
if (marker[1] == "owrt-tx") dir="tx";
else if (marker[1] == "owrt-rx") dir="rx";
ip=marker[2];
}
break;
}
}
if (dir == "" || ip == "" || !(ip in mac_by_ip)) continue;
n=split(line, parts, /[[:space:]]+/);
for (i=1; i<=n; i++) {
if (parts[i] == "bytes" && i < n) {
bytes=parts[i + 1] + 0;
break;
}
}
if (dir == "tx") tx_nft[mac_by_ip[ip]] = bytes;
else if (dir == "rx") rx_nft[mac_by_ip[ip]] = bytes;
flow_hits++;
}
close(nft_file);
}
if ((has_conntrack + 0) > 0) {
while ((getline line < conntrack_file) > 0) {
src1=dst1=src2=dst2="";
bytes1=bytes2=0;
src_count=0;
dst_count=0;
bytes_count=0;
n=split(line, parts, /[[:space:]]+/);
for (i=1; i<=n; i++) {
token=parts[i];
if (token ~ /^src=/) {
src_count++;
if (src_count == 1) src1=substr(token, 5);
else if (src_count == 2) src2=substr(token, 5);
} else if (token ~ /^dst=/) {
dst_count++;
if (dst_count == 1) dst1=substr(token, 5);
else if (dst_count == 2) dst2=substr(token, 5);
} else if (token ~ /^bytes=/) {
bytes_count++;
if (bytes_count == 1) bytes1=substr(token, 7) + 0;
else if (bytes_count == 2) bytes2=substr(token, 7) + 0;
}
}
if (bytes1 > 0) {
if (src1 in mac_by_ip) tx_conntrack[mac_by_ip[src1]] += bytes1;
if (dst1 in mac_by_ip) rx_conntrack[mac_by_ip[dst1]] += bytes1;
flow_hits++;
}
if (bytes2 > 0) {
if (src2 in mac_by_ip) tx_conntrack[mac_by_ip[src2]] += bytes2;
if (dst2 in mac_by_ip) rx_conntrack[mac_by_ip[dst2]] += bytes2;
flow_hits++;
}
}
close(conntrack_file);
}
printf "META\tflow_hits\t%d\n", flow_hits + 0;
for (i=1; i<=count; i++) {
mac=order[i];
rx_value=rx_nft[mac] + 0;
tx_value=tx_nft[mac] + 0;
if ((rx_conntrack[mac] + 0) > rx_value) rx_value=rx_conntrack[mac] + 0;
if ((tx_conntrack[mac] + 0) > tx_value) tx_value=tx_conntrack[mac] + 0;
total=rx_value + tx_value;
printf "CLIENT\t%s\t%s\t%s\t%s\t%s\t%s\t%.0f\t%.0f\t%.0f\n",
mac, ips[mac], hosts[mac], statics[mac], ifaces[mac], sources[mac], rx_value, tx_value, total;
}
}
' "$tmp_clients"
"""
raw = self.run_router_ssh_script(row, script, timeout=28, ssh_password=ssh_password)
clients = []
traffic_source = "none"
flow_hits = 0
for line in raw.splitlines():
if not line.strip():
continue
parts = [part.strip() for part in line.split("\t")]
if not parts:
continue
kind = parts[0]
if kind == "META" and len(parts) >= 3:
if parts[1] == "traffic_source":
traffic_source = parts[2] or "none"
elif parts[1] == "flow_hits":
try:
flow_hits = int(parts[2] or 0)
except ValueError:
flow_hits = 0
continue
if kind != "CLIENT":
continue
while len(parts) < 10:
parts.append("")
mac = self.normalize_wol_mac(parts[1])
if not mac:
continue
ip_addr = parts[2]
name = parts[3]
static_ip = parts[4]
iface = parts[5]
source = parts[6]
try:
rx_bytes = int(float(parts[7] or 0))
except ValueError:
rx_bytes = 0
try:
tx_bytes = int(float(parts[8] or 0))
except ValueError:
tx_bytes = 0
try:
total_bytes = int(float(parts[9] or (rx_bytes + tx_bytes)))
except ValueError:
total_bytes = rx_bytes + tx_bytes
clients.append(
{
"mac": mac,
"ip": ip_addr,
"name": name,
"static_ip": static_ip,
"iface": iface,
"source": source,
"rx_bytes": rx_bytes,
"tx_bytes": tx_bytes,
"total_bytes": total_bytes,
"has_static": bool(static_ip),
}
)
clients = accumulate_traffic_clients(row["id"], clients)
clients.sort(
key=lambda item: (
-int(item.get("total_bytes") or 0),
str(item.get("name") or "").lower(),
str(item.get("ip") or ""),
str(item.get("mac") or ""),
)
)
return {
"clients": clients,
"traffic_source": traffic_source,
"traffic_supported": traffic_source != "none",
"flow_hits": flow_hits,
}
def reset_router_client_traffic(self, row, ssh_password=""):
script = r"""
set -eu
install_conntrack() {
pkg=""
if command -v opkg >/dev/null 2>&1; then
opkg update >/dev/null 2>&1 || true
for pkg in conntrack conntrack-tools; do
opkg install "$pkg" >/dev/null 2>&1 && return 0
done
fi
if command -v apk >/dev/null 2>&1; then
apk update >/dev/null 2>&1 || true
for pkg in conntrack conntrack-tools; do
apk add "$pkg" >/dev/null 2>&1 && return 0
done
fi
return 1
}
did_reset=0
conntrack_failed=0
if command -v nft >/dev/null 2>&1; then
nft delete table inet owrt_traffic >/dev/null 2>&1 || true
did_reset=1
fi
if ! command -v conntrack >/dev/null 2>&1; then
install_conntrack || true
fi
if ! command -v conntrack >/dev/null 2>&1; then
echo "Не удалось найти или установить conntrack на роутере. Попробуй вручную: opkg install conntrack" >&2
exit 127
fi
if ! conntrack -F >/dev/null 2>&1; then
echo "Команда conntrack найдена, но очистить таблицу не удалось." >&2
exit 1
fi
echo "Трафик сброшен. Conntrack очищен, новые счётчики начнут копиться заново."
"""
output = self.run_router_ssh_script(row, script, timeout=75, ssh_password=ssh_password).strip()
return {
"message": output or "Трафик сброшен. Conntrack очищен, новые счётчики начнут копиться заново."
}
def reset_router_client_traffic(self, row, ssh_password=""):
script = r"""
set -eu
install_conntrack() {
pkg=""
if command -v opkg >/dev/null 2>&1; then
opkg update >/dev/null 2>&1 || true
for pkg in conntrack conntrack-tools; do
opkg install "$pkg" >/dev/null 2>&1 && return 0
done
fi
if command -v apk >/dev/null 2>&1; then
apk update >/dev/null 2>&1 || true
for pkg in conntrack conntrack-tools; do
apk add "$pkg" >/dev/null 2>&1 && return 0
done
fi
return 1
}
did_reset=0
conntrack_failed=0
if command -v nft >/dev/null 2>&1; then
nft delete table inet owrt_traffic >/dev/null 2>&1 || true
did_reset=1
fi
if ! command -v conntrack >/dev/null 2>&1; then
install_conntrack || true
fi
if command -v conntrack >/dev/null 2>&1; then
if conntrack -F >/dev/null 2>&1; then
did_reset=1
else
conntrack_failed=1
fi
fi
[ "$did_reset" -eq 1 ] || {
echo "Failed to reset traffic counters: neither conntrack nor nftables could be cleared." >&2
exit 1
}
if [ "$conntrack_failed" -eq 1 ]; then
echo "Traffic counters partially reset: nft client counters were cleared, but conntrack flush failed."
else
echo "Traffic counters reset: conntrack flushed and nft client counters cleared."
fi
"""
output = self.run_router_ssh_script(row, script, timeout=75, ssh_password=ssh_password).strip()
clear_traffic_counters(row["id"])
return {
"message": output or "Traffic counters reset: conntrack flushed and nft client counters cleared."
}
def ensure_router_wol_support(self, row, ssh_password=""):
script = r"""
set -eu
has_wol_tool() {
command -v etherwake >/dev/null 2>&1 || command -v wakeonlan >/dev/null 2>&1 || command -v wol >/dev/null 2>&1
}
install_pkg() {
pkg="$1"
case "$PKG_MANAGER" in
opkg)
opkg install "$pkg" >/dev/null 2>&1
;;
apk)
apk add "$pkg" >/dev/null 2>&1
;;
*)
return 1
;;
esac
}
if has_wol_tool; then
echo "WOL tool already present on router"
exit 0
fi
PKG_MANAGER=""
if command -v apk >/dev/null 2>&1; then
PKG_MANAGER="apk"
elif command -v opkg >/dev/null 2>&1; then
PKG_MANAGER="opkg"
fi
[ -n "$PKG_MANAGER" ] || {
echo "No package manager found to install WOL support." >&2
exit 1
}
case "$PKG_MANAGER" in
opkg)
opkg update >/dev/null 2>&1 || true
;;
apk)
apk update >/dev/null 2>&1 || true
;;
esac
install_pkg luci-app-wol || true
install_pkg etherwake || true
install_pkg wakeonlan || true
install_pkg wol || true
if has_wol_tool; then
echo "WOL support installed via $PKG_MANAGER"
exit 0
fi
echo "WOL package installation finished, but no etherwake/wakeonlan/wol command is available." >&2
exit 1
"""
return self.run_router_ssh_script(row, script, timeout=75, ssh_password=ssh_password).strip()
def send_router_wol_packet(self, row, mac, iface="", ssh_password=""):
clean_mac = self.normalize_wol_mac(mac)
if not clean_mac:
raise RuntimeError("invalid MAC address")
script = r"""
set -eu
mac="$1"
iface="${2:-}"
if command -v etherwake >/dev/null 2>&1; then
if [ -n "$iface" ]; then
etherwake -i "$iface" "$mac"
else
etherwake "$mac"
fi
echo "Wake packet sent via etherwake"
exit 0
fi
if command -v wakeonlan >/dev/null 2>&1; then
wakeonlan "$mac"
echo "Wake packet sent via wakeonlan"
exit 0
fi
if command -v wol >/dev/null 2>&1; then
wol "$mac"
echo "Wake packet sent via wol"
exit 0
fi
echo "No WOL tool found on router. Install etherwake, wakeonlan or wol." >&2
exit 127
"""
try:
output = self.run_router_ssh_script(
row,
script,
[clean_mac, str(iface or "")],
timeout=12,
ssh_password=ssh_password,
)
except RuntimeError as exc:
if "No WOL tool found on router" not in str(exc):
raise
install_output = self.ensure_router_wol_support(row, ssh_password=ssh_password)
output = self.run_router_ssh_script(
row,
script,
[clean_mac, str(iface or "")],
timeout=18,
ssh_password=ssh_password,
)
if install_output:
output = (install_output + "\n" + output).strip()
return {"mac": clean_mac, "iface": str(iface or ""), "output": output.strip() or "Wake packet sent"}
def vps_shell_args(self):
env = os.environ.copy()
env["TERM"] = "xterm-256color"
shell = env.get("SHELL", "")
if not shell:
shell = "/bin/bash" if Path("/bin/bash").exists() else "/bin/sh"
args = [shell]
if os.path.basename(shell) in {"bash", "sh", "ash", "dash", "zsh", "ksh"}:
args.append("-l")
return env, args
def spawn_terminal_pty(self, env, args, unavailable_message, open_message, exec_name):
try:
import pty
except Exception as exc:
raise RuntimeError(f"{unavailable_message}: {exc}")
try:
pid, fd = pty.fork()
except Exception as exc:
raise RuntimeError(f"{open_message}: {exc}")
if pid == 0:
try:
os.execvpe(args[0], args, env)
except Exception as exc:
print(f"{exec_name} start failed: {exc}", flush=True)
os._exit(127)
return pid, fd
def ssh_http_reader(self, sid):
session = SSH_HTTP_SESSIONS.get(sid)
if not session:
return
fd = session["fd"]
try:
while True:
ready, _, _ = select.select([fd], [], [], 0.5)
if fd not in ready:
with session["lock"]:
if not session["alive"]:
break
continue
try:
data = os.read(fd, 4096)
except OSError as exc:
with session["lock"]:
session["buffer"].append(f"\r\n[{session.get('label', 'Terminal')} read error: {exc}]\r\n")
break
if not data:
break
with session["lock"]:
session["buffer"].append(data.decode("utf-8", errors="replace"))
session["last_seen"] = now_ts()
finally:
with session["lock"]:
session["alive"] = False
session["buffer"].append("\r\n[" + session.get("close_notice", "SSH соединение закрыто") + "]\r\n")
try:
os.close(fd)
except OSError:
pass
try:
os.waitpid(session["pid"], os.WNOHANG)
except OSError:
pass
def start_ssh_http_session(self, router_id, port):
env, args = self.ssh_args(port)
pid, fd = self.spawn_terminal_pty(env, args, "pty недоступен на VPS", "не удалось открыть SSH pty", "ssh")
sid = secrets.token_urlsafe(24)
session = {
"id": sid,
"router_id": router_id,
"port": port,
"pid": pid,
"fd": fd,
"buffer": [],
"alive": True,
"created": now_ts(),
"last_seen": now_ts(),
"lock": threading.Lock(),
"label": "SSH",
"close_notice": "SSH соединение закрыто",
}
with SSH_HTTP_LOCK:
SSH_HTTP_SESSIONS[sid] = session
threading.Thread(target=self.ssh_http_reader, args=(sid,), daemon=True).start()
return session
def start_vps_http_session(self):
env, args = self.vps_shell_args()
pid, fd = self.spawn_terminal_pty(env, args, "pty недоступен на VPS", "не удалось открыть VPS pty", "vps-shell")
sid = secrets.token_urlsafe(24)
session = {
"id": sid,
"router_id": VPS_TERMINAL_ID,
"port": 0,
"pid": pid,
"fd": fd,
"buffer": [],
"alive": True,
"created": now_ts(),
"last_seen": now_ts(),
"lock": threading.Lock(),
"label": "VPS terminal",
"close_notice": "VPS terminal закрыт",
}
with SSH_HTTP_LOCK:
SSH_HTTP_SESSIONS[sid] = session
threading.Thread(target=self.ssh_http_reader, args=(sid,), daemon=True).start()
return session
def ssh_http_session(self):
router_id = self.router_id_from_path("/api/ssh/")
if self.ssh_token_ok(router_id):
allowed = True
elif is_vps_terminal_id(router_id):
allowed = self.owner_ok()
else:
allowed = self.router_access_allowed(router_id, "B")
if not allowed:
self.send_json(403, {"ok": False, "error": "not authorized"})
return
if is_vps_terminal_id(router_id):
try:
session = self.start_vps_http_session()
query = self.query()
set_pty_size(session["fd"], query.get("rows", ["24"])[0], query.get("cols", ["80"])[0])
self.send_json(200, {"ok": True, "sid": session["id"], "router_id": router_id, "mode": "local-shell"})
except Exception as exc:
self.send_json(500, {"ok": False, "error": str(exc)})
return
with self.app.conn() as conn:
row = get_active_router(conn, router_id)
if not row:
self.send_json(404, {"ok": False, "error": "router not found"})
return
port = int(row["ssh_entry_port"] or 0)
if port <= 0:
self.send_json(400, {"ok": False, "error": "router has no ssh_entry_port"})
return
try:
session = self.start_ssh_http_session(router_id, port)
query = self.query()
set_pty_size(session["fd"], query.get("rows", ["24"])[0], query.get("cols", ["80"])[0])
self.send_json(200, {"ok": True, "sid": session["id"], "router_id": router_id, "port": port})
except Exception as exc:
self.send_json(500, {"ok": False, "error": str(exc)})
def ssh_http_read(self, sid):
with SSH_HTTP_LOCK:
session = SSH_HTTP_SESSIONS.get(sid)
if not session:
self.send_json(404, {"ok": False, "error": "terminal session not found", "alive": False, "data": ""})
return
with session["lock"]:
data = "".join(session["buffer"])
session["buffer"].clear()
alive = bool(session["alive"])
session["last_seen"] = now_ts()
self.send_json(200, {"ok": True, "alive": alive, "data": data})
def ssh_http_write(self, sid, payload=None):
with SSH_HTTP_LOCK:
session = SSH_HTTP_SESSIONS.get(sid)
if not session:
self.send_json(404, {"ok": False, "error": "terminal session not found"})
return
if payload is None:
payload = self.read_payload()
data = payload.get("data", "")
if not isinstance(data, str):
data = str(data)
with session["lock"]:
alive = bool(session["alive"])
fd = session["fd"]
if not alive:
self.send_json(409, {"ok": False, "error": "terminal session closed"})
return
try:
write_pty_all(fd, data)
self.send_json(200, {"ok": True})
except Exception as exc:
self.send_json(500, {"ok": False, "error": str(exc)})
def ssh_http_resize(self, sid, payload=None):
with SSH_HTTP_LOCK:
session = SSH_HTTP_SESSIONS.get(sid)
if not session:
self.send_json(404, {"ok": False, "error": "terminal session not found"})
return
if payload is None:
payload = self.read_payload()
ok = set_pty_size(session["fd"], payload.get("rows", 24), payload.get("cols", 80))
self.send_json(200, {"ok": bool(ok)})
def ssh_http_write_short(self):
payload = self.read_payload()
sid = payload.get("sid", "")
if not sid:
sid = self.query().get("sid", [""])[0]
if not sid:
self.send_json(400, {"ok": False, "error": "terminal sid is empty"})
return
self.ssh_http_write(sid, payload)
def ssh_http_close(self, sid):
with SSH_HTTP_LOCK:
session = SSH_HTTP_SESSIONS.pop(sid, None)
if not session:
self.send_json(200, {"ok": True})
return
with session["lock"]:
session["alive"] = False
try:
os.kill(session["pid"], signal.SIGHUP)
except OSError:
pass
self.send_json(200, {"ok": True})
def ssh_session_action(self, path):
parts = path.strip("/").split("/")
if len(parts) != 4 or parts[0] != "api" or parts[1] != "ssh-session":
self.send_json(404, {"ok": False, "error": "terminal route not found"})
return
sid = urllib.parse.unquote(parts[2])
action = parts[3]
with SSH_HTTP_LOCK:
session = SSH_HTTP_SESSIONS.get(sid)
if not session:
self.send_json(404, {"ok": False, "error": "terminal session not found"})
return
router_id = str(session.get("router_id") or "")
if is_vps_terminal_id(router_id):
allowed = self.owner_ok()
else:
allowed = self.router_access_allowed(router_id, "B")
if not allowed:
self.send_json(403, {"ok": False, "error": "not authorized"})
return
if action == "read":
self.ssh_http_read(sid)
return
if action == "write":
self.ssh_http_write(sid)
return
if action == "resize":
self.ssh_http_resize(sid)
return
if action == "close":
self.ssh_http_close(sid)
return
self.send_json(404, {"ok": False, "error": "terminal action not found"})
def run_terminal_session(self, env, args, unavailable_message, open_message, exec_name, error_label):
ensure_state()
try:
pid, fd = self.spawn_terminal_pty(env, args, unavailable_message, open_message, exec_name)
except Exception as exc:
ws_send_frame(self.connection, f"{exc}\r\n")
return
ws_send_frame(self.connection, "")
try:
while True:
ready, _, _ = select.select([self.connection, fd], [], [], 0.25)
if fd in ready:
try:
data = os.read(fd, 4096)
except OSError:
break
if not data:
break
ws_send_frame(self.connection, data.decode("utf-8", errors="replace"))
if self.connection in ready:
try:
opcode, payload = ws_read_frame(self.connection)
except Exception:
break
if opcode == 8:
break
if opcode == 9:
ws_send_frame(self.connection, payload, opcode=10)
continue
if opcode == 1 and payload:
resize = parse_resize_payload(payload)
if resize:
set_pty_size(fd, resize[0], resize[1])
continue
if opcode in (1, 2) and payload:
write_pty_all(fd, payload)
except Exception as exc:
try:
ws_send_frame(self.connection, f"\r\n[{error_label}: {exc}]\r\n")
except Exception:
pass
finally:
try:
os.kill(pid, signal.SIGHUP)
except OSError:
pass
try:
os.close(fd)
except OSError:
pass
try:
os.waitpid(pid, os.WNOHANG)
except OSError:
pass
def run_ssh_session(self, router_id, port):
env, args = self.ssh_args(port)
self.run_terminal_session(env, args, "pty недоступен на VPS", "не удалось открыть SSH pty", "ssh", "SSH error")
def run_vps_terminal_session(self):
env, args = self.vps_shell_args()
self.run_terminal_session(env, args, "pty недоступен на VPS", "не удалось открыть VPS pty", "vps-shell", "VPS terminal error")
def backup_download(self):
with tempfile.TemporaryDirectory(prefix="owrt-hub-download-") as tmp_name:
filename = backup_filename()
archive = Path(tmp_name) / filename
create_hub_backup(archive, self.app.db_path)
body = archive.read_bytes()
self.send_bytes(
200,
body,
"application/gzip",
[("Content-Disposition", f'attachment; filename="{filename}"')],
)
def backup_restore(self):
try:
payload = self.read_payload()
archive_b64 = str(payload.get("archive_b64") or "")
if not archive_b64:
self.send_json(400, {"ok": False, "error": "archive_b64 is empty"})
return
if len(archive_b64) > 80 * 1024 * 1024:
self.send_json(413, {"ok": False, "error": "backup archive is too large"})
return
raw = base64.b64decode(archive_b64.encode("ascii"), validate=True)
with tempfile.TemporaryDirectory(prefix="owrt-hub-upload-") as tmp_name:
archive = Path(tmp_name) / "restore.tar.gz"
archive.write_bytes(raw)
result = restore_hub_backup(
archive,
self.app.db_path,
payload.get("vps_host", ""),
payload.get("public_url", ""),
)
self.app.session_token = session_token()
self.app.agent_token = agent_token()
add_notification(
"backup-restore",
"Hub backup восстановлен",
"Состояние Hub восстановлено из резервной копии. Перезапусти owrt-remote на VPS для чистого применения.",
"warn",
result.get("warnings", []),
{"rewritten": result.get("rewritten", {})},
)
self.send_json(200, {"ok": True, **result})
except Exception as exc:
self.send_json(400, {"ok": False, "error": str(exc)})
def router_endpoints_rewrite(self):
try:
payload = self.read_payload()
vps_host = str(payload.get("vps_host") or "").strip()
public_url = str(payload.get("public_url") or "").strip()
apply_live = bool(payload.get("apply_live", True))
ssh_password = str(payload.get("ssh_password") or "")
if not vps_host and not public_url:
self.send_json(400, {"ok": False, "error": "vps_host or public_url is required"})
return
with self.app.conn() as conn:
rewritten = rewrite_router_endpoints(
conn,
vps_host=vps_host,
public_url=public_url,
preserve_vps_fallback=bool(payload.get("preserve_vps_fallback", True)),
)
rows = list_router_rows(conn)
total = len(rows)
auto_apply = {
"requested": bool(apply_live),
"attempted": 0,
"confirmed": 0,
"applied": 0,
"unreachable": 0,
"failed": 0,
"results": [],
}
if apply_live:
for row in rows:
result = self.apply_router_rebind_via_ssh(row, ssh_password=ssh_password, request_origin=self.request_origin())
auto_apply["results"].append(result)
auto_apply["attempted"] += 1
status = str(result.get("status") or "")
if status == "confirmed":
auto_apply["confirmed"] += 1
auto_apply["applied"] += 1
elif status == "applied":
auto_apply["applied"] += 1
elif status == "unreachable":
auto_apply["unreachable"] += 1
else:
auto_apply["failed"] += 1
add_notification(
"router-endpoints-rewrite",
"Router endpoints updated",
"Hub updated router endpoint settings and tried to push the new config over SSH to reachable routers.",
"warn",
[
f"rewritten: {', '.join(f'{k}={v}' for k, v in rewritten.items()) or 'none'}",
f"auto-apply confirmed: {auto_apply['confirmed']}/{total}",
f"auto-apply applied: {auto_apply['applied']}/{total}",
f"auto-apply unreachable: {auto_apply['unreachable']}/{total}",
f"auto-apply failed: {auto_apply['failed']}/{total}",
],
{"rewritten": rewritten, "routers": total, "auto_apply": auto_apply},
)
self.send_json(200, {"ok": True, "rewritten": rewritten, "routers": total, "auto_apply": auto_apply})
except Exception as exc:
self.send_json(400, {"ok": False, "error": str(exc)})
def do_GET(self):
path = self.parsed().path
if path == "/health":
self.send_json(200, {"ok": True})
return
if path == "/favicon.ico":
self.send_local_asset(FAVICON_ICO_FILE, "image/x-icon")
return
if path == "/favicon-32.png":
self.send_local_asset(FAVICON_PNG_32_FILE, "image/png")
return
if path == "/favicon-192.png":
self.send_local_asset(FAVICON_PNG_192_FILE, "image/png")
return
if path == "/favicon-512.png":
self.send_local_asset(FAVICON_PNG_512_FILE, "image/png")
return
if path == "/apple-touch-icon.png":
self.send_local_asset(APPLE_TOUCH_ICON_FILE, "image/png")
return
if path == "/favicon.svg":
self.send_bytes(200, favicon_svg().encode("utf-8"), "image/svg+xml; charset=utf-8")
return
if path == "/sw.js":
self.send_bytes(
200,
service_worker_js().encode("utf-8"),
"application/javascript; charset=utf-8",
[("Service-Worker-Allowed", "/")],
)
return
if path == "/manifest.webmanifest":
self.send_bytes(200, web_manifest_json().encode("utf-8"), "application/manifest+json; charset=utf-8")
return
if path == "/api/auth/meta":
self.auth_meta()
return
if path == "/oauth/github/start":
self.start_social_login("github")
return
if path == "/oauth/vk/start":
self.start_social_login("vk")
return
if path == "/oauth/github/callback":
self.finish_social_callback("github")
return
if path == "/oauth/vk/callback":
self.finish_social_callback("vk")
return
if path.startswith("/.well-known/acme-challenge/"):
self.serve_acme_challenge(path)
return
if path == "/login":
self.send_bytes(200, login_html().encode("utf-8"), "text/html; charset=utf-8")
return
if path == "/ssh-key-manual/":
self.send_bytes(200, ssh_key_manual_html().encode("utf-8"), "text/html; charset=utf-8")
return
if path == "/logout":
revoke_hub_session(token=self.current_session_token())
self.redirect("/login", [("Set-Cookie", self.clear_session_cookie())])
return
if path == "/vps-terminal":
self.redirect("/vps-terminal/")
return
if path == "/vps-terminal/":
self.vps_terminal_page()
return
if path.startswith("/api/ssh/") and path.endswith("/check"):
self.ssh_check()
return
if path.startswith("/api/ssh/") and path.endswith("/session"):
self.ssh_http_session()
return
if path == "/api/ssh-session-write":
self.ssh_http_write_short()
return
if path.startswith("/api/ssh-session/"):
self.ssh_session_action(path)
return
if path.startswith("/ssh-ws/"):
self.ssh_ws()
return
if path.startswith("/ssh/"):
self.ssh_page()
return
if path.startswith("/access/"):
self.proxy_access(path)
return
if self.maybe_proxy_luci_absolute(path):
return
if not self.require_admin():
return
if path == "/" or path == "":
extra_headers = []
session_token_value = self.current_session_token()
profile = self.current_account_profile(touch=False)
if self.legacy_admin_ok() and not self.current_hub_session(touch=False):
session_token_value, session = make_hub_session(current_username(), self.client_ip(), self.headers.get("User-Agent", ""))
add_notification(
"login",
"Вход в Hub",
f"{session.get('client', 'устройство')} · IP {session.get('ip', 'unknown')}",
"warn",
[session.get("user_agent", "")],
{"session_id": session.get("id", ""), "ip": session.get("ip", ""), "legacy": True},
)
extra_headers.append(("Set-Cookie", self.session_cookie(session_token_value)))
with self.app.conn() as conn:
routers = self.visible_routers(conn, profile)
self.send_bytes(
200,
dashboard_html(
routers,
(profile or {}).get("username") or current_username(),
list_hub_sessions(session_token_value, self.current_or_owner_session_scope()),
list_notifications(0, 40) if not profile or profile.get("is_owner") else [],
).encode("utf-8"),
"text/html; charset=utf-8",
extra_headers,
)
return
if path == "/api/routers":
with self.app.conn() as conn:
routers = self.visible_routers(conn)
self.send_json(200, {"routers": routers})
return
if path == "/api/backup/download":
if not self.require_owner():
return
self.backup_download()
return
if path == "/api/sessions":
self.send_json(200, {"sessions": list_hub_sessions(self.current_session_token(), self.current_or_owner_session_scope())})
return
if path == "/api/notifications":
if not self.require_owner(json_mode=True):
return
query = self.query()
self.send_json(
200,
{
"notifications": list_notifications(
query.get("after", ["0"])[0],
query.get("limit", ["60"])[0],
query.get("after_serial", ["0"])[0],
),
"serial": latest_notification_serial(),
},
)
return
if path == "/api/notifications/wait":
if not self.require_owner(json_mode=True):
return
query = self.query()
self.send_json(
200,
{
"notifications": wait_for_notifications(
query.get("after_serial", ["0"])[0],
query.get("timeout", ["25"])[0],
query.get("limit", ["60"])[0],
),
"serial": latest_notification_serial(),
},
)
return
if path == "/api/push/vapid-public-key":
if not self.require_owner(json_mode=True):
return
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])
if not self.require_router_access(router_id, "G", json_mode=True):
return
with self.app.conn() as conn:
row = get_active_router(conn, router_id)
if not row:
self.send_json(404, {"ok": False, "error": "router not found"})
return
try:
devices = self.discover_router_wol_devices(row)
self.send_json(200, {"ok": True, "router_id": router_id, "devices": devices})
except Exception as exc:
self.send_json(400, {"ok": False, "error": str(exc), "router_id": router_id, "devices": []})
return
if path.startswith("/router/"):
self.router_asset(path)
return
self.send_text(404, "not found")
def do_HEAD(self):
self.do_GET()
def do_POST(self):
path = self.parsed().path
if path == "/login":
self.login()
return
if path == "/api/login/passkey/begin":
self.begin_passkey_login()
return
if path == "/api/login/passkey/finish":
self.finish_passkey_login()
return
if path == "/api/login/ssh/begin":
self.begin_ssh_login()
return
if path == "/api/login/ssh/finish":
self.finish_ssh_login()
return
if path == "/api/ssh-session-write":
self.ssh_http_write_short()
return
if path.startswith("/api/ssh-session/"):
self.ssh_session_action(path)
return
if path == "/api/heartbeat":
if not self.agent_ok():
self.send_json(401, {"ok": False, "error": "bad agent token"})
return
try:
payload = self.read_payload()
with self.app.conn() as conn:
router = heartbeat(conn, payload)
if router and router.pop("_became_online", False):
notify_router_online(router)
xray_reload = None
if router and router.pop("_xray_reload_required", False):
try:
xray_reload = reload_vps_xray(self.app.db_path)
except Exception as exc:
self.log_message("heartbeat xray reload error: %s", exc)
xray_reload = {"error": str(exc)}
xray_restart = None
if payload.get("event") == "wan-reconnect":
try:
xray_restart = maybe_restart_vps_xray_after_wan_reconnect(router["id"])
except Exception as exc:
self.log_message("wan reconnect xray restart error: %s", exc)
xray_restart = {"error": str(exc)}
self.send_json(
200,
{
"ok": True,
"router": router,
"hub_update": canonical_router_hub_update(router, self.app.public_url, self.request_origin()),
"xray_reload": xray_reload,
"xray_restart": xray_restart,
},
)
except Exception as exc:
self.log_message("heartbeat error: %s", exc)
self.send_json(400, {"ok": False, "error": str(exc)})
return
if path.startswith("/access/"):
self.proxy_access(path)
return
if self.maybe_proxy_luci_absolute(path):
return
if not self.require_admin():
return
if path == "/api/auth":
if not self.require_owner():
return
self.update_auth()
return
if path == "/api/auth/users/save":
if not self.require_owner(json_mode=True):
return
self.save_delegated_user()
return
if path == "/api/auth/users/delete":
if not self.require_owner(json_mode=True):
return
self.delete_delegated_user()
return
if path == "/api/auth/users/revoke-sessions":
if not self.require_owner(json_mode=True):
return
self.revoke_delegated_user_sessions()
return
if path == "/api/auth/totp/setup":
if not self.require_owner(json_mode=True):
return
self.totp_setup()
return
if path == "/api/auth/totp/enable":
if not self.require_owner(json_mode=True):
return
self.totp_enable()
return
if path == "/api/auth/totp/disable":
if not self.require_owner(json_mode=True):
return
self.totp_disable()
return
if path == "/api/auth/passkeys/begin":
if not self.require_owner(json_mode=True):
return
self.begin_passkey_registration()
return
if path == "/api/auth/passkeys/finish":
if not self.require_owner(json_mode=True):
return
self.finish_passkey_registration()
return
if path == "/api/auth/passkeys/remove":
if not self.require_owner(json_mode=True):
return
self.remove_passkey()
return
if path == "/api/auth/ssh-keys/add":
if not self.require_owner(json_mode=True):
return
self.add_ssh_key()
return
if path == "/api/auth/ssh-keys/remove":
if not self.require_owner(json_mode=True):
return
self.remove_ssh_key()
return
if path == "/api/auth/social/github/save":
if not self.require_owner(json_mode=True):
return
self.save_social_provider_config("github")
return
if path == "/api/auth/social/vk/save":
if not self.require_owner(json_mode=True):
return
self.save_social_provider_config("vk")
return
if path == "/api/auth/social/github/link":
if not self.require_owner(json_mode=True):
return
self.begin_social_link("github")
return
if path == "/api/auth/social/vk/link":
if not self.require_owner(json_mode=True):
return
self.begin_social_link("vk")
return
if path == "/api/auth/social/github/unlink":
if not self.require_owner(json_mode=True):
return
self.unlink_social_account("github")
return
if path == "/api/auth/social/vk/unlink":
if not self.require_owner(json_mode=True):
return
self.unlink_social_account("vk")
return
if path == "/api/session/client-hint":
payload = self.read_payload()
session = update_hub_session_client_hint(self.current_session_token(), payload.get("client_hint", ""))
if not session:
self.send_json(400, {"ok": False, "error": "session not found"})
return
self.send_json(200, {"ok": True, "client": session.get("client", ""), "hint": normalize_client_hint(payload.get("client_hint", ""))})
return
if path == "/api/session/revoke":
payload = self.read_payload()
session_id = payload.get("id", "")
if not session_id:
self.send_text(400, "session id is empty")
return
current = self.current_hub_session(touch=False)
if current and session_id == current.get("id"):
self.send_text(400, "Текущую сессию заверши кнопкой Выйти")
return
if not self.owner_ok():
session_allowed = next(
(
session
for session in list_hub_sessions(self.current_session_token(), self.current_or_owner_session_scope())
if session.get("id") == session_id
),
None,
)
if not session_allowed:
self.send_json(403, {"ok": False, "error": "not authorized"})
return
removed = revoke_hub_session(session_id=session_id)
self.send_json(200, {"ok": True, "removed": removed})
return
if path == "/api/session/revoke-others":
current = self.current_hub_session(touch=False)
current_id = current.get("id", "") if current else ""
removed = 0
for session in list_hub_sessions(self.current_session_token(), self.current_or_owner_session_scope()):
if session.get("id") != current_id:
removed += revoke_hub_session(session_id=session.get("id", ""))
self.send_json(200, {"ok": True, "removed": removed})
return
if path == "/api/notifications/clear":
if not self.require_owner(json_mode=True):
return
clear_notifications()
self.send_json(200, {"ok": True})
return
if path == "/api/backup/restore":
if not self.require_owner(json_mode=True):
return
self.backup_restore()
return
if path == "/api/routers/rewrite-endpoints":
if not self.require_owner(json_mode=True):
return
self.router_endpoints_rewrite()
return
if path == "/api/push/subscribe":
if not self.require_owner(json_mode=True):
return
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":
if not self.require_owner(json_mode=True):
return
try:
payload = self.read_payload()
removed = remove_push_subscription(payload.get("endpoint", ""))
self.send_json(200, {"ok": True, "removed": removed})
except Exception as exc:
self.send_json(400, {"ok": False, "error": str(exc)})
return
if path == "/api/xray/reload":
if not self.require_owner(json_mode=True):
return
try:
result = reload_vps_xray(self.app.db_path)
self.send_json(200, {"ok": True, **result})
except Exception as exc:
self.send_text(500, str(exc))
return
if path == "/api/xray/restart":
if not self.require_owner(json_mode=True):
return
try:
result = restart_vps_xray()
self.send_json(200, {"ok": True, **result})
except Exception as exc:
self.send_text(500, str(exc))
return
if path == "/api/router":
if not self.require_add_router(json_mode=True):
return
try:
current = self.current_account_profile(touch=False) or {}
payload = self.read_payload()
router_id = clean_router_id(payload.get("id"))
entry_port = int(payload.get("entry_port") or 0)
ssh_entry_port = int(payload.get("ssh_entry_port") or (entry_port + 1000))
if entry_port <= 0:
self.send_text(400, "entry_port должен быть больше 0")
return
with self.app.conn() as conn:
existing = get_router(conn, router_id)
if existing and not router_deleted(existing):
self.send_text(
409,
f"Router ID '{router_id}' уже есть. Для второго роутера укажи новый ID, например node-2 или main123.",
)
return
port_owner = get_router_by_any_port(conn, entry_port, router_id)
if port_owner:
self.send_text(
409,
f"entry_port {entry_port} уже занят роутером '{port_owner['id']}'. Для следующего роутера поставь другой порт, например {entry_port + 10}.",
)
return
ssh_port_owner = get_router_by_any_port(conn, ssh_entry_port, router_id)
if ssh_port_owner:
self.send_text(
409,
f"ssh_entry_port {ssh_entry_port} уже занят роутером '{ssh_port_owner['id']}'. Поставь entry_port так, чтобы entry_port + 1000 был свободен.",
)
return
payload["ssh_entry_port"] = ssh_entry_port
row = upsert_router(conn, payload)
router = row_to_router(row)
if current and not current.get("is_owner"):
grant_delegated_router_flag(load_auth(), current.get("username", ""), router_id, "G")
self.send_json(200, {"ok": True, "router": router, "auth": self.build_auth_meta()})
except Exception as exc:
self.send_text(400, str(exc))
return
if path.startswith("/api/router/") and path.endswith("/wol/devices"):
parts = path.strip("/").split("/")
if len(parts) != 5 or parts[0] != "api" or parts[1] != "router" or parts[3] != "wol" or parts[4] != "devices":
self.send_text(404, "not found")
return
router_id = urllib.parse.unquote(parts[2])
if not self.require_router_access(router_id, "G", json_mode=True):
return
try:
payload = self.read_payload()
with self.app.conn() as conn:
row = get_active_router(conn, router_id)
if not row:
self.send_json(404, {"ok": False, "error": "router not found"})
return
devices = self.discover_router_wol_devices(row, payload.get("ssh_password", ""))
self.send_json(200, {"ok": True, "router_id": router_id, "devices": devices})
except Exception as exc:
self.send_json(400, {"ok": False, "error": str(exc), "router_id": router_id, "devices": []})
return
if path.startswith("/api/router/") and path.endswith("/traffic/clients"):
parts = path.strip("/").split("/")
if len(parts) != 5 or parts[0] != "api" or parts[1] != "router" or parts[3] != "traffic" or parts[4] != "clients":
self.send_text(404, "not found")
return
router_id = urllib.parse.unquote(parts[2])
if not self.require_router_access(router_id, "G", json_mode=True):
return
try:
payload = self.read_payload()
with self.app.conn() as conn:
row = get_active_router(conn, router_id)
if not row:
self.send_json(404, {"ok": False, "error": "router not found"})
return
result = self.discover_router_client_traffic(row, payload.get("ssh_password", ""))
self.send_json(200, {"ok": True, "router_id": router_id, **result})
except Exception as exc:
self.send_json(
400,
{
"ok": False,
"error": str(exc),
"router_id": router_id,
"clients": [],
"traffic_source": "none",
"traffic_supported": False,
"flow_hits": 0,
},
)
return
if path.startswith("/api/router/") and path.endswith("/traffic/reset"):
parts = path.strip("/").split("/")
if len(parts) != 5 or parts[0] != "api" or parts[1] != "router" or parts[3] != "traffic" or parts[4] != "reset":
self.send_text(404, "not found")
return
router_id = urllib.parse.unquote(parts[2])
if not self.require_router_access(router_id, "G", json_mode=True):
return
try:
payload = self.read_payload()
with self.app.conn() as conn:
row = get_active_router(conn, router_id)
if not row:
self.send_json(404, {"ok": False, "error": "router not found"})
return
result = self.reset_router_client_traffic(row, payload.get("ssh_password", ""))
self.send_json(200, {"ok": True, "router_id": router_id, **result})
except Exception as exc:
self.send_json(400, {"ok": False, "error": str(exc), "router_id": router_id})
return
if path.startswith("/api/router/") and path.endswith("/wol"):
parts = path.strip("/").split("/")
if len(parts) != 4 or parts[0] != "api" or parts[1] != "router" or parts[3] != "wol":
self.send_text(404, "not found")
return
router_id = urllib.parse.unquote(parts[2])
if not self.require_router_access(router_id, "G", json_mode=True):
return
try:
payload = self.read_payload()
with self.app.conn() as conn:
row = get_active_router(conn, router_id)
if not row:
self.send_json(404, {"ok": False, "error": "router not found"})
return
result = self.send_router_wol_packet(
row,
payload.get("mac"),
payload.get("iface", ""),
payload.get("ssh_password", ""),
)
self.send_json(200, {"ok": True, "router_id": router_id, **result})
except Exception as exc:
self.send_json(400, {"ok": False, "error": str(exc), "router_id": router_id})
return
if path.startswith("/api/router/") and path.endswith("/rename"):
try:
router_id = urllib.parse.unquote(path.split("/")[3])
if not self.require_router_access(router_id, "G", json_mode=True):
return
payload = self.read_payload()
with self.app.conn() as conn:
row = rename_router(conn, router_id, payload.get("name"))
self.send_json(200, {"ok": True, "router": row_to_router(row)})
except Exception as exc:
self.send_text(400, str(exc))
return
if path.startswith("/api/router/") and path.endswith("/delete"):
router_id = urllib.parse.unquote(path.split("/")[3])
if not self.require_owner(json_mode=True):
return
deleted = False
xray_result = None
warnings = []
with self.app.conn() as conn:
row = get_router(conn, router_id)
if row and not router_deleted(row):
ts = now_ts()
conn.execute(
"update routers set deleted_at = ?, updated_at = ? where id = ?",
(ts, ts, router_id),
)
conn.commit()
deleted = True
if deleted:
try:
xray_result = reload_vps_xray(self.app.db_path)
except Exception as exc:
warnings.append(f"xray reload skipped: {exc}")
self.send_json(200, {"ok": True, "deleted": deleted, "xray": xray_result, "warnings": warnings})
return
self.send_text(404, "not found")
def router_asset(self, path):
parts = path.strip("/").split("/")
if len(parts) != 3:
self.send_text(404, "not found")
return
_, router_id, asset = parts
router_id = urllib.parse.unquote(router_id)
if asset == "config":
if not self.require_router_access(router_id, "G"):
return
elif asset == "xray-client.json":
if not self.require_router_access(router_id, "G", json_mode=True):
return
else:
self.send_text(404, "not found")
return
with self.app.conn() as conn:
row = get_active_router(conn, router_id)
if not row:
self.send_text(404, "router not found")
return
hub_update, hub_url, config_vps_host = router_current_hub_bundle(
row,
self.app.public_url,
self.request_origin(),
self.headers.get("Host", ""),
)
if asset == "config":
self.send_text(
200,
make_openwrt_config(
row,
hub_url,
vps_host_override=config_vps_host,
public_url_override=hub_update.get("public_url", ""),
),
)
return
if asset == "xray-client.json":
self.send_json(200, make_router_xray_config(row))
return
self.send_text(404, "not found")
def proxy_access(self, path):
parts = path.split("/", 3)
if len(parts) < 3 or not parts[2]:
self.redirect("/")
return
router_id = urllib.parse.unquote(parts[2])
if not self.require_router_access(router_id, "A"):
return
rest = "/" + parts[3] if len(parts) == 4 else "/"
with self.app.conn() as conn:
row = get_active_router(conn, router_id)
if not row:
self.send_text(404, "router not found")
return
port = int(row["entry_port"] or 0)
if port <= 0:
self.send_text(400, "router has no entry_port")
return
query = urllib.parse.parse_qsl(self.parsed().query, keep_blank_values=True)
query = list(query)
target = rest
if query:
target += "?" + urllib.parse.urlencode(query)
is_static = self.command in ("GET", "HEAD") and is_luci_static_target(target)
cache_key = static_cache_key(router_id, target) if is_static else None
if cache_key:
cached = static_cache_get(cache_key)
if cached:
status, resp_body, content_type, resp_headers = cached
resp_headers.append(("X-OWRT-Static-Cache", "hit"))
self.send_raw_bytes(status, resp_body, content_type, resp_headers)
return
body = self.read_body() if self.command in ("POST", "PUT", "PATCH") else None
headers = {}
skip = {"host", "connection", "keep-alive", "proxy-authenticate", "proxy-authorization", "te", "trailers", "transfer-encoding", "upgrade", "content-length", "accept-encoding"}
for key, value in self.headers.items():
if key.lower() in skip:
continue
if key.lower() == "cookie":
value = clean_forward_cookie(value)
if not value:
continue
elif key.lower() == "referer":
value = rewrite_forward_url(value, router_id, port)
elif key.lower() == "origin":
value = f"http://127.0.0.1:{port}"
headers[key] = value
headers["Host"] = f"127.0.0.1:{port}"
headers["Connection"] = "close"
headers["X-Forwarded-Host"] = self.headers.get("Host", "")
headers["X-Forwarded-Prefix"] = f"/access/{urllib.parse.quote(router_id)}"
headers["X-Forwarded-Proto"] = "http"
if body is not None:
headers["Content-Length"] = str(len(body))
limiter = None if is_static else router_proxy_limiter(router_id)
acquired = False
try:
if limiter is not None:
acquired = limiter.acquire(timeout=PROXY_TIMEOUT)
if not acquired:
self.send_text(503, "proxy busy: router is handling too many requests")
return
attempts = 4 if is_static and self.command == "GET" else 1
last_exc = None
for attempt in range(attempts):
backend = None
try:
backend = http.client.HTTPConnection("127.0.0.1", port, timeout=PROXY_TIMEOUT)
backend.request(self.command, target, body=body, headers=headers)
resp = backend.getresponse()
resp_status = resp.status
resp_raw_headers = resp.getheaders()
resp_body = resp.read()
content_type = resp.getheader("Content-Type", "")
last_exc = None
break
except Exception as exc:
last_exc = exc
if attempt + 1 < attempts:
time.sleep(0.12 * (attempt + 1))
continue
finally:
if backend is not None:
backend.close()
if last_exc is not None:
raise last_exc
resp_headers = []
prefix = f"/access/{urllib.parse.quote(router_id)}"
public_hosts = normalize_public_hosts(
self.headers.get("Host", ""),
self.app.public_url,
"127.0.0.1",
f"127.0.0.1:{port}",
"localhost",
f"localhost:{port}",
row["admin_host"],
f"{row['admin_host']}:{row['admin_port']}",
)
for key, value in resp_raw_headers:
low = key.lower()
if low in {"cache-control", "connection", "content-length", "content-type", "keep-alive", "proxy-authenticate", "proxy-authorization", "te", "trailers", "transfer-encoding", "upgrade"}:
continue
if low == "location":
value = rewrite_location(value, prefix, port)
if low == "set-cookie":
value = rewrite_cookie_path(value, "/")
resp_headers.append((key, value))
if should_rewrite_body(content_type):
resp_body = rewrite_html(resp_body, prefix, content_type, public_hosts)
if cache_key and self.command == "GET":
static_cache_put(
cache_key,
resp_status,
resp_body,
content_type or "application/octet-stream",
static_cache_headers(resp_headers),
)
if not is_static:
resp_headers.append(("Set-Cookie", current_router_cookie(router_id)))
if is_static:
self.send_raw_bytes(
resp_status,
resp_body,
content_type or "application/octet-stream",
resp_headers + [("X-OWRT-Static-Cache", "miss")],
)
else:
self.send_bytes(
resp_status,
resp_body,
content_type or "application/octet-stream",
resp_headers,
)
except Exception as exc:
self.send_text(502, f"proxy error: {exc}")
finally:
if acquired:
limiter.release()
def rewrite_location(value, prefix, port):
if value.startswith("/"):
return prefix + value
for base in (f"http://127.0.0.1:{port}", f"http://localhost:{port}"):
if value.startswith(base + "/"):
return prefix + value[len(base):]
return value
def rewrite_cookie_path(value, path):
chunks = value.split(";")
changed = []
saw_path = False
for chunk in chunks:
if chunk.strip().lower().startswith("path="):
changed.append(" Path=" + path)
saw_path = True
else:
changed.append(chunk)
if not saw_path:
changed.append(" Path=" + path)
return ";".join(changed)
def proxy_runtime_script(prefix):
prefix_json = json.dumps(prefix)
return """""" % prefix_json
def protect_luci_resource_root(text):
protected = []
def protect_value(match):
token = f"__OWRT_REMOTE_LUCI_RESOURCE_{len(protected)}__"
protected.append(match.group(0))
return token
patterns = (
r"""((?:"resource"|'resource'|resource)\s*[:=]\s*)(["'])(/luci-static/resources)(\2)""",
r"""((?:"resource"|'resource'|resource)\s*[:=]\s*)(["'])(\\/luci-static\\/resources)(\2)""",
)
for pattern in patterns:
text = re.sub(pattern, protect_value, text)
return text, protected
def restore_luci_resource_root(text, protected):
for index, value in enumerate(protected):
text = text.replace(f"__OWRT_REMOTE_LUCI_RESOURCE_{index}__", value)
return text
def normalize_public_hosts(*values):
hosts = set()
for value in values:
if not value:
continue
raw = str(value).strip()
if not raw:
continue
parsed = urllib.parse.urlsplit(raw if "://" in raw else f"//{raw}")
netloc = parsed.netloc or parsed.path.split("/", 1)[0]
netloc = netloc.split("@", 1)[-1].strip().lower()
if not netloc:
continue
hosts.add(netloc)
if ":" not in netloc:
hosts.add(f"{netloc}:80")
hosts.add(f"{netloc}:443")
hosts.add(f"{netloc}:8088")
return sorted(hosts, key=len, reverse=True)
def rewrite_public_absolute_urls(text, prefix, public_hosts):
escaped_prefix = prefix.replace("/", "\\/")
for host in public_hosts or []:
for scheme in ("http", "https"):
for root in ("/ubus", "/cgi-bin/luci", "/luci-static"):
text = text.replace(f"{scheme}://{host}{root}", f"{prefix}{root}")
escaped_root = root.replace("/", "\\/")
text = text.replace(f"{scheme}:\\/\\/{host}{escaped_root}", f"{escaped_prefix}{escaped_root}")
return text
def rewrite_remaining_luci_roots(text, prefix):
roots = ("/ubus", "/cgi-bin/luci", "/luci-static")
escaped_prefix = prefix.replace("/", "\\/")
for root in roots:
key = root.strip("/").replace("/", "_")
marker = f"__OWRT_REMOTE_RAW_ROOT_{key}__"
escaped_marker = f"__OWRT_REMOTE_ESC_ROOT_{key}__"
escaped_root = root.replace("/", "\\/")
escaped_prefixed = f"{escaped_prefix}{escaped_root}"
text = text.replace(escaped_prefixed, escaped_marker)
text = text.replace(escaped_root, escaped_prefixed)
text = text.replace(escaped_prefixed, escaped_marker)
prefixed = f"{prefix}{root}"
text = text.replace(prefixed, marker)
text = text.replace(root, prefixed)
text = text.replace(marker, prefixed)
text = text.replace(escaped_marker, escaped_prefixed)
return text
def rewrite_html(body, prefix, content_type="", public_hosts=None):
text = body.decode("utf-8", errors="ignore")
escaped_prefix = prefix.replace("/", "\\/")
text, protected_resource_roots = protect_luci_resource_root(text)
replacements = {
'href="/': f'href="{prefix}/',
'src="/': f'src="{prefix}/',
'action="/': f'action="{prefix}/',
'data-url="/': f'data-url="{prefix}/',
"href=/": f"href={prefix}/",
"src=/": f"src={prefix}/",
"action=/": f"action={prefix}/",
"data-url=/": f"data-url={prefix}/",
"href='/": f"href='{prefix}/",
"src='/": f"src='{prefix}/",
"action='/": f"action='{prefix}/",
"data-url='/": f"data-url='{prefix}/",
'url("/': f'url("{prefix}/',
"url('/": f"url('{prefix}/",
"url(/": f"url({prefix}/",
'"/ubus"': f'"{prefix}/ubus"',
"'/ubus'": f"'{prefix}/ubus'",
"`/ubus`": f"`{prefix}/ubus`",
'"/cgi-bin/luci"': f'"{prefix}/cgi-bin/luci"',
"'/cgi-bin/luci'": f"'{prefix}/cgi-bin/luci'",
"`/cgi-bin/luci`": f"`{prefix}/cgi-bin/luci`",
'"/cgi-bin/luci': f'"{prefix}/cgi-bin/luci',
'"/ubus/': f'"{prefix}/ubus/',
'"/luci-static/': f'"{prefix}/luci-static/',
"'/cgi-bin/luci": f"'{prefix}/cgi-bin/luci",
"'/ubus/": f"'{prefix}/ubus/",
"'/luci-static/": f"'{prefix}/luci-static/",
"`/cgi-bin/luci": f"`{prefix}/cgi-bin/luci",
"`/ubus/": f"`{prefix}/ubus/",
"`/luci-static/": f"`{prefix}/luci-static/",
'"\\/ubus"': f'"{escaped_prefix}\\/ubus"',
"'\\/ubus'": f"'{escaped_prefix}\\/ubus'",
"`\\/ubus`": f"`{escaped_prefix}\\/ubus`",
'"\\/cgi-bin\\/luci"': f'"{escaped_prefix}\\/cgi-bin\\/luci"',
"'\\/cgi-bin\\/luci'": f"'{escaped_prefix}\\/cgi-bin\\/luci'",
"`\\/cgi-bin\\/luci`": f"`{escaped_prefix}\\/cgi-bin\\/luci`",
'"\\/cgi-bin\\/luci': f'"{escaped_prefix}\\/cgi-bin\\/luci',
'"\\/ubus\\/': f'"{escaped_prefix}\\/ubus\\/',
'"\\/luci-static\\/': f'"{escaped_prefix}\\/luci-static\\/',
"'\\/cgi-bin\\/luci": f"'{escaped_prefix}\\/cgi-bin\\/luci",
"'\\/ubus\\/": f"'{escaped_prefix}\\/ubus\\/",
"'\\/luci-static\\/": f"'{escaped_prefix}\\/luci-static\\/",
"`\\/cgi-bin\\/luci": f"`{escaped_prefix}\\/cgi-bin\\/luci",
"`\\/ubus\\/": f"`{escaped_prefix}\\/ubus\\/",
"`\\/luci-static\\/": f"`{escaped_prefix}\\/luci-static\\/",
}
for old, new in replacements.items():
text = text.replace(old, new)
text = rewrite_public_absolute_urls(text, prefix, public_hosts or [])
text = rewrite_remaining_luci_roots(text, prefix)
text = restore_luci_resource_root(text, protected_resource_roots)
if "text/html" in (content_type or "").lower():
script = proxy_runtime_script(prefix)
head_match = re.search(r"]*>", text, flags=re.IGNORECASE)
if head_match:
text = text[: head_match.end()] + "\n" + script + text[head_match.end() :]
elif "" in text:
text = text.replace("", script + "\n", 1)
elif "
GitHub
Сохрани OAuth Client ID/Secret, затем привяжи тот GitHub-аккаунт, которому разрешён вход в Hub.
VK ID
Современный VK ID OAuth 2.1 flow с PKCE: сохрани Client ID, при confidential-приложении добавь Service Token, затем привяжи конкретный VK ID.