Привязанные сервисыGitHub и VK ID для входа без отдельного пароля приложения. На экране входа показываются только реально привязанные аккаунты.
⌄
GitHub
Сохрани OAuth Client ID/Secret, затем привяжи тот GitHub-аккаунт, которому разрешён вход в Hub.
Не настроен
Появится на странице входа только после успешной привязки хотя бы одного GitHub-аккаунта.
VK ID
Современный VK ID OAuth 2.1 flow с PKCE: сохрани Client ID, при confidential-приложении добавь Service Token, затем привяжи конкретный VK ID.
Не настроен
На странице входа будут видны только привязанные VK ID. Для confidential-приложения VK ID во втором поле нужен Service Token.
Управление сессиямиАктивные входы в Hub и быстрое завершение лишних сессий.
⌄
Управление сессиями
Ограниченные пользователиУчётки с флагами A, B и G только на выбранные роутеры.
⌄
Доступ к роутерам
A = только LuCI, B = SSH к роутеру, G = полный доступ к панели этого роутера без VPS/Xray/backup, а также просмотр, добавление и редактирование заметок.
УведомленияWeb Push для входов, смены IP и событий VPS/Hub.
⌄
Уведомления
Web Push для входов в панель, смены IP и запуска VPS/Hub. На iOS включай из приложения Hub с экрана Домой.
Обновить все роутеры разомОбщая команда и SSH-пароль, последовательное обновление с итогом по каждому роутеру.
Архив переносит БД роутеров, логин, токены Hub/агента, push-ключи и уведомления. Для переезда на другой IP укажи новый VPS host/Public URL перед восстановлением.
Команда выполняется на роутерах по очереди через SSH. Укажи один общий SSH-пароль root. Для каждого роутера будет отдельный итог. Если SSH-туннель не работает, отправить команду этому роутеру через VPS не получится.
«Остановить всё» сразу прекращает очередь и отправляет остановку текущей задачи. Уже внесённые установщиком изменения не откатываются. Если SSH недоступен, панель покажет, что остановка на роутере не подтверждена. При перезапуске очередь останавливается сразу, но уже отправленный reboot отменить нельзя.
Перезапуск идёт по очереди. «Успешно» означает, что роутер загрузился заново и SSH восстановился. Ожидание — до 3 минут на роутер; при ошибке или отсутствии подтверждения очередь продолжится.
Список роутеров
Загрузка
Получаю данные…0%
Всего роутеров0
Обновляются0
Ожидают0
Успешно0
Проблемы обновления
Здесь перечислены роутеры без подтверждённого успеха и причины результата.
Получаю список роутеров…
Роутеры
Текущая связь определяется по Heartbeat. Итог команды показан отдельно и не означает, что роутер сейчас онлайн.
Действия панели, Heartbeat, WAN, предупреждения и ошибки Xray этого роутера. Доставка проверяется каждые 3 секунды; новые записи обычно появляются после пакетной записи на Flash, до 60 секунд. На обновлённом роутере журнал сохраняется на проверенной Flash, временный буфер ограничен 16 КиБ. Если роутер оффлайн, доступны последние доставленные записи. Архив VPS хранится в SQLite на диске: до 2 МиБ на роутер. Ключи и пароли скрываются.
'''.replace('__TITLE__', title).replace('__DOWNLOAD__', download).replace('__ENDPOINT__', endpoint)
def router_notes_html(router, username="", saved="", error="", draft=None, edit_note_id=""):
router = dict(router or {})
router_id = str(router.get("id") or "").strip()
router_name = str(router.get("name") or router_id or "router").strip()
permissions = router.get("permissions") if isinstance(router.get("permissions"), dict) else {}
can_edit = bool(permissions.get("notes_edit") or permissions.get("manage"))
can_delete = bool(permissions.get("notes_delete") or permissions.get("owner"))
note_entries = list(router.get("notes_entries") or [])
visible_entries = list(reversed(note_entries))
has_note_images = any(bool(item.get("images")) for item in visible_entries)
edit_note_id = str(edit_note_id or "").strip()
if not can_edit:
edit_note_id = ""
notes_value = clean_router_notes(draft if draft is not None else "")
safe_router_name = html.escape(router_name)
safe_notes = html.escape(notes_value)
safe_notes_url = html.escape(str(router.get("notes_url") or f"/router/{urllib.parse.quote(router_id)}/notes"), quote=True)
note_len = len(notes_value)
notes_total = len(note_entries)
message_html = ""
saved = str(saved or "").strip().lower()
def render_note_images_html(images):
tiles = []
for image in list(images or []):
image_url = html.escape(str(image.get("url") or ""), quote=True)
if not image_url:
continue
image_name = html.escape(str(image.get("name") or "Изображение"))
tiles.append(
f"""
{image_name}"""
)
return f'
{"".join(tiles)}
' if tiles else ""
if error:
message_html = f'
{html.escape(str(error))}
'
elif saved == "added":
message_html = '
Заметка опубликована.
'
elif saved == "updated":
message_html = '
Заметка обновлена.
'
elif saved == "deleted":
message_html = '
Заметка удалена.
'
read_only_css = ""
view_only_notice_html = ""
if not can_edit:
read_only_css = ".notesLayout{grid-template-columns:1fr}.editor{display:none}.cardActions{display:none!important}"
view_only_notice_html = '
Доступ к заметкам открыт только для просмотра.
'
notes_layout_class = "notesLayout notesLayoutMedia" if has_note_images else "notesLayout"
notes_items = []
for item in visible_entries:
note_id = str(item.get("id") or "")
safe_note_id = html.escape(note_id, quote=True)
safe_edit_link = html.escape(f"{router.get('notes_url') or f'/router/{urllib.parse.quote(router_id)}/notes'}?edit={urllib.parse.quote(note_id)}", quote=True)
note_time_iso = html.escape(str(item.get("created_at_iso") or ""), quote=True)
note_time_label = html.escape(str(item.get("created_at_label") or "Дата публикации неизвестна"))
note_text_html = ""
if str(item.get("text") or "").strip():
note_text_html = f'
{html.escape(str(item.get("text") or "")).replace(chr(10), " ")}
'
note_images_html = render_note_images_html(item.get("images") or [])
if can_edit and note_id == edit_note_id:
edit_text = clean_router_notes(draft if draft is not None else item.get("text") or "")
safe_edit_text = html.escape(edit_text)
edit_count = len(edit_text)
note_body_html = f"""
"""
else:
note_action_parts = []
if can_edit:
note_action_parts.append(f'Редактировать')
if can_delete:
note_action_parts.append(
f"""
"""
)
note_actions_html = ""
if note_action_parts:
note_actions_html = f"""
Открой 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.
После этого рядом появится файл C:\\Users\\ВАШЕ_ИМЯ\\AppData\\Local\\Temp\\hub-challenge.txt.sig.
7. Покажи подпись и скопируй весь блок
Нужен весь текст от -----BEGIN SSH SIGNATURE----- до -----END SSH SIGNATURE-----.
PowerShell
Get-Content $env:TEMP\\hub-challenge.txt.sig
8. Вставь подпись обратно в Hub
Вернись на экран логина, вставь весь блок подписи в поле SSH signature и нажми Проверить подпись. Если все ок, Hub впустит без пароля.
Если команда ssh-keygen не работает
Проверь, установлен ли OpenSSH Client в Windows.
PowerShell
ssh -V
"""
_base_login_html = login_html
def login_html(error=""):
auth = normalize_auth_state(load_auth())
page = _base_login_html(error)
state = effective_captcha_state(auth)
if state.get("effective_mode") not in CAPTCHA_RECAPTCHA_MODES:
return page
replacement = modern_login_captcha_html(auth)
page, count = re.subn(
r'
.*?',
replacement,
page,
count=1,
flags=re.S,
)
if count and ".captchaSectionRecaptcha" not in page:
page = page.replace(
".captchaRefresh:active{transform:translateY(1px)}",
".captchaRefresh:active{transform:translateY(1px)}"
".captchaSectionRecaptcha{width:min(100%,336px);padding:10px 10px 8px;gap:8px}"
".captchaHint{color:var(--muted);font-size:12px;line-height:1.45}"
".recaptchaBox{display:flex;justify-content:center;align-items:flex-start;width:100%;min-width:0;overflow:hidden;padding:2px 0 0}",
1,
)
script = login_recaptcha_script(auth)
if script and script not in page:
page = page.replace("", f"{script}\n", 1)
return page
class VpsResourceMonitor:
"""Shared, nonblocking Linux samples; never spawn commands per browser poll."""
interval = 1.0
def __init__(self, proc_dir="/proc", disk_path="/"):
self.proc_dir = Path(proc_dir)
self.disk_path = disk_path
self.lock = threading.Lock()
self.last_sample = None
self.cached = None
self.cpu_previous = self.read_cpu()
def read_cpu(self):
try:
with (self.proc_dir / "stat").open(encoding="ascii") as source:
values = source.readline().split()
if not values or values[0] != "cpu" or len(values) < 5:
return None
ticks = [int(value) for value in values[1:9]]
# guest/guest_nice are already included in user/nice; do not sum twice.
return sum(ticks), ticks[3] + (ticks[4] if len(ticks) > 4 else 0)
except (OSError, ValueError):
return None
def cpu_usage(self):
current = self.read_cpu()
previous, self.cpu_previous = self.cpu_previous, current
percent = None
if current is not None and previous is not None:
total, idle = current[0] - previous[0], current[1] - previous[1]
if total > 0 and idle >= 0:
percent = round(max(0.0, min(100.0, 100 * (total - idle) / total)), 1)
return {"percent": percent, "cores": os.cpu_count() or 1}
def memory_usage(self):
try:
with (self.proc_dir / "meminfo").open(encoding="ascii") as source:
values = {key: int(value.split()[0]) * 1024 for key, value in
(line.split(":", 1) for line in source if ":" in line)}
total = values["MemTotal"]
available = values.get("MemAvailable")
if available is None:
available = (values.get("MemFree", 0) + values.get("Buffers", 0) +
values.get("Cached", 0) + values.get("SReclaimable", 0) -
values.get("Shmem", 0))
if total <= 0:
return None
available = max(0, min(total, available))
used = total - available
return {"percent": round(used * 100 / total, 1), "used_bytes": used,
"total_bytes": total, "available_bytes": available}
except (OSError, ValueError, KeyError, IndexError):
return None
def disk_usage(self):
try:
usage = shutil.disk_usage(self.disk_path)
if usage.total <= 0:
return None
return {"percent": round(usage.used * 100 / usage.total, 1),
"used_bytes": usage.used, "total_bytes": usage.total,
"free_bytes": usage.free, "path": self.disk_path}
except OSError:
return None
def snapshot(self):
with self.lock:
now = time.monotonic()
if self.cached is None or now - self.last_sample >= self.interval:
self.cached = {"cpu": self.cpu_usage(), "memory": self.memory_usage(),
"disk": self.disk_usage(), "sampled_at": time.time()}
self.last_sample = now
return self.cached
def normalize_router_update_command(command):
command = command.removeprefix('\ufeff').replace('\r\n', '\n').replace('\r', '\n').strip()
url = command[1:-1] if command[:1] in {'"', "'"} and command[-1:] == command[:1] else command
if not re.match(r'(?i)^https?://', url):
return command
try:
parsed = urllib.parse.urlsplit(url)
valid = parsed.hostname and parsed.scheme.lower() in {'http', 'https'} and parsed.port != 0
except ValueError:
valid = False
if not valid or re.search(r'\s|[\x00-\x1f\x7f]', url):
raise ValueError('Нужна прямая ссылка HTTP/HTTPS без пробелов или полная shell-команда обновления.')
return '''set -e
: "${OWRT_REMOTE_UPDATE_DIR:?}"
file="$OWRT_REMOTE_UPDATE_DIR/download.sh"
echo 'Загрузка установочного скрипта…'
if command -v curl >/dev/null 2>&1; then
curl -fL --connect-timeout 10 -o "$file" -- __URL__
else
wget -O "$file" __URL__
fi
[ -s "$file" ] || { echo 'Ошибка: получен пустой установочный скрипт'; exit 1; }
echo 'Скрипт загружен; запуск установки…'
/bin/sh "$file"
'''.replace('__URL__', shlex.quote(url))
def router_update_name(row, reported_name=''):
"""Prefer UCI's router_name; keep the stable router ID a separate field."""
try:
cached_name = json.loads(row.get('status_json') or '{}').get('name')
except (ValueError, AttributeError):
cached_name = ''
for value in (reported_name, cached_name, row.get('custom_name')):
name = re.sub(r'[\x00-\x1f\x7f]', ' ', str(value or '')).strip()[:200]
if name:
return name
return 'Имя роутера не получено'
def router_update_status(row):
try:
status = json.loads(row.get('status_json') or '{}')
status = status if isinstance(status, dict) else {}
except ValueError:
status = {}
last_seen = int(row.get('last_seen') or 0)
xray = str(status.get('xray') or '')
return {'id': row['id'], 'name': router_update_name(row),
'online': bool(last_seen and now_ts() - last_seen <= router_online_timeout(status)),
'last_seen': last_seen,
'xray': xray if xray in {'running', 'stopped'} else 'unknown'}
def router_update_preflight_script():
return r'''set -eu
printf 'OWRT_UPDATE_NAME_TEXT='
(uci -q get owrtremote.main.router_name || true) | head -c 512 | tr '\r\n' ' '
printf '\n'
for tool in uci setsid mkfifo dd cut head tail tr wc cat mv rm mkdir sleep; do
if ! command -v "$tool" >/dev/null 2>&1; then
printf 'OWRT_UPDATE_STATE=not_started\nOWRT_UPDATE_ERROR=На роутере отсутствует утилита %s. Команда обновления не запускалась.\n' "$tool"
exit 0
fi
done
printf 'OWRT_UPDATE_READY=1\n'
'''
def router_update_launch_script(task_id, command, timeout=180):
"""Stage a detached router-side task; never execute the owner's command on VPS."""
# POSIX printf is an ash builtin even when BusyBox has no base64 applet.
encoded = ''.join('\\0%03o' % byte for byte in command.encode('utf-8'))
return r'''set -eu
umask 077
job=/tmp/owrt-remote-update-__TASK__
limit=__TIMEOUT__
started=0
launch_exit() {
rc=$?
trap - EXIT
if [ "$rc" -ne 0 ] && [ "$started" = 0 ]; then
printf 'OWRT_UPDATE_STATE=not_started\nOWRT_UPDATE_ERROR=Подготовка задачи на роутере завершилась ошибкой, rc=%s. Команда обновления не запускалась.\n' "$rc"
exit 0
fi
exit "$rc"
}
trap launch_exit EXIT
if [ ! -d "$job" ]; then
command -v setsid >/dev/null || { echo 'setsid is required'; exit 1; }
mkdir "$job"
printf '%b' '__COMMAND__' >"$job/command.sh"
cat >"$job/runner.sh" <<'OWRT_UPDATE_RUNNER'
#!/bin/sh
umask 077
job=$1
clock() { cut -d. -f1 /proc/uptime; }
stop_group() {
case "$1" in ''|*[!0-9]*) return;; esac
[ "$1" -gt 1 ] || return
kill -TERM "-$1" 2>/dev/null || true
sleep 1
kill -KILL "-$1" 2>/dev/null || true
}
if [ "${2:-}" = reader ]; then
while :; do
dd bs=4096 count=1 <&3 >"$job/chunk" 2>/dev/null
[ -s "$job/chunk" ] || break
cat "$job/chunk" >>"$job/output"
bytes=$(wc -c <"$job/output")
if [ "$bytes" -gt 32768 ]; then
tail -c 16384 "$job/output" >"$job/output.new" && mv "$job/output.new" "$job/output"
fi
done 3<"$job/stream"
exit
fi
limit=$2
printf '%s\n' "$$" >"$job/pid"
clock >"$job/started"
printf '%s\n' "$limit" >"$job/limit"
if [ -e "$job/cancel" ]; then
echo cancelled >"$job/reason"
echo 130 >"$job/result"
exit 0
fi
mkfifo "$job/stream" || exit 1
# Separate groups let cancellation target only this task's processes.
setsid /bin/sh "$job/runner.sh" "$job" reader &
reader=$!
export OWRT_REMOTE_UPDATE_DIR="$job"
# BusyBox ash's pipefail also catches wget failures in `wget ... | sh`.
setsid /bin/sh -ec 'set -o pipefail; . "$1"' sh "$job/command.sh" >"$job/stream" 2>&1 &
installer=$!
reason=exit
started=$(cat "$job/started")
while kill -0 "$installer" 2>/dev/null; do
if [ -e "$job/cancel" ]; then reason=cancelled; break; fi
now=$(clock)
if [ "$((now - started))" -ge "$limit" ]; then reason=timeout; break; fi
sleep 1
done
if [ "$reason" != exit ]; then
stop_group "$installer"
wait "$installer" 2>/dev/null || true
if [ "$reason" = cancelled ]; then rc=130; else rc=124; fi
else
wait "$installer"
rc=$?
fi
# A daemon may inherit stdout from the installer. Bound FIFO drain time.
drain=0
while kill -0 "$reader" 2>/dev/null && [ "$drain" -lt 2 ]; do sleep 1; drain=$((drain + 1)); done
if kill -0 "$reader" 2>/dev/null; then
stop_group "$reader"
wait "$reader" 2>/dev/null || true
else
wait "$reader" || { [ "$rc" -ne 0 ] || rc=125; }
fi
printf '%s\n' "$reason" >"$job/reason"
printf '%s\n' "$rc" >"$job/result.new"
mv "$job/result.new" "$job/result"
rm -f "$job/stream" "$job/chunk" "$job/command.sh" "$job/download.sh" "$job/runner.sh"
OWRT_UPDATE_RUNNER
# OpenWrt supplies setsid by default; nohup is optional. Ignore HUP before
# exec so loss of the reverse SSH connection cannot kill the installer.
(trap '' HUP; exec setsid /bin/sh "$job/runner.sh" "$job" "$limit") /dev/null 2>&1 &
fi
started=1
printf 'OWRT_UPDATE_STARTED=1\n'
'''.replace('__TASK__', task_id).replace('__COMMAND__', encoded).replace('__TIMEOUT__', str(int(timeout)))
def router_update_cancel_script(task_id):
# A tombstone blocks delayed launches; the runner records the actual result
# after stopping its own installer group, without matching unrelated PIDs.
return ('umask 077\njob=/tmp/owrt-remote-update-' + task_id + '\n'
+ '''if mkdir "$job" 2>/dev/null; then
: >"$job/cancel"
echo cancelled >"$job/reason"
echo 130 >"$job/result.new"
mv "$job/result.new" "$job/result"
else
: >"$job/cancel"
fi
echo OWRT_UPDATE_CANCEL=1
''')
def router_update_poll_script(task_id, cleanup=False):
prefix = 'job=/tmp/owrt-remote-update-' + task_id + '\n'
if cleanup:
return prefix + '''[ -s "$job/result" ] || exit 0
rm -f "$job/result" "$job/result.new" "$job/pid" "$job/output" "$job/output.new" "$job/chunk" "$job/stream" "$job/command.sh" "$job/download.sh" "$job/runner.sh" "$job/started" "$job/limit" "$job/reason"
# Keep the tiny cancellation marker until reboot. A launch still in transit
# must not start this task after the confirmed result has been cleaned up.
[ ! -e "$job/cancel" ] || exit 0
rmdir "$job" 2>/dev/null || true
'''
return prefix + r'''if [ ! -d "$job" ]; then echo OWRT_UPDATE_STATE=missing; exit 0; fi
if [ -s "$job/result" ]; then
printf 'OWRT_UPDATE_RC='; cat "$job/result"
echo OWRT_UPDATE_STATE=done
elif [ -s "$job/pid" ] && kill -0 "$(cat "$job/pid")" 2>/dev/null; then
echo OWRT_UPDATE_STATE=running
elif [ -s "$job/pid" ]; then
echo OWRT_UPDATE_STATE=dead
else
echo OWRT_UPDATE_STATE=starting
fi
printf 'OWRT_UPDATE_REASON='; cat "$job/reason" 2>/dev/null || echo
printf 'OWRT_UPDATE_OUTPUT_TEXT=\n'
tail -c 8192 "$job/output" 2>/dev/null || true
'''
def router_update_fields(output):
# The final text payload is bounded on the router. Parse metadata only
# before it, so installer output cannot forge a result or another name.
header, separator, payload = str(output or '').partition('\nOWRT_UPDATE_OUTPUT_TEXT=\n')
fields = {}
for line in header.splitlines():
key, separator, value = line.partition('=')
if separator and key.startswith('OWRT_UPDATE_'):
fields[key.removeprefix('OWRT_UPDATE_')] = value
for key in ('NAME', 'OUTPUT'):
try:
fields[key] = base64.b64decode(fields.get(key, ''), validate=True).decode('utf-8', 'replace')
except (ValueError, UnicodeError):
fields[key] = ''
if 'NAME_TEXT' in fields:
fields['NAME'] = fields.pop('NAME_TEXT').strip()
if separator:
fields['OUTPUT'] = payload
return fields
def router_reboot_probe_script(task_id=''):
script = r'''set -eu
printf 'OWRT_UPDATE_NAME_TEXT='
(uci -q get owrtremote.main.router_name || true) | head -c 512 | tr '\r\n' ' '
printf '\nOWRT_UPDATE_BOOT_ID='
cat /proc/sys/kernel/random/boot_id
'''
if task_id:
script += ('job=/tmp/owrt-remote-reboot-' + task_id + '\n' + r'''if [ -s "$job/result" ]; then
printf 'OWRT_UPDATE_RC='; cat "$job/result"
fi
printf 'OWRT_UPDATE_OUTPUT_TEXT=\n'
tail -c 2048 "$job/output" 2>/dev/null || true
''')
else:
script += r'''for tool in uci setsid reboot sleep mkdir cat head tail tr mv; do
if ! command -v "$tool" >/dev/null 2>&1; then
printf 'OWRT_UPDATE_STATE=not_started\nOWRT_UPDATE_ERROR=На роутере отсутствует утилита %s. Перезагрузка не запускалась.\n' "$tool"
exit 0
fi
done
printf 'OWRT_UPDATE_READY=1\n'
'''
return script
def router_reboot_launch_script(task_id, delay=3):
# Give SSH time to deliver the receipt; a new boot_id confirms the reboot.
return r'''set -eu
umask 077
job=/tmp/owrt-remote-reboot-__TASK__
started=0
launch_exit() {
rc=$?
trap - EXIT
if [ "$rc" -ne 0 ] && [ "$started" = 0 ]; then
printf 'OWRT_UPDATE_STATE=not_started\nOWRT_UPDATE_ERROR=Не удалось подготовить перезагрузку, rc=%s. Команда reboot не запускалась.\n' "$rc"
exit 0
fi
exit "$rc"
}
trap launch_exit EXIT
if [ ! -d "$job" ]; then
mkdir "$job"
cat >"$job/reboot.sh" <<'OWRT_REBOOT_RUNNER'
#!/bin/sh
job=$1
sleep __DELAY__
reboot >"$job/output" 2>&1
rc=$?
printf '%s\n' "$rc" >"$job/result.new"
mv "$job/result.new" "$job/result"
OWRT_REBOOT_RUNNER
(trap '' HUP; exec setsid /bin/sh "$job/reboot.sh" "$job") /dev/null 2>&1 &
fi
started=1
printf 'OWRT_UPDATE_STARTED=1\n'
'''.replace('__TASK__', task_id).replace('__DELAY__', str(max(0, int(delay))))
class RouterUpdateManager:
"""One sequential owner-controlled queue per Hub, independent of the browser."""
POLL_SECONDS = 3
ROUTER_TIMEOUT = 180
LAUNCH_TIMEOUT = 15
CONNECTION_TIMEOUT = 30
SILENCE_TIMEOUT = 90
STOP_TIMEOUT = 10
RESULT_TTL = 7200
REBOOT_TIMEOUT = 180
def __init__(self, app):
self.app = app
self.lock = threading.Lock()
self.csrf = secrets.token_urlsafe(32)
self.job = None
self.thread = None
self.stopping = threading.Event()
self.wake = threading.Event()
self.cancel_event = threading.Event()
self.transport_lock = threading.Lock()
self.transport = None
def _ssh(self, row, script, password):
# Keep this transport interruptible without changing other SSH features.
helper = Handler.__new__(Handler)
env, args = helper.ssh_exec_args(int(row['ssh_entry_port']), allow_password=bool(password))
askpass = helper.prepare_ssh_askpass(env, password)
process = None
received = False
try:
process = subprocess.Popen(args + ['sh', '-s', '--'], stdin=subprocess.PIPE,
stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True,
encoding='utf-8', errors='replace', env=env,
start_new_session=bool(password))
with self.transport_lock:
self.transport = process
try:
stdout, stderr = process.communicate(str(script), timeout=10)
received = True
except subprocess.TimeoutExpired as exc:
raise RuntimeError('SSH: нет ответа за 10 секунд') from exc
if process.returncode:
raise RuntimeError((stderr or stdout or '').strip() or 'SSH-соединение прервано')
return stdout
finally:
if process:
if process.poll() is None:
try:
process.kill()
except OSError:
pass
if not received:
process.communicate()
with self.transport_lock:
if self.transport is process:
self.transport = None
if askpass:
shutil.rmtree(askpass, ignore_errors=True)
def _interrupt_transport(self):
with self.transport_lock:
process = self.transport
if process and process.poll() is None:
try:
process.kill()
except OSError:
pass
def snapshot(self):
with self.lock:
if self.job and self.job['state'] != 'running' and time.time() - self.job['finished_at'] > self.RESULT_TTL:
self.job = None
return json.loads(json.dumps(self.job)) if self.job else None
def clear_finished(self, job_id):
if not isinstance(job_id, str):
raise ValueError('Некорректный идентификатор очереди.')
with self.lock:
# A stale browser must not erase a newer job or an active worker.
if self.job and self.job['id'] == job_id and self.job['state'] != 'running':
self.job = None
def start_reboot(self, password, request_id):
return self.start('', password, request_id, operation='reboot')
def start(self, command, password, request_id, operation='update'):
if operation not in {'update', 'reboot'}:
raise ValueError('Неизвестное действие очереди.')
if operation == 'update' and (not isinstance(command, str) or not command.strip() or len(command.encode('utf-8')) > 8192 or '\x00' in command):
raise ValueError('Укажи команду обновления размером до 8 КиБ без нулевых символов.')
if not isinstance(password, str) or len(password.encode('utf-8')) > 1024 or '\x00' in password:
raise ValueError('Некорректный SSH-пароль.')
if not isinstance(request_id, str) or not re.fullmatch(r'[a-zA-Z0-9_-]{16,80}', request_id):
raise ValueError('Некорректный идентификатор запроса. Обнови страницу.')
command = normalize_router_update_command(command) if operation == 'update' else ''
with self.lock:
if self.job and self.job['request_id'] == request_id:
if self.job['operation'] != operation:
raise ValueError('Этот запрос уже использован для другого действия. Обнови страницу.')
return self.job['id']
if self.job and self.job['state'] == 'running':
raise RuntimeError('Очередь уже запущена. Дождись её завершения или останови очередь.')
if self.stopping.is_set():
raise RuntimeError('Hub завершает работу. Повтори после запуска.')
self.cancel_event.clear()
self.wake.clear()
with self.app.conn() as conn:
rows = [dict(row) for row in list_router_rows(conn)]
if not rows:
raise ValueError('Нет роутеров для запуска очереди.')
if len(rows) > 512:
raise ValueError('В одной очереди поддерживается до 512 роутеров.')
items = []
for row in rows:
items.append({'id': row['id'], 'name': router_update_name(row),
'state': 'queued', 'message': 'Ожидает очереди', 'output': '', 'elapsed_seconds': 0})
job_id = secrets.token_hex(16)
self.job = {'id': job_id, 'request_id': request_id, 'operation': operation, 'state': 'running', 'started_at': time.time(),
'finished_at': 0, 'cancel_requested': False, 'items': items}
self.thread = threading.Thread(target=self._run, args=(rows, command, password, job_id, operation), daemon=True,
name='owrt-router-updates')
try:
self.thread.start()
except BaseException:
self.job = None
self.thread = None
raise
return job_id
def cancel(self, job_id):
with self.lock:
if not self.job or self.job['id'] != job_id:
raise ValueError('Очередь не найдена.')
self.job['cancel_requested'] = True
for item in self.job['items']:
if item['state'] == 'queued':
item.update(state='skipped', message='Пропущен: очередь остановлена пользователем')
elif item['state'] in {'connecting', 'running', 'cancelling'}:
item['state'] = 'cancelling'
item['message'] = ('Останавливаю очередь; уже отправленный reboot не отменяется'
if self.job['operation'] == 'reboot' else 'Останавливаю текущую задачу…')
self.cancel_event.set()
self.wake.set()
self._interrupt_transport()
def _set(self, index, **values):
with self.lock:
self.job['items'][index].update(values)
def _cancelled(self):
with self.lock:
return self.stopping.is_set() or self.job['cancel_requested']
@staticmethod
def _safe(text, password):
text = str(text or '')
if password:
text = text.replace(password, '[пароль скрыт]')
text = redact_router_log_bytes(text.encode('utf-8', 'replace')).decode('utf-8', 'replace')
return re.sub(r'[\x00-\x08\x0b-\x1f\x7f]', '', text)[-8192:]
@classmethod
def _ssh_error(cls, error, password):
# Diagnose SSH's authentication response before the general secret
# filter hides its literal "password" authentication method name.
text = str(error or '')
denied = re.search(
r'(?im)^(?:[^\s@]+@[^\s:]+:\s*)?Permission denied'
r'(?:\s*\(([^)\r\n]*)\)[.!]?|,\s*please try again[.!]?|[.!]?)\s*$', text)
failed = re.search(r'(?im)^(?:ssh:\s*)?Authentication failed[.!]?\s*$', text)
if denied or failed:
methods = set((denied.group(1) or '').lower().replace(' ', '').split(',')) if denied else set()
if password:
if denied and denied.group(1) and not methods.intersection({'password', 'keyboard-interactive'}):
return 'SSH-сервер не предлагает вход по паролю. Проверь разрешение входа root по SSH.'
return ('Общий SSH-пароль не принят этим роутером. Возможно, пароль роутера отличается '
'от общего; проверь его пароль и разрешение входа root по SSH.')
return 'SSH-авторизация отклонена. Укажи пароль root или проверь SSH-ключ доступа к этому роутеру.'
safe = cls._safe(text, password)[:1200]
if re.search(r'(?i)(?:connection timed out during banner exchange|banner exchange:.*(?:timed out|timeout))', text):
return ('SSH не прислал приветствие за отведённое время. До проверки пароля дело не дошло. '
'По этому ответу нельзя отличить проблему обратного туннеля от зависания SSH-сервера. '
'Технический ответ: ' + safe)
return cls._safe(text, password)[:1200] or 'Ошибка подключения по SSH'
def _run(self, rows, command, password, job_id, operation):
try:
for index, row in enumerate(rows):
if self._cancelled():
self._set(index, state='skipped', message='Пропущен: очередь остановлена')
continue
try:
# Reload ports/deletion state immediately before this router,
# without retaining a database connection during SSH waits.
with self.app.conn() as conn:
current = get_active_router(conn, row['id'])
current = dict(current) if current else None
if not current:
self._set(index, state='skipped', message='Роутер удалён из Hub')
continue
if operation == 'reboot':
self._reboot_one(index, current, password, job_id)
else:
self._update_one(index, current, command, password, job_id)
except Exception as exc:
cancelled = self.cancel_event.is_set()
self._set(index, state='cancelled' if cancelled else 'error',
message=('Остановлено до отправки команды ' + ('reboot' if operation == 'reboot' else 'установки'))
if cancelled else self._ssh_error(exc, password))
finally:
password = ''
command = ''
with self.lock:
self.job['state'] = 'finished'
self.job['finished_at'] = time.time()
def _reboot_one(self, index, row, password, job_id):
if not int(row.get('ssh_entry_port') or 0):
self._set(index, state='skipped', message='SSH-туннель не настроен; команда reboot не отправлена')
return
if self._cancelled():
self._set(index, state='skipped', message='Пропущен: очередь остановлена')
return
self._set(index, state='connecting', message='Проверяю SSH перед перезагрузкой')
try:
fields = router_update_fields(self._ssh(row, router_reboot_probe_script(), password))
except Exception as exc:
cancelled = self._cancelled()
self._set(index, state='cancelled' if cancelled else 'error',
message=('Остановлено до отправки reboot' if cancelled else
self._ssh_error(exc, password) + '. Команда reboot не отправлена.'))
return
self._set(index, name=router_update_name(row, fields.get('NAME', '')))
if fields.get('STATE') == 'not_started':
self._set(index, state='error', message=self._safe(fields.get('ERROR'), password)
or 'Проверка роутера не пройдена; команда reboot не отправлена')
return
boot_id = fields.get('BOOT_ID', '')
if fields.get('READY') != '1' or not re.fullmatch(r'[a-fA-F0-9-]{36}', boot_id):
self._set(index, state='error', message='Не получен идентификатор загрузки роутера; команда reboot не отправлена')
return
if self._cancelled():
self._set(index, state='cancelled', message='Остановлено до отправки reboot')
return
task_id = job_id + '-' + str(index)
started = time.monotonic()
last_error = ''
accepted = False
try:
fields = router_update_fields(self._ssh(row, router_reboot_launch_script(task_id), password))
if fields.get('STATE') == 'not_started':
self._set(index, state='error', message=self._safe(fields.get('ERROR'), password)
or 'Не удалось подготовить перезагрузку; команда reboot не запускалась')
return
accepted = fields.get('STARTED') == '1'
except Exception as exc:
# A disconnect may be the reboot itself. Never resend this task.
last_error = self._ssh_error(exc, password)
self._set(index, state='running', message='Команда reboot отправлена; ожидаю новую загрузку и восстановление SSH')
while not self._cancelled() and time.monotonic() - started < self.REBOOT_TIMEOUT:
elapsed = int(time.monotonic() - started)
try:
fields = router_update_fields(self._ssh(row, router_reboot_probe_script(task_id), password))
current_boot = fields.get('BOOT_ID', '')
if re.fullmatch(r'[a-fA-F0-9-]{36}', current_boot) and current_boot != boot_id:
self._set(index, state='success', elapsed_seconds=elapsed,
message='Роутер успешно перезагружен: новая загрузка и SSH подтверждены')
return
rc = fields.get('RC', '')
if re.fullmatch(r'\d{1,3}', rc) and rc != '0':
self._set(index, state='error', elapsed_seconds=elapsed,
message='Команда reboot завершилась ошибкой, rc=' + rc,
output=self._safe(fields.get('OUTPUT', ''), password))
return
except Exception as exc:
last_error = self._ssh_error(exc, password)
self._set(index, elapsed_seconds=elapsed,
message=('Команда reboot принята; ' if accepted else 'Отправка reboot не подтверждена; ')
+ 'ожидаю новую загрузку и SSH: ' + str(elapsed) + ' с из ' + str(self.REBOOT_TIMEOUT) + ' с')
self.wake.wait(self.POLL_SECONDS)
self.wake.clear()
message = ('Очередь остановлена; уже отправленный reboot не отменяется. '
if self._cancelled() else 'Новая загрузка и SSH не подтверждены за ' + str(self.REBOOT_TIMEOUT) + ' с. ')
self._set(index, state='unknown', elapsed_seconds=int(time.monotonic() - started),
message=message + 'Повторная команда не отправлялась. Проверь связь с роутером.'
+ (' Последний ответ SSH: ' + last_error if last_error else ''))
def _update_one(self, index, row, command, password, job_id):
if not int(row.get('ssh_entry_port') or 0):
self._set(index, state='skipped', message='SSH-туннель не настроен')
return
task_id = job_id + '-' + str(index)
with self.lock:
if self.cancel_event.is_set() or self.stopping.is_set():
self.job['items'][index].update(state='skipped', message='Пропущен: очередь остановлена')
return
self.job['items'][index].update(state='connecting', message='Подключаюсь по SSH')
try:
fields = router_update_fields(self._ssh(row, router_update_preflight_script(), password))
except Exception as exc:
cancelled = self.cancel_event.is_set()
self._set(index, state='cancelled' if cancelled else 'error',
message=('Остановлено до отправки команды установки' if cancelled else
self._ssh_error(exc, password) + '. Команда обновления не запускалась.'))
return
self._set(index, name=router_update_name(row, fields.get('NAME', '')))
if fields.get('STATE') == 'not_started':
self._set(index, state='error', message=self._safe(fields.get('ERROR'), password)
or 'Подготовка роутера не пройдена. Команда обновления не запускалась.')
return
if fields.get('READY') != '1':
raise RuntimeError('SSH не подтвердил готовность. Команда обновления не отправлена.')
if self.cancel_event.is_set() or self.stopping.is_set():
self._set(index, state='cancelled', message='Остановлено до отправки команды установки')
return
launched = False
launch_error = ''
started = time.monotonic()
hard_deadline = started + self.ROUTER_TIMEOUT
try:
fields = router_update_fields(self._ssh(row, router_update_launch_script(task_id, command, self.ROUTER_TIMEOUT), password))
if fields.get('STATE') == 'not_started':
self._set(index, state='error', message=self._safe(fields.get('ERROR'), password)
or 'Не удалось подготовить задачу на роутере. Команда обновления не запускалась.')
return
launched = fields.get('STARTED') == '1'
if fields.get('NAME', '').strip():
self._set(index, name=router_update_name(row, fields['NAME']))
except Exception as exc:
# SSH can close after the detached task was accepted. Poll its known
# ID instead of executing the installation a second time.
launch_error = self._ssh_error(exc, password)
self._set(index, state='running', message='Установка выполняется' if launched else 'Проверяю, запустилась ли установка')
last_error = launch_error
last_contact = time.monotonic()
last_progress = last_contact
previous_output = ''
stop_reason = ''
stop_deadline = None
cancel_delivered = False
timeout_reason = 'Превышено время установки (' + str(self.ROUTER_TIMEOUT) + ' с)'
while not self.stopping.is_set():
now = time.monotonic()
if self.cancel_event.is_set():
stop_reason = 'Остановка пользователем'
elif now - last_contact >= self.CONNECTION_TIMEOUT and not stop_reason:
stop_reason = 'SSH не отвечает ' + str(self.CONNECTION_TIMEOUT) + ' с: ' + (last_error or 'связь потеряна')
elif not launched and now - started >= self.LAUNCH_TIMEOUT and not stop_reason:
stop_reason = 'Запуск не подтверждён: ' + (launch_error or 'нет ответа задачи')
elif launched and not stop_reason and now - last_progress >= self.SILENCE_TIMEOUT:
stop_reason = 'Нет нового вывода установщика ' + str(self.SILENCE_TIMEOUT) + ' с; задача зависла или ожидает ввода'
elif now >= hard_deadline and not stop_reason:
stop_reason = timeout_reason
if stop_reason and stop_deadline is None:
stop_deadline = now + self.STOP_TIMEOUT
if stop_reason and not cancel_delivered:
try:
response = self._ssh(row, router_update_cancel_script(task_id), password)
cancel_delivered = 'OWRT_UPDATE_CANCEL=1' in response.splitlines()
except Exception as exc:
last_error = self._ssh_error(exc, password)
if stop_reason and (time.monotonic() >= stop_deadline or not cancel_delivered):
self._set(index, state='unknown', message=stop_reason + '. Результат и остановка не подтверждены'
+ (': ' + last_error if last_error else '')
+ '; после восстановления связи проверь роутер. Очередь продолжает работу.')
return
try:
fields = router_update_fields(self._ssh(row, router_update_poll_script(task_id), password))
now = time.monotonic()
elapsed = int(now - started)
output = self._safe(fields.get('OUTPUT', ''), password)
if fields.get('OUTPUT', '') != previous_output:
previous_output = fields.get('OUTPUT', '')
last_progress = now
self._set(index, output=output, elapsed_seconds=elapsed)
state = fields.get('STATE')
if self.cancel_event.is_set() and not stop_reason:
continue
if state in {'done', 'running', 'starting', 'dead', 'missing'}:
last_contact = now
if state == 'done':
rc = fields.get('RC', '')
if not re.fullmatch(r'\d{1,3}', rc):
raise RuntimeError('Роутер вернул некорректный результат установки')
reason = fields.get('REASON', '')
if reason == 'cancelled':
final_state = 'cancelled' if self.cancel_event.is_set() else 'error'
message = (stop_reason or 'Задача остановлена') + '; остановка на роутере подтверждена, rc=' + rc
elif reason == 'timeout':
final_state, message = 'error', timeout_reason + '; установщик остановлен на роутере, rc=' + rc
else:
final_state = 'success' if rc == '0' else 'error'
message = 'Установка успешно завершена, rc=0' if rc == '0' else 'Ошибка установки, rc=' + rc
if rc != '0':
lines = [line.strip() for line in output.splitlines()
if line.strip() and 'строка с ключом или паролем скрыта' not in line]
message += '. Последний вывод: ' + (' / '.join(lines[-3:])[-500:] if lines else 'установщик не передал описание ошибки')
self._set(index, state=final_state, message=message)
try:
self._ssh(row, router_update_poll_script(task_id, cleanup=True), password)
except Exception:
pass
return
if state == 'running' and not launched:
launched = True
if state == 'dead':
self._set(index, state='error', message='Процесс установки завершился без итогового кода; возможна ошибка запуска. Очередь продолжает работу.')
return
if state == 'starting' and now - started >= self.LAUNCH_TIMEOUT:
stop_reason = 'Задача установки не запустилась: ' + (launch_error or 'нет процесса установщика')
elif state == 'missing' and not launched and now - started >= self.LAUNCH_TIMEOUT:
stop_reason = 'Задача установки не запустилась: ' + (launch_error or 'нет процесса установщика')
if state == 'missing' and launched:
self._set(index, state='unknown' if launched else 'error',
message=('Результат установки потерян: временные файлы отсутствуют. Успех не подтверждён.'
if launched else launch_error or 'Установка не запущена'))
return
if state not in {'running', 'starting', 'missing'}:
raise RuntimeError('Не получен статус установки от роутера')
message = (stop_reason + '; ожидаю подтверждение остановки' if stop_reason else
'Установка выполняется: ' + str(elapsed) + ' с; без нового вывода '
+ str(int(now - last_progress)) + ' с; лимит ' + str(self.ROUTER_TIMEOUT) + ' с')
self._set(index, message=message)
except Exception as exc:
last_error = self._ssh_error(exc, password)
self._set(index, message='Нет ответа по SSH: ' + last_error + '; ожидание не более '
+ str(self.CONNECTION_TIMEOUT) + ' с')
self.wake.wait(min(self.POLL_SECONDS, 1) if stop_reason else self.POLL_SECONDS)
self.wake.clear()
self._set(index, state='unknown',
message='Результат не подтверждён: '
+ (last_error or 'истекло время ожидания'))
def stop(self):
self.stopping.set()
self.wake.set()
self._interrupt_transport()
thread = self.thread
if thread and thread.ident is not None and thread is not threading.current_thread():
thread.join(timeout=25)
HUB_UPDATE_LIMIT = 4 * 1024 * 1024
HUB_UPDATE_ACTIVE = {'starting', 'installing', 'restarting', 'rollback'}
def hub_update_write(path, data, mode=0o600):
"""One durable atomic replacement; never truncate a running Hub or its state."""
path = Path(path)
path.parent.mkdir(mode=0o700, parents=True, exist_ok=True)
fd, name = tempfile.mkstemp(prefix='.' + path.name + '-', dir=path.parent)
try:
with os.fdopen(fd, 'wb') as stream:
stream.write(data)
stream.flush()
os.fsync(stream.fileno())
os.chmod(name, mode)
os.replace(name, path)
finally:
Path(name).unlink(missing_ok=True)
def hub_update_state(directory, value=None):
path = Path(directory) / 'job.json'
if value is not None:
hub_update_write(path, json.dumps(value, ensure_ascii=False).encode('utf-8'))
return value
try:
with path.open('rb') as stream:
raw = stream.read(16385)
data = json.loads(raw) if len(raw) <= 16384 else {}
return data if isinstance(data, dict) else {}
except (OSError, ValueError):
return {}
@contextmanager
def hub_update_lock(directory, blocking=False):
# The worker survives Hub restarts; the kernel releases this lock on a crash.
import fcntl
Path(directory).mkdir(mode=0o700, parents=True, exist_ok=True)
with (Path(directory) / 'worker.lock').open('a') as stream:
try:
fcntl.flock(stream, fcntl.LOCK_EX | (0 if blocking else fcntl.LOCK_NB))
except BlockingIOError:
raise RuntimeError('Обновление панели уже выполняется.')
try:
yield
finally:
fcntl.flock(stream, fcntl.LOCK_UN)
def hub_update_validate(data):
if not 50000 <= len(data) <= HUB_UPDATE_LIMIT:
raise ValueError('Некорректный размер файла обновления панели.')
source = data.decode('utf-8')
if not all(marker in source for marker in ('class App:', 'class Handler(', 'def dashboard_html(', 'def main():')):
raise ValueError('Источник вернул файл, не похожий на панель Hub.')
if not all(marker in source for marker in ('class HubUpdateManager:', 'panel-update-worker', 'HUB_LOADED_REVISION')):
raise ValueError('Сборка в источнике ещё не поддерживает проверяемое обновление из панели.')
with warnings.catch_warnings():
warnings.simplefilter('ignore', SyntaxWarning)
compile(source, 'owrt-remote-hub.py', 'exec', dont_inherit=True)
return data
def hub_update_version(data):
match = re.search(rb'appBannerVersion[^>]*>(v[0-9]+)', data)
return match[1].decode('ascii') if match else 'последняя сборка'
def hub_update_health(url, revision, attempts=30):
for _ in range(attempts):
try:
with urllib.request.urlopen(url + '?panel-update=1', timeout=2) as response:
data = json.loads(response.read(4096))
if data.get('ok') and data.get('revision') == revision:
return True
except (OSError, ValueError):
pass
time.sleep(2)
return False
def run_hub_update_worker(job_id, directory=None, target=None):
directory = Path(directory or STATE_DIR / 'panel-update')
target = Path(target or Path(__file__).resolve())
with hub_update_lock(directory, blocking=True):
job = hub_update_state(directory)
if job.get('id') != job_id or job.get('status') != 'starting':
raise RuntimeError('Задача обновления устарела или уже запущена.')
changed = False
previous = None
candidate = directory / 'candidate.py'
def report(status, message):
job.update(status=status, message=message, updated_at=time.time())
hub_update_state(directory, job)
try:
time.sleep(2) # Give the initiating HTTP request time to return its job id.
data = hub_update_validate(candidate.read_bytes())
if hashlib.sha256(data).hexdigest() != job.get('revision'):
raise RuntimeError('Контрольная сумма обновления не совпала; файл не заменён.')
previous = target.read_bytes()
if hashlib.sha256(previous).hexdigest() != job.get('previous_revision'):
raise RuntimeError('Файл Hub изменился после подтверждения; обнови страницу.')
hub_update_write(directory / 'previous.py', previous, 0o700)
report('installing', 'Устанавливается новая сборка панели…')
hub_update_write(target, data, 0o755)
changed = True
report('restarting', 'Панель перезапускается; ожидается проверка новой сборки…')
subprocess.run(['systemctl', 'restart', 'owrt-remote'], check=True, capture_output=True, timeout=35)
if not hub_update_health(job['health_url'], job['revision']):
raise RuntimeError('Новая сборка не прошла проверку работоспособности.')
report('succeeded', 'Панель успешно обновлена. Страница будет перезагружена.')
return 0
except Exception as exc:
reason = str(exc)[:500]
if changed and previous is not None:
try:
report('rollback', 'Ошибка обновления; восстанавливается предыдущая сборка…')
except OSError:
pass # A full state disk must not prevent recovery of the Hub file.
try:
hub_update_write(target, previous, 0o755)
subprocess.run(['systemctl', 'restart', 'owrt-remote'], check=True, capture_output=True, timeout=35)
restored = hub_update_health(job['health_url'], job['previous_revision'], attempts=15)
reason += ' Предыдущий файл восстановлен.' + ('' if restored else ' Работоспособность сервиса не подтверждена; проверь журнал owrt-remote на VPS.')
except Exception as rollback_exc:
reason += ' Не удалось завершить откат: ' + str(rollback_exc)[:300]
report('failed', 'Обновление не выполнено: ' + reason)
return 1
finally:
candidate.unlink(missing_ok=True)
class HubUpdateManager:
check_interval = 300
def __init__(self, target=None, directory=None, source=None):
self.target = Path(target or Path(__file__).resolve())
self.directory = Path(directory or STATE_DIR / 'panel-update')
self.source = (source or RAW_REPO_BASE).rstrip('/')
self.csrf = secrets.token_urlsafe(32)
self.lock = threading.Lock()
self.checked_at = 0
self.checking = False
self.error = ''
self.candidate = None
self.remote_revision = ''
self.remote_version = ''
self.health_url = 'http://127.0.0.1:8088/health'
def check(self, force=False):
with self.lock:
job = hub_update_state(self.directory)
if self.checking or job.get('status') in HUB_UPDATE_ACTIVE:
return
if self.checked_at and time.monotonic() - self.checked_at < (15 if force else self.check_interval):
return
self.checking = True
try:
threading.Thread(target=self._check, name='owrt-panel-update-check', daemon=True).start()
except Exception:
with self.lock:
self.checking = False
raise
def fetch_candidate(self):
if urllib.parse.urlsplit(self.source).scheme != 'https':
raise ValueError('Источник обновления должен использовать HTTPS.')
request = urllib.request.Request(self.source + '/vps/owrt-remote-hub.py', headers={
'User-Agent': 'OpenWrt-Remote-Hub-Updater', 'Cache-Control': 'no-cache'})
with urllib.request.urlopen(request, timeout=15) as response:
if urllib.parse.urlsplit(response.geturl()).scheme != 'https':
raise ValueError('Источник обновления должен использовать HTTPS.')
return response.read(HUB_UPDATE_LIMIT + 1)
def _check(self):
data, error = None, ''
try:
data = self.fetch_candidate()
hub_update_validate(data)
except Exception as exc:
error = 'Не удалось проверить обновление: ' + str(exc)[:300]
with self.lock:
self.checked_at = time.monotonic()
self.error = error
self.candidate = data if not error else None
self.remote_revision = hashlib.sha256(data).hexdigest() if not error else ''
self.remote_version = hub_update_version(data) if not error else ''
self.checking = False
def snapshot(self):
with self.lock:
job = hub_update_state(self.directory)
if job.get('status') in HUB_UPDATE_ACTIVE and time.time() - job.get('started_at', 0) > 420:
job.update(status='failed', message='Процесс обновления прерван. Итог не подтверждён; проверь сервис owrt-remote на VPS.')
hub_update_state(self.directory, job)
revision = HUB_LOADED_REVISION
return {'checking': self.checking, 'error': self.error, 'source': self.source,
'current_revision': revision, 'remote_revision': self.remote_revision,
'remote_version': self.remote_version, 'checked': bool(self.checked_at),
'available': bool(self.remote_revision and self.remote_revision != revision),
'job': job, 'csrf': self.csrf}
def start(self, revision):
with self.lock:
with hub_update_lock(self.directory):
job = hub_update_state(self.directory)
if job.get('status') in HUB_UPDATE_ACTIVE:
raise RuntimeError('Обновление панели уже выполняется.')
if not revision or revision != self.remote_revision or not self.candidate or self.error or self.checking:
raise ValueError('Результат проверки устарел. Проверь обновление ещё раз.')
if revision == HUB_LOADED_REVISION:
raise ValueError('Эта сборка панели уже установлена.')
hub_update_validate(self.candidate)
if shutil.disk_usage(self.target.parent).free < HUB_UPDATE_LIMIT * 3:
raise RuntimeError('Недостаточно свободного места для обновления и резервной копии.')
if shutil.disk_usage(self.directory).free < HUB_UPDATE_LIMIT * 3:
raise RuntimeError('Недостаточно свободного места для резервной копии панели.')
job = {'id': secrets.token_hex(16), 'status': 'starting', 'started_at': time.time(),
'message': 'Запускается обновление панели…', 'revision': revision,
'version': self.remote_version, 'previous_revision': HUB_LOADED_REVISION,
'health_url': self.health_url}
hub_update_write(self.directory / 'candidate.py', self.candidate)
hub_update_state(self.directory, job)
try:
subprocess.run(['systemd-run', '--unit=owrt-remote-panel-update-' + job['id'], '--collect',
'--property=RuntimeMaxSec=360', '--setenv=OWRT_REMOTE_STATE_DIR=' + str(STATE_DIR),
sys.executable, str(self.target), 'panel-update-worker', '--job-id', job['id']],
check=True, capture_output=True, timeout=15)
except Exception as exc:
job.update(status='failed', message='Не удалось запустить обновление через systemd: ' + str(exc)[:300])
hub_update_state(self.directory, job)
(self.directory / 'candidate.py').unlink(missing_ok=True)
raise RuntimeError(job['message'])
return job
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
self.vps_resources = VpsResourceMonitor()
self.router_updates = RouterUpdateManager(self)
self.hub_update = HubUpdateManager()
@contextmanager
def conn(self):
with connect(self.db_path) as conn:
init_db(conn)
yield 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")):
with self.conn() as conn:
record_router_connection_log(conn, router_id, False)
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")))
try:
self.prime_router_state_snapshot()
except Exception as exc:
print(f"WARNING: router state monitor initialization error: {exc}", file=sys.stderr)
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)
expire_ssh_http_sessions()
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()
thread = self.router_monitor_thread
if thread and thread.ident is not None and thread is not threading.current_thread():
thread.join(timeout=10)
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:
raw_line = self.rfile.readline()
if not raw_line:
raise ValueError("incomplete chunked request body")
line = raw_line.strip()
size = int(line.split(b";", 1)[0], 16)
if size < 0:
raise ValueError("negative chunk size")
if size == 0:
while True:
trailer = self.rfile.readline()
if not trailer:
raise ValueError("incomplete chunked request trailers")
if trailer == b"\r\n":
break
break
chunk = self.rfile.read(size)
if len(chunk) != size or self.rfile.read(2) != b"\r\n":
raise ValueError("incomplete chunked request data")
chunks.append(chunk)
return b"".join(chunks)
length = int(self.headers.get("Content-Length", "0") or "0")
if length < 0:
raise ValueError("negative content length")
body = self.rfile.read(length) if length else b""
if len(body) != length:
raise ValueError("incomplete request body")
return body
def read_payload(self, *, keep_blank_values=False):
body = self.read_body()
ctype = self.headers.get("Content-Type", "")
if "application/json" in ctype:
return json.loads(body.decode("utf-8") or "{}")
if "multipart/form-data" in ctype.lower():
message = BytesParser(policy=email_policy_default).parsebytes(
b"Content-Type: " + ctype.encode("utf-8", errors="replace") + b"\r\nMIME-Version: 1.0\r\n\r\n" + body
)
payload = {"__files__": {}}
if not message.is_multipart():
return payload
for part in message.iter_parts():
if part.get_content_disposition() != "form-data":
continue
name = str(part.get_param("name", header="content-disposition") or "").strip()
if not name:
continue
filename = part.get_filename()
raw = part.get_payload(decode=True) or b""
if filename is not None:
payload["__files__"].setdefault(name, []).append(
{
"filename": filename,
"content_type": part.get_content_type() or "",
"body": raw,
}
)
continue
payload[name] = raw.decode(part.get_content_charset() or "utf-8", errors="replace")
return payload
parsed = urllib.parse.parse_qs(body.decode("utf-8"), keep_blank_values=keep_blank_values)
return {k: v[-1] for k, v in parsed.items()}
def session_cookie(self, token):
secure = "; Secure" if self.request_scheme() == "https" else ""
return f"{SESSION_COOKIE}={token}; HttpOnly; SameSite=Lax; Path=/; Max-Age={SESSION_TTL_SECONDS}{secure}"
def clear_session_cookie(self):
secure = "; Secure" if self.request_scheme() == "https" else ""
return f"{SESSION_COOKIE}=; HttpOnly; SameSite=Lax; Path=/; Max-Age=0{secure}"
def request_scheme(self):
forwarded = str(self.headers.get("X-Forwarded-Proto", "")).split(",", 1)[0].strip().lower()
if forwarded in {"http", "https"}:
return forwarded
return "https" if isinstance(self.request, ssl.SSLSocket) else "http"
def request_host(self):
scheme = self.request_scheme()
host = str(self.headers.get("X-Forwarded-Host") or self.headers.get("Host") or "").split(",", 1)[0].strip()
forwarded_port = self.headers.get("X-Forwarded-Port", "")
return append_forwarded_port(scheme, host, forwarded_port)
def request_origin(self):
return origin_from_parts(self.request_scheme(), self.request_host())
def request_host_name(self):
try:
return urllib.parse.urlsplit(self.request_origin()).hostname or ""
except Exception:
return ""
def webauthn_rp_id(self):
return public_url_rp_id(self.app.public_url) or self.request_host_name()
def webauthn_allowed_origins(self):
values = []
for item in (public_url_origin(self.app.public_url), self.request_origin()):
if item and item not in values:
values.append(item)
return values
def build_webauthn_server(self):
if not passkey_supported():
raise ValueError("На сервере не установлен модуль Passkey/WebAuthn")
rp_id = self.webauthn_rp_id()
origins = set(self.webauthn_allowed_origins())
if not rp_id or not origins:
raise ValueError("Не удалось определить origin/RP ID для Passkey")
def verify_origin(origin):
try:
parts = urllib.parse.urlsplit(str(origin or ""))
return origin_from_parts(parts.scheme, parts.netloc) in origins
except Exception:
return False
return Fido2Server({"id": rp_id, "name": APP_NAME}, verify_origin=verify_origin)
def require_current_password(self, payload, auth=None):
auth = normalize_auth_state(auth or load_auth())
current_password = str((payload or {}).get("current_password") or "")
if not verify_login(auth.get("username", ""), current_password):
raise ValueError("Текущий пароль неверный")
return auth
def verify_login_captcha(self, payload, auth=None):
auth = normalize_auth_state(auth or load_auth())
state = effective_captcha_state(auth)
if state.get("effective_mode") in CAPTCHA_RECAPTCHA_MODES:
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(),
expected_action=RECAPTCHA_V3_ACTION if state["effective_mode"] == CAPTCHA_MODE_RECAPTCHA_V3 else "",
min_score=state["min_score"],
)
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(keep_blank_values=True)
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", "")
previous_captcha = sanitize_captcha_state(auth.get("captcha"))
captcha_mode = sanitize_captcha_mode(payload.get("captcha_mode", previous_captcha["mode"]))
same_captcha_mode = captcha_mode == previous_captcha["mode"]
captcha_site_key = str(payload.get("captcha_site_key", previous_captcha["site_key"] if same_captcha_mode else "") or "").strip()
captcha_secret_key = str(payload.get("captcha_secret_key", previous_captcha["secret_key"] if same_captcha_mode else "") or "").strip()
captcha_min_score = previous_captcha["min_score"] if same_captcha_mode else RECAPTCHA_V3_MIN_SCORE
if captcha_mode == CAPTCHA_MODE_DIGITS:
captcha_site_key = ""
captcha_secret_key = ""
captcha_min_score = RECAPTCHA_V3_MIN_SCORE
if captcha_mode == CAPTCHA_MODE_RECAPTCHA_V3:
try:
captcha_min_score = parse_recaptcha_score(payload.get("captcha_min_score", captcha_min_score))
except ValueError as exc:
self.send_text(400, str(exc))
return
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 in CAPTCHA_RECAPTCHA_MODES and not (captcha_site_key and captcha_secret_key):
version = "v3" if captcha_mode == CAPTCHA_MODE_RECAPTCHA_V3 else "v2 Checkbox"
self.send_text(400, f"Для Google reCAPTCHA {version} нужны 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,
"min_score": captcha_min_score,
}
)
auth["updated_at"] = now_ts()
save_auth_state(auth)
if new_password:
revoke_hub_session(token=self.current_session_token())
if self.legacy_admin_ok():
token = secrets.token_urlsafe(32)
atomic_write_text(SESSION_TOKEN_FILE, token + "\n", mode=0o600)
self.app.session_token = token
self.send_bytes(
200,
"Доступ к Hub обновлен".encode("utf-8"),
extra_headers=[("Set-Cookie", self.clear_session_cookie()), ("X-Hub-Reauth", "1")],
)
return
self.send_text(200, "Доступ к Hub обновлен")
def build_auth_meta(self):
auth = normalize_auth_state(load_auth())
current = self.current_account_profile(touch=False) if self.admin_ok() else None
if current and current.get("is_owner"):
meta = admin_auth_meta(auth)
with self.app.conn() as conn:
router_rows = list_router_rows(conn)
session_rows_by_username = {}
for session in list_hub_sessions("", ""):
username = str(session.get("username") or "")
if not username:
continue
session_rows_by_username.setdefault(username, []).append(session)
login_rows_by_username = {}
for event in list_login_events(""):
username = str(event.get("username") or "")
if not username:
continue
login_rows_by_username.setdefault(username, []).append(event)
meta["username"] = current.get("username", auth.get("username", "admin"))
meta["is_owner"] = True
meta["can_add_router"] = True
meta["current_user"] = {
"username": current.get("username", auth.get("username", "admin")),
"is_owner": True,
}
meta["router_options"] = [
{
"id": router.get("id", ""),
"name": router.get("name", ""),
"role": router.get("role", "node"),
}
for router in [row_to_router(row) for row in router_rows]
]
meta["delegated_users"] = [
item
for item in (
serialize_delegated_user(
auth,
user,
router_rows,
session_rows_by_username.get(str((user or {}).get("username") or ""), []),
login_rows_by_username.get(str((user or {}).get("username") or ""), []),
)
for user in auth.get("delegated_users", [])
)
if item
]
elif current:
with self.app.conn() as conn:
router_rows = list_router_rows(conn)
meta = delegated_auth_meta(auth, current, router_rows)
else:
meta = public_auth_meta(auth)
meta["can_add_router"] = False
social = meta.get("social") if isinstance(meta.get("social"), dict) else {}
for provider, item in social.items():
if not isinstance(item, dict):
continue
item["redirect_uri"] = self.social_callback_url(provider)
return meta
def auth_meta(self):
self.send_json(200, {"ok": True, "auth": self.build_auth_meta()})
def save_delegated_user(self):
try:
payload = self.read_payload()
auth = self.require_current_password(payload)
username = clean_username(payload.get("username", ""))
if secrets.compare_digest(username, auth.get("username", "")):
raise ValueError("Главный аккаунт нельзя превратить в ограниченный")
user_id = str(payload.get("id") or "").strip()
password = str(payload.get("password") or "")
password_confirm = str(payload.get("password_confirm") or "")
if password:
if password != password_confirm:
raise ValueError("Пароль и повтор не совпадают")
if len(password) < MIN_PASSWORD_LENGTH:
raise ValueError(f"Пароль должен быть минимум {MIN_PASSWORD_LENGTH} символа")
next_password = password_digest(password)
else:
next_password = None
router_flags = sanitize_router_access_map(payload.get("router_flags"))
enabled = bool(payload.get("enabled", True))
existing = None
for item in auth.get("delegated_users", []):
if user_id and item.get("id") == user_id:
existing = item
break
for item in auth.get("delegated_users", []):
if existing and item.get("id") == existing.get("id"):
continue
if secrets.compare_digest(item.get("username", ""), username):
raise ValueError("Пользователь с таким логином уже существует")
if existing is None and next_password is None:
raise ValueError("Для нового пользователя нужен пароль")
updated_users = []
replaced = False
for item in auth.get("delegated_users", []):
if existing and item.get("id") == existing.get("id"):
updated_users.append(
{
**item,
"username": username,
"password": next_password or item.get("password", {}),
"enabled": enabled,
"router_flags": router_flags,
"updated_at": now_ts(),
}
)
replaced = True
continue
updated_users.append(item)
if not replaced:
updated_users.append(
{
"id": user_id or secrets.token_hex(8),
"username": username,
"password": next_password,
"enabled": enabled,
"router_flags": router_flags,
"created_at": now_ts(),
"updated_at": now_ts(),
}
)
auth = save_auth_state({**auth, "delegated_users": updated_users})
self.send_json(200, {"ok": True, "message": "Пользователь сохранен", "auth": self.build_auth_meta()})
except ValueError as exc:
self.send_json(400, {"ok": False, "error": str(exc)})
except Exception as exc:
self.send_json(500, {"ok": False, "error": str(exc)})
def delete_delegated_user(self):
try:
payload = self.read_payload()
auth = self.require_current_password(payload)
user_id = str(payload.get("id") or "").strip()
if not user_id:
raise ValueError("Не указан пользователь")
removed = 0
removed_username = ""
kept = []
for item in auth.get("delegated_users", []):
if item.get("id") == user_id:
removed += 1
removed_username = str(item.get("username") or "")
continue
kept.append(item)
if not removed:
raise ValueError("Пользователь уже удален")
revoke_hub_sessions_for_username(removed_username)
auth = save_auth_state({**auth, "delegated_users": kept})
self.send_json(200, {"ok": True, "message": "Пользователь удален", "auth": self.build_auth_meta()})
except ValueError as exc:
self.send_json(400, {"ok": False, "error": str(exc)})
except Exception as exc:
self.send_json(500, {"ok": False, "error": str(exc)})
def revoke_delegated_user_sessions(self):
try:
payload = self.read_payload()
auth = self.require_current_password(payload)
user_id = str(payload.get("id") or "").strip()
if not user_id:
raise ValueError("Не указан пользователь")
target = next((item for item in auth.get("delegated_users", []) if item.get("id") == user_id), None)
if not target:
raise ValueError("Пользователь не найден")
target_username = str(target.get("username") or "").strip()
removed = revoke_hub_sessions_for_username(target_username)
self.send_json(
200,
{
"ok": True,
"removed": removed,
"message": "Сессии пользователя завершены" if removed else "У пользователя нет активных сессий",
"auth": self.build_auth_meta(),
},
)
except ValueError as exc:
self.send_json(400, {"ok": False, "error": str(exc)})
except Exception as exc:
self.send_json(500, {"ok": False, "error": str(exc)})
def save_social_provider_config(self, provider):
try:
payload = self.read_payload()
auth = self.require_current_password(payload)
provider = str(provider or "").strip().lower()
if provider not in SOCIAL_PROVIDERS:
raise ValueError("Неизвестный OAuth provider")
client_id = str(payload.get("client_id") or "").strip()
client_secret = str(payload.get("client_secret") or "").strip()
def mutator(current):
current = normalize_auth_state(current)
current["social"][provider]["client_id"] = client_id
current["social"][provider]["client_secret"] = client_secret
return current
save_auth_state(mutator(auth))
self.send_json(
200,
{
"ok": True,
"auth": self.build_auth_meta(admin=True),
"message": f"{social_provider_label(provider)} сохранен",
},
)
except ValueError as exc:
self.send_json(400, {"ok": False, "error": str(exc)})
except Exception as exc:
self.send_json(500, {"ok": False, "error": str(exc)})
def begin_social_link(self, provider):
try:
payload = self.read_payload()
auth = self.require_current_password(payload)
provider = str(provider or "").strip().lower()
redirect_uri = self.social_callback_url(provider)
cfg = self.social_provider_config(provider, auth)
if not social_provider_configured(provider, cfg):
raise ValueError(social_provider_setup_message(provider))
flow_payload = {
"provider": provider,
"mode": "link",
"redirect_uri": redirect_uri,
}
if provider == "vk":
flow_payload["code_verifier"] = make_pkce_verifier()
ticket = put_auth_flow(f"oauth-{provider}", flow_payload)
self.send_json(
200,
{
"ok": True,
"url": self.social_flow_authorize_url(provider, ticket, redirect_uri, flow=flow_payload),
},
)
except ValueError as exc:
self.send_json(400, {"ok": False, "error": str(exc)})
except Exception as exc:
self.send_json(500, {"ok": False, "error": str(exc)})
def unlink_social_account(self, provider):
try:
payload = self.read_payload()
auth = self.require_current_password(payload)
provider = str(provider or "").strip().lower()
account_id = str(payload.get("id") or "").strip()
if not account_id:
raise ValueError("Не указан аккаунт для отвязки")
if not find_social_account_record(auth, provider, account_id):
raise ValueError("Аккаунт уже отвязан")
updated = save_auth_state(remove_social_account(auth, provider, account_id))
self.send_json(
200,
{
"ok": True,
"auth": self.build_auth_meta(admin=True),
"message": f"{social_provider_label(provider)} отвязан",
},
)
except ValueError as exc:
self.send_json(400, {"ok": False, "error": str(exc)})
except Exception as exc:
self.send_json(500, {"ok": False, "error": str(exc)})
def start_social_login(self, provider):
provider = str(provider or "").strip().lower()
try:
redirect_uri = self.social_callback_url(provider)
cfg = self.social_provider_config(provider)
if not social_provider_configured(provider, cfg):
raise ValueError(social_provider_setup_message(provider))
if not cfg.get("accounts"):
raise ValueError(f"Для {social_provider_label(provider)} пока нет привязанных аккаунтов")
flow_payload = {
"provider": provider,
"mode": "login",
"redirect_uri": redirect_uri,
}
if provider == "vk":
flow_payload["code_verifier"] = make_pkce_verifier()
ticket = put_auth_flow(f"oauth-{provider}", flow_payload)
self.redirect(self.social_flow_authorize_url(provider, ticket, redirect_uri, flow=flow_payload))
except ValueError as exc:
self.send_bytes(400, self.social_login_error_page(str(exc)).encode("utf-8"), "text/html; charset=utf-8")
except Exception as exc:
self.send_bytes(500, self.social_login_error_page(str(exc)).encode("utf-8"), "text/html; charset=utf-8")
def finish_social_callback(self, provider):
provider = str(provider or "").strip().lower()
params = self.query()
flow_state = str(params.get("state", [""])[0] or "")
error_code = str(params.get("error", [""])[0] or "")
error_text = str(params.get("error_description", [""])[0] or params.get("error_reason", [""])[0] or error_code or "")
flow = None
try:
flow = pop_auth_flow(flow_state, f"oauth-{provider}")
if not flow:
raise ValueError("OAuth сессия истекла или уже была использована")
if error_code:
raise ValueError(error_text or f"{social_provider_label(provider)} вернул ошибку авторизации")
code = str(params.get("code", [""])[0] or "").strip()
if not code:
raise ValueError("OAuth provider не вернул код авторизации")
device_id = str(params.get("device_id", [""])[0] or "").strip()
account = self.exchange_social_code(
provider,
code,
str(flow.get("redirect_uri") or self.social_callback_url(provider)),
flow=flow,
flow_state=flow_state,
device_id=device_id,
)
if flow.get("mode") == "link":
updated = save_auth_state(upsert_social_account(load_auth(), provider, account))
message = f"{social_provider_label(provider)} аккаунт {account.get('label') or account.get('id')} привязан"
self.send_bytes(
200,
self.oauth_popup_html(social_provider_label(provider), message, provider=provider, ok=True).encode("utf-8"),
"text/html; charset=utf-8",
)
return
auth = load_auth()
linked = find_social_account_record(auth, provider, account.get("id"))
if not linked:
raise ValueError("Этот аккаунт не привязан к Hub. Сначала привяжи его в разделе Доступ к Hub.")
save_auth_state(touch_social_account_last_used(auth, provider, account.get("id")))
token, _ = self.create_login_session(current_username(), auth_method=provider)
self.redirect("/", [("Set-Cookie", self.session_cookie(token))])
except ValueError as exc:
if (flow or {}).get("mode") == "link":
self.send_bytes(
400,
self.oauth_popup_html(social_provider_label(provider), str(exc), provider=provider, ok=False).encode("utf-8"),
"text/html; charset=utf-8",
)
return
self.send_bytes(400, self.social_login_error_page(str(exc)).encode("utf-8"), "text/html; charset=utf-8")
except Exception as exc:
self.send_bytes(500, self.social_login_error_page(str(exc)).encode("utf-8"), "text/html; charset=utf-8")
def totp_setup(self):
try:
payload = self.read_payload()
auth = self.require_current_password(payload)
secret = generate_totp_secret()
ticket = put_auth_flow("totp-setup", {"secret": secret, "username": auth.get("username", "admin")})
self.send_json(
200,
{
"ok": True,
"ticket": ticket,
"secret": secret,
"otpauth_uri": totp_otpauth_uri(auth.get("username", "admin"), secret),
"digits": TOTP_DIGITS,
"period": TOTP_PERIOD_SECONDS,
},
)
except Exception as exc:
self.send_json(400, {"ok": False, "error": str(exc)})
def totp_enable(self):
try:
payload = self.read_payload()
self.require_current_password(payload)
ticket = payload.get("ticket", "")
flow = get_auth_flow(ticket, "totp-setup")
if not flow:
raise ValueError("Сессия настройки 2FA истекла, начни заново")
secret = flow.get("secret", "")
if not verify_totp(secret, payload.get("code", "")):
raise ValueError("Неверный код 2FA")
pop_auth_flow(ticket, "totp-setup")
auth = update_auth_state(
lambda current: {
**current,
"totp": {
**default_totp_state(),
"enabled": True,
"secret": secret,
"digits": TOTP_DIGITS,
"period": TOTP_PERIOD_SECONDS,
"updated_at": now_ts(),
},
}
)
self.send_json(200, {"ok": True, "message": "2FA включена", "auth": admin_auth_meta(auth)})
except Exception as exc:
self.send_json(400, {"ok": False, "error": str(exc)})
def totp_disable(self):
try:
payload = self.read_payload()
auth = self.require_current_password(payload)
if not auth.get("totp", {}).get("enabled"):
raise ValueError("2FA уже выключена")
if not verify_totp(auth.get("totp", {}).get("secret", ""), payload.get("code", "")):
raise ValueError("Неверный код 2FA")
auth = update_auth_state(
lambda current: {
**current,
"totp": {
**default_totp_state(),
"updated_at": now_ts(),
},
}
)
self.send_json(200, {"ok": True, "message": "2FA выключена", "auth": admin_auth_meta(auth)})
except Exception as exc:
self.send_json(400, {"ok": False, "error": str(exc)})
def begin_passkey_registration(self):
try:
payload = self.read_payload()
auth = self.require_current_password(payload)
server = self.build_webauthn_server()
label = str(payload.get("label") or f"Passkey {len(auth.get('passkeys', [])) + 1}").strip()[:80] or "Passkey"
options, state = server.register_begin(
{
"id": auth.get("username", "admin").encode("utf-8"),
"name": auth.get("username", "admin"),
"displayName": auth.get("username", "admin"),
},
passkey_credentials(auth),
resident_key_requirement=ResidentKeyRequirement.PREFERRED if ResidentKeyRequirement else None,
user_verification=UserVerificationRequirement.PREFERRED if UserVerificationRequirement else None,
)
ticket = put_auth_flow(
"passkey-register",
{"state": state, "label": label, "username": auth.get("username", "admin")},
)
self.send_json(200, {"ok": True, "ticket": ticket, "options": webauthn_json(dict(options))})
except Exception as exc:
self.send_json(400, {"ok": False, "error": str(exc)})
def finish_passkey_registration(self):
try:
payload = self.read_payload()
ticket = payload.get("ticket", "")
response = payload.get("credential") if isinstance(payload.get("credential"), dict) else payload
flow = pop_auth_flow(ticket, "passkey-register")
if not flow:
raise ValueError("Passkey-регистрация истекла, начни заново")
server = self.build_webauthn_server()
auth_data = server.register_complete(flow.get("state"), response)
credential_data = auth_data.credential_data
if not credential_data:
raise ValueError("Не удалось прочитать credential data")
key_id = b64url(credential_data.credential_id)
label = str(flow.get("label") or "Passkey").strip()[:80] or "Passkey"
def mutator(current):
current = normalize_auth_state(current)
rows = [item for item in current.get("passkeys", []) if item.get("id") != key_id]
rows.append(
{
"id": key_id,
"label": label,
"credential_data": b64url(bytes(credential_data)),
"created_at": now_ts(),
"last_used_at": 0,
"sign_count": int(auth_data.counter or 0),
"transports": [str(value).strip() for value in payload.get("transports", []) if str(value).strip()],
}
)
current["passkeys"] = rows
return current
auth = update_auth_state(mutator)
self.send_json(200, {"ok": True, "message": "Passkey добавлен", "auth": admin_auth_meta(auth)})
except Exception as exc:
self.send_json(400, {"ok": False, "error": str(exc)})
def remove_passkey(self):
try:
payload = self.read_payload()
self.require_current_password(payload)
credential_id = str(payload.get("id") or "").strip()
if not credential_id:
raise ValueError("id passkey пустой")
def mutator(current):
current = normalize_auth_state(current)
current["passkeys"] = [item for item in current.get("passkeys", []) if item.get("id") != credential_id]
return current
auth = update_auth_state(mutator)
self.send_json(200, {"ok": True, "message": "Passkey удален", "auth": admin_auth_meta(auth)})
except Exception as exc:
self.send_json(400, {"ok": False, "error": str(exc)})
def begin_passkey_login(self):
try:
auth = load_auth()
passkey_info = passkey_inventory(auth)
credentials = passkey_info.get("credentials", [])
if not credentials:
if passkey_info.get("invalid_count"):
raise ValueError("Сохраненный passkey поврежден или записан в старом формате. Удали его в меню доступа и зарегистрируй заново")
raise ValueError("Для входа Passkey пока не зарегистрирован")
server = self.build_webauthn_server()
options, state = server.authenticate_begin(
credentials,
user_verification=UserVerificationRequirement.PREFERRED if UserVerificationRequirement else None,
)
ticket = put_auth_flow("passkey-login", {"state": state, "username": auth.get("username", "admin")})
self.send_json(200, {"ok": True, "ticket": ticket, "options": webauthn_json(dict(options))})
except Exception as exc:
self.send_json(400, {"ok": False, "error": str(exc)})
def finish_passkey_login(self):
try:
payload = self.read_payload()
ticket = payload.get("ticket", "")
response = payload.get("credential") if isinstance(payload.get("credential"), dict) else payload
flow = pop_auth_flow(ticket, "passkey-login")
if not flow:
raise ValueError("Passkey-челлендж истек, начни вход заново")
auth = load_auth()
passkey_info = passkey_inventory(auth)
credentials = passkey_info.get("credentials", [])
if not credentials:
if passkey_info.get("invalid_count"):
raise ValueError("Сохраненный passkey поврежден или записан в старом формате. Удали его в меню доступа и зарегистрируй заново")
raise ValueError("Passkey не зарегистрирован")
server = self.build_webauthn_server()
credential = server.authenticate_complete(flow.get("state"), credentials, response)
key_id = b64url(credential.credential_id)
counter = 0
if AuthenticationResponse is not None:
try:
auth_response = AuthenticationResponse.from_dict(response)
counter = int(auth_response.response.authenticator_data.counter or 0)
except Exception:
counter = 0
def mutator(current):
current = normalize_auth_state(current)
for item in current.get("passkeys", []):
if item.get("id") == key_id:
item["last_used_at"] = now_ts()
item["sign_count"] = max(int(item.get("sign_count") or 0), counter)
break
return current
update_auth_state(mutator)
self.send_login_json(auth.get("username", "admin"), "passkey")
except Exception as exc:
self.send_json(400, {"ok": False, "error": str(exc)})
def add_ssh_key(self):
try:
payload = self.read_payload()
self.require_current_password(payload)
key = sanitize_ssh_key_record(
{
"id": payload.get("id", ""),
"label": payload.get("label", ""),
"public_key": payload.get("public_key", ""),
"created_at": now_ts(),
}
)
if not key:
raise ValueError("SSH ED25519 ключ не распознан")
def mutator(current):
current = normalize_auth_state(current)
rows = [item for item in current.get("ssh_keys", []) if item.get("public_key") != key.get("public_key")]
rows.append(key)
current["ssh_keys"] = rows
return current
auth = update_auth_state(mutator)
self.send_json(200, {"ok": True, "message": "SSH ED25519 ключ добавлен", "auth": admin_auth_meta(auth)})
except Exception as exc:
self.send_json(400, {"ok": False, "error": str(exc)})
def remove_ssh_key(self):
try:
payload = self.read_payload()
self.require_current_password(payload)
key_id = str(payload.get("id") or "").strip()
if not key_id:
raise ValueError("id SSH ключа пустой")
def mutator(current):
current = normalize_auth_state(current)
current["ssh_keys"] = [item for item in current.get("ssh_keys", []) if item.get("id") != key_id]
return current
auth = update_auth_state(mutator)
self.send_json(200, {"ok": True, "message": "SSH ключ удален", "auth": admin_auth_meta(auth)})
except Exception as exc:
self.send_json(400, {"ok": False, "error": str(exc)})
def begin_ssh_login(self):
try:
auth = load_auth()
ssh_keys = auth.get("ssh_keys", [])
if not ssh_keys:
raise ValueError("Для входа ED25519 пока нет зарегистрированных ключей")
issued_at = now_ts()
host = self.request_host()
ticket = put_auth_flow("ssh-login", {"username": auth.get("username", "admin"), "issued_at": issued_at, "host": host})
challenge = build_ssh_auth_message(ticket, auth.get("username", "admin"), host, issued_at)
with AUTH_FLOW_LOCK:
state = AUTH_FLOW_STATE.get(ticket)
if state:
state["challenge"] = challenge
self.send_json(
200,
{
"ok": True,
"ticket": ticket,
"challenge": challenge,
"namespace": ssh_auth_namespace(),
"principal": ssh_auth_principal(auth.get("username", "admin")),
"keys": public_auth_meta(auth).get("ssh_keys", []),
},
)
except Exception as exc:
self.send_json(400, {"ok": False, "error": str(exc)})
def finish_ssh_login(self):
try:
payload = self.read_payload()
ticket = str(payload.get("ticket") or "").strip()
flow = pop_auth_flow(ticket, "ssh-login")
if not flow:
raise ValueError("ED25519-челлендж истек, начни вход заново")
auth = load_auth()
challenge = str(flow.get("challenge") or "")
if not challenge:
challenge = build_ssh_auth_message(
ticket,
auth.get("username", "admin"),
flow.get("host", "") or self.request_host(),
flow.get("issued_at", 0),
)
matched = verify_ssh_auth_signature(auth.get("ssh_keys", []), auth.get("username", "admin"), challenge, payload.get("signature", ""))
def mutator(current):
current = normalize_auth_state(current)
for item in current.get("ssh_keys", []):
if item.get("id") == matched.get("id"):
item["last_used_at"] = now_ts()
break
return current
update_auth_state(mutator)
self.send_login_json(auth.get("username", "admin"), "ed25519")
except Exception as exc:
self.send_json(400, {"ok": False, "error": str(exc)})
def router_id_from_path(self, prefix):
suffix = self.parsed().path[len(prefix):].strip("/")
if not suffix:
return ""
return urllib.parse.unquote(suffix.split("/", 1)[0])
def ssh_page(self):
router_id = self.router_id_from_path("/ssh/")
if not self.require_router_access(router_id, "B"):
return
with self.app.conn() as conn:
row = get_active_router(conn, router_id)
if not row:
self.send_text(404, "router not found")
return
if int(row["ssh_entry_port"] or 0) <= 0:
self.send_text(400, "router has no ssh_entry_port")
return
ws_token = ssh_ws_token(self.app.session_token, router_id)
self.send_bytes(
200,
ssh_terminal_html_v2(row, ws_token).encode("utf-8"),
"text/html; charset=utf-8",
[("Set-Cookie", current_router_cookie(router_id))],
)
def router_logs_page(self, router_id):
if not self.require_router_access(router_id, 'G'):
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
self.send_bytes(200, router_logs_html(row_to_router(row)).encode('utf-8'), 'text/html; charset=utf-8',
[('Cache-Control', 'no-store')])
def router_logs_api(self, router_id, mode='live'):
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
if mode == 'clear':
clear_router_log_archive(conn, router_id)
snapshot, raw = router_log_snapshot(conn, router_id)
else:
snapshot, raw = router_log_snapshot(conn, router_id)
router = row_to_router(row)
if mode == 'download':
name = clean_router_id(router_id)
filename = f'owrt-remote-global-{name}-{dt.datetime.now().strftime("%Y%m%d-%H%M%S")}.log'
self.send_bytes(200, raw, 'text/plain; charset=utf-8',
[('Cache-Control', 'no-store'), ('Content-Disposition', f'attachment; filename="{filename}"')])
else:
payload = {'ok': True, 'router_id': router_id, 'online': router['online'],
'storage': router_log_storage(self.app.db_path), **snapshot}
if mode == 'clear':
payload['message'] = 'Архив VPS очищен. Журнал роутера будет очищен при следующем соединении.'
self.send_json(200, payload)
def receive_router_logs_api(self):
if not self.agent_ok():
self.send_json(401, {'ok': False, 'error': 'bad agent token'})
return
try:
if self.headers.get('Transfer-Encoding') or not 0 < int(self.headers.get('Content-Length', '0')) <= 100000:
self.close_connection = True
self.send_json(413, {'ok': False, 'error': 'log request is too large or has no length'})
return
payload = self.read_payload()
with self.app.conn() as conn:
reply = receive_router_logs(conn, payload.get('id'), payload.get('batch'), payload.get('state'))
self.send_json(200, {'ok': True, **reply})
except Exception as exc:
self.send_json(400, {'ok': False, 'error': str(exc)})
def router_notes_page(self, router_id, error="", draft=None, status=200, edit_note_id=""):
if not self.require_router_access(router_id, "A"):
return
profile = self.current_account_profile(touch=False) or {}
with self.app.conn() as conn:
row = get_active_router(conn, router_id)
if not row:
self.send_text(404, "router not found")
return
router = router_with_access(row_to_router(row), profile)
saved = self.query().get("saved", [""])[0]
if (router.get("permissions") or {}).get("notes_edit") and not edit_note_id:
edit_note_id = self.query().get("edit", [""])[0]
else:
edit_note_id = ""
body = router_notes_html(
router,
username=(profile or {}).get("username") or current_username(),
saved="" if error else saved,
error=error,
draft=draft,
edit_note_id=edit_note_id,
).encode("utf-8")
self.send_bytes(
status,
body,
"text/html; charset=utf-8",
[("Set-Cookie", current_router_cookie(router_id))],
)
def router_note_media_page(self, path):
parts = path.strip("/").split("/")
if len(parts) != 5 or parts[0] != "router" or parts[2] != "notes-media":
self.send_text(404, "not found")
return
router_id = urllib.parse.unquote(parts[1])
note_id = urllib.parse.unquote(parts[3])
file_name = Path(urllib.parse.unquote(parts[4])).name
if not self.require_router_access(router_id, "A"):
return
with self.app.conn() as conn:
row = get_active_router(conn, router_id)
if not row:
self.send_text(404, "router not found")
return
entries = parse_router_notes_entries(row["notes"] or "", fallback_ts=row["updated_at"] or row["created_at"] or 0)
image_meta = {}
for item in entries:
if str(item.get("id") or "") != note_id:
continue
for image in list(item.get("images") or []):
if Path(str(image.get("file_name") or "")).name == file_name:
image_meta = image
break
break
if not image_meta:
self.send_text(404, "image not found")
return
file_path = router_note_image_path(router_id, note_id, file_name)
try:
body = file_path.read_bytes()
except FileNotFoundError:
self.send_text(404, "image file not found")
return
self.send_bytes(
200,
body,
str(image_meta.get("content_type") or "application/octet-stream"),
[("Cache-Control", "private, max-age=3600")],
)
def router_notes_submit(self, router_id):
payload = self.read_payload()
action = str(payload.get("action") or "add").strip().lower()
note_id = payload.get("note_id", "")
notes = payload.get("note", payload.get("notes", ""))
if action == "delete":
if not self.owner_ok():
self.router_notes_page(
router_id,
error="Удаление заметок доступно только владельцу.",
draft=notes,
status=403,
)
return
elif not self.require_router_access(router_id, "G"):
return
uploads = payload_files(payload, "images") if action == "add" else []
try:
with self.app.conn() as conn:
if action == "delete":
delete_router_note_entry(conn, router_id, note_id)
saved = "deleted"
elif action == "update":
update_router_note_entry(conn, router_id, note_id, notes)
saved = "updated"
else:
append_router_note(conn, router_id, notes, image_uploads=uploads)
saved = "added"
except Exception as exc:
self.router_notes_page(
router_id,
error=str(exc),
draft=notes,
status=400,
edit_note_id=note_id if action == "update" else "",
)
return
self.redirect(f"/router/{urllib.parse.quote(router_id)}/notes?saved={urllib.parse.quote(saved)}")
def vps_terminal_page(self):
if not self.require_owner():
return
row = vps_terminal_row()
ws_token = ssh_ws_token(self.app.session_token, row["id"])
public_host = urllib.parse.urlsplit(self.app.public_url).hostname if self.app.public_url else ""
if not public_host:
public_host = self.headers.get("Host", "").split(":", 1)[0]
quick_commands_html = vps_quick_commands_html(public_host or "YOUR_VPS_IP")
self.send_bytes(200, ssh_terminal_html_v2(row, ws_token, quick_commands_html).encode("utf-8"), "text/html; charset=utf-8")
def router_updates_page(self):
if not self.require_owner():
return
self.send_bytes(200, router_updates_html(self.app.router_updates.csrf).encode('utf-8'), 'text/html; charset=utf-8')
def hub_update_api(self, action=''):
if not self.require_owner(json_mode=True):
return
manager = self.app.hub_update
if action:
if not secrets.compare_digest(self.headers.get('X-Hub-Update-CSRF', ''), manager.csrf):
self.send_json(403, {'ok': False, 'error': 'Обнови страницу панели и повтори.'})
return
if self.headers.get('Origin') and self.headers['Origin'] != self.request_origin():
self.send_json(403, {'ok': False, 'error': 'Недопустимый источник запроса.'})
return
length = self.headers.get('Content-Length', '')
if (self.headers.get('Transfer-Encoding') or not length.isdigit() or int(length) > 2048
or 'application/json' not in self.headers.get('Content-Type', '')):
self.send_json(400, {'ok': False, 'error': 'Ожидается небольшой запрос JSON.'})
return
try:
payload = self.read_payload()
if not isinstance(payload, dict):
raise ValueError('Ожидается объект JSON.')
if action == 'start':
manager.start(payload.get('revision'))
else:
manager.check(force=True)
except ValueError as exc:
self.send_json(400, {'ok': False, 'error': str(exc)})
return
except (RuntimeError, OSError) as exc:
self.send_json(409, {'ok': False, 'error': str(exc)})
return
else:
manager.check()
self.send_json(200, {'ok': True, **manager.snapshot()})
def router_updates_api(self, action=''):
if not self.require_owner(json_mode=True):
return
manager = self.app.router_updates
if action:
if not secrets.compare_digest(self.headers.get('X-Router-Update-CSRF', ''), manager.csrf):
self.send_json(403, {'ok': False, 'error': 'Обнови страницу терминала обновления и повтори.'})
return
origin = self.headers.get('Origin', '')
if origin and origin != self.request_origin():
self.send_json(403, {'ok': False, 'error': 'Недопустимый источник запроса.'})
return
if 'application/json' not in self.headers.get('Content-Type', ''):
self.send_json(415, {'ok': False, 'error': 'Ожидается JSON.'})
return
length = self.headers.get('Content-Length', '')
if self.headers.get('Transfer-Encoding') or not length.isdigit() or int(length) > 65536:
self.send_json(413, {'ok': False, 'error': 'Слишком большой запрос.'})
return
try:
payload = self.read_payload()
if not isinstance(payload, dict):
raise ValueError('Ожидается объект JSON.')
if action == 'start':
manager.start(payload.get('command'), payload.get('ssh_password', ''), payload.get('request_id'))
elif action == 'reboot':
manager.start_reboot(payload.get('ssh_password', ''), payload.get('request_id'))
elif action == 'cancel':
manager.cancel(payload.get('id'))
elif action == 'refresh':
manager.clear_finished(payload.get('id', ''))
except ValueError as exc:
self.send_json(400, {'ok': False, 'error': str(exc)})
return
except RuntimeError as exc:
self.send_json(409, {'ok': False, 'error': str(exc)})
return
job = manager.snapshot()
with self.app.conn() as conn:
routers = [router_update_status(dict(row)) for row in list_router_rows(conn)]
self.send_json(200, {'ok': True, 'job': job, 'routers': routers})
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"
try:
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
except BaseException:
shutil.rmtree(askpass_dir)
raise
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)
try:
argv = args + ["sh", "-s", "--"] + [str(item) for item in (script_args or [])]
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=None):
# Pass ownership directly: the map may be cleared before the thread runs.
if session is None:
with SSH_HTTP_LOCK:
session = SSH_HTTP_SESSIONS.get(sid)
if not session:
return
fd = session["fd"]
try:
while True:
with session["lock"]:
if not session["alive"] or now_ts() - session["last_seen"] > 15 * 60:
break
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"))
finally:
with session["lock"]:
session["alive"] = False
session["closed_at"] = now_ts()
session["buffer"].append("\r\n[" + session.get("close_notice", "SSH соединение закрыто") + "]\r\n")
close_terminal_process(session["pid"], fd)
def launch_ssh_http_reader(self, session):
sid = session["id"]
try:
thread = threading.Thread(target=self.ssh_http_reader, args=(sid, session), daemon=True)
session["thread"] = thread
with SSH_HTTP_LOCK:
SSH_HTTP_SESSIONS[sid] = session
thread.start()
except BaseException:
with SSH_HTTP_LOCK:
SSH_HTTP_SESSIONS.pop(sid, None)
close_terminal_process(session["pid"], session["fd"])
raise
def start_ssh_http_session(self, router_id, port):
env, args = self.ssh_args(port)
sid = secrets.token_urlsafe(24)
session = {
"id": sid,
"router_id": router_id,
"port": port,
"buffer": deque(maxlen=256),
"alive": True,
"created": now_ts(),
"last_seen": now_ts(),
"lock": threading.Lock(),
"label": "SSH",
"close_notice": "SSH соединение закрыто",
}
session["pid"], session["fd"] = self.spawn_terminal_pty(env, args, "pty недоступен на VPS", "не удалось открыть SSH pty", "ssh")
self.launch_ssh_http_reader(session)
return session
def start_vps_http_session(self):
env, args = self.vps_shell_args()
sid = secrets.token_urlsafe(24)
session = {
"id": sid,
"router_id": VPS_TERMINAL_ID,
"port": 0,
"buffer": deque(maxlen=256),
"alive": True,
"created": now_ts(),
"last_seen": now_ts(),
"lock": threading.Lock(),
"label": "VPS terminal",
"close_notice": "VPS terminal закрыт",
}
session["pid"], session["fd"] = self.spawn_terminal_pty(env, args, "pty недоступен на VPS", "не удалось открыть VPS pty", "vps-shell")
self.launch_ssh_http_reader(session)
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)
fd = None
try:
with session["lock"]:
if session["alive"]:
session["last_seen"] = now_ts()
# Own a temporary descriptor while writing, so reader cleanup
# cannot close/reuse it and terminal output remains unblocked.
fd = os.dup(session["fd"])
if fd is None:
self.send_json(409, {"ok": False, "error": "terminal session closed"})
return
write_pty_all(fd, data)
self.send_json(200, {"ok": True})
except Exception as exc:
self.send_json(500, {"ok": False, "error": str(exc)})
finally:
if fd is not None:
os.close(fd)
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()
with session["lock"]:
if not session["alive"]:
self.send_json(409, {"ok": False, "error": "terminal session closed"})
return
session["last_seen"] = now_ts()
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
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
try:
ws_send_frame(self.connection, "")
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:
close_terminal_process(pid, fd)
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":
result = {"ok": True}
if self.query().get('panel-update') == ['1']:
result['revision'] = HUB_LOADED_REVISION
self.send_json(200, result)
return
if path == '/api/hub-update':
self.hub_update_api()
return
if path == "/api/vps/resources":
if not self.admin_ok():
self.send_json(401, {"ok": False, "error": "not authorized"})
return
self.send_json(200, {"ok": True, **self.app.vps_resources.snapshot()})
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 in {'/router-updates', '/router-updates/'}:
self.router_updates_page()
return
if path == '/api/router-updates':
self.router_updates_api()
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 [],
{
"username": (profile or {}).get("username") or current_username(),
"is_owner": bool(profile and profile.get("is_owner")),
"can_add_router": bool(profile and account_can_add_router(profile)),
},
vps_resources=self.app.vps_resources.snapshot(),
).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/router-groups":
with self.app.conn() as conn:
groups = list_router_groups(conn)
self.send_json(200, {"groups": groups})
return
if path == "/api/backup/download":
if not self.require_owner():
return
self.backup_download()
return
if path == "/api/sessions":
self.send_json(200, {"sessions": list_hub_sessions(self.current_session_token(), self.current_or_owner_session_scope())})
return
if path == "/api/notifications":
if not self.require_owner(json_mode=True):
return
query = self.query()
self.send_json(
200,
{
"notifications": list_notifications(
query.get("after", ["0"])[0],
query.get("limit", ["60"])[0],
query.get("after_serial", ["0"])[0],
),
"serial": latest_notification_serial(),
},
)
return
if path == "/api/notifications/wait":
if not self.require_owner(json_mode=True):
return
query = self.query()
self.send_json(
200,
{
"notifications": wait_for_notifications(
query.get("after_serial", ["0"])[0],
query.get("timeout", ["25"])[0],
query.get("limit", ["60"])[0],
),
"serial": latest_notification_serial(),
},
)
return
if path == "/api/push/vapid-public-key":
if not self.require_owner(json_mode=True):
return
backend = web_push_backend_status()
if not backend.get("ready"):
self.send_json(
503,
{
"ok": False,
"error": backend.get("error") or "На VPS не готов Web Push backend.",
"reason": backend.get("reason", ""),
"subject": backend.get("subject", ""),
"publicKey": backend.get("public_key", ""),
},
)
return
self.send_json(200, {"ok": True, "publicKey": backend.get("public_key", ""), "subject": backend.get("subject", "")})
return
if path == "/api/push/status":
if not self.require_owner(json_mode=True):
return
self.send_json(200, push_status_snapshot())
return
log_match = re.fullmatch(r'/api/router/([^/]+)/logs(?:/(download))?', path)
if log_match:
self.router_logs_api(urllib.parse.unquote(log_match[1]), log_match[2] or 'live')
return
if path.startswith("/api/router/") and path.endswith("/wol/devices"):
parts = path.strip("/").split("/")
if len(parts) != 5 or parts[0] != "api" or parts[1] != "router" or parts[3] != "wol" or parts[4] != "devices":
self.send_text(404, "not found")
return
router_id = urllib.parse.unquote(parts[2])
if not self.require_router_access(router_id, "G", json_mode=True):
return
with self.app.conn() as conn:
row = get_active_router(conn, router_id)
if not row:
self.send_json(404, {"ok": False, "error": "router not found"})
return
try:
devices = self.discover_router_wol_devices(row)
self.send_json(200, {"ok": True, "router_id": router_id, "devices": devices})
except Exception as exc:
self.send_json(400, {"ok": False, "error": str(exc), "router_id": router_id, "devices": []})
return
if path.startswith("/router/"):
if path.endswith('/logs'):
self.router_logs_page(self.router_id_from_path('/router/'))
return
if "/notes-media/" in path:
self.router_note_media_page(path)
return
if path.endswith("/notes"):
self.router_notes_page(self.router_id_from_path("/router/"))
return
self.router_asset(path)
return
self.send_text(404, "not found")
def do_HEAD(self):
self.do_GET()
def do_POST(self):
path = self.parsed().path
if path in {'/api/hub-update/check', '/api/hub-update/start'}:
self.hub_update_api(path.rsplit('/', 1)[-1])
return
if path in {'/api/router-updates/start', '/api/router-updates/reboot', '/api/router-updates/cancel', '/api/router-updates/refresh'}:
self.router_updates_api(path.rsplit('/', 1)[-1])
return
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/router-logs':
self.receive_router_logs_api()
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.get('_became_online'):
record_router_connection_log(conn, router['id'], True)
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
log_match = re.fullmatch(r'/api/router/([^/]+)/logs/clear', path)
if log_match:
self.router_logs_api(urllib.parse.unquote(log_match[1]), 'clear')
return
if path == "/api/auth":
if not self.require_owner():
return
self.update_auth()
return
if path == "/api/auth/users/save":
if not self.require_owner(json_mode=True):
return
self.save_delegated_user()
return
if path == "/api/auth/users/delete":
if not self.require_owner(json_mode=True):
return
self.delete_delegated_user()
return
if path == "/api/auth/users/revoke-sessions":
if not self.require_owner(json_mode=True):
return
self.revoke_delegated_user_sessions()
return
if path == "/api/auth/totp/setup":
if not self.require_owner(json_mode=True):
return
self.totp_setup()
return
if path == "/api/auth/totp/enable":
if not self.require_owner(json_mode=True):
return
self.totp_enable()
return
if path == "/api/auth/totp/disable":
if not self.require_owner(json_mode=True):
return
self.totp_disable()
return
if path == "/api/auth/passkeys/begin":
if not self.require_owner(json_mode=True):
return
self.begin_passkey_registration()
return
if path == "/api/auth/passkeys/finish":
if not self.require_owner(json_mode=True):
return
self.finish_passkey_registration()
return
if path == "/api/auth/passkeys/remove":
if not self.require_owner(json_mode=True):
return
self.remove_passkey()
return
if path == "/api/auth/ssh-keys/add":
if not self.require_owner(json_mode=True):
return
self.add_ssh_key()
return
if path == "/api/auth/ssh-keys/remove":
if not self.require_owner(json_mode=True):
return
self.remove_ssh_key()
return
if path == "/api/auth/social/github/save":
if not self.require_owner(json_mode=True):
return
self.save_social_provider_config("github")
return
if path == "/api/auth/social/vk/save":
if not self.require_owner(json_mode=True):
return
self.save_social_provider_config("vk")
return
if path == "/api/auth/social/github/link":
if not self.require_owner(json_mode=True):
return
self.begin_social_link("github")
return
if path == "/api/auth/social/vk/link":
if not self.require_owner(json_mode=True):
return
self.begin_social_link("vk")
return
if path == "/api/auth/social/github/unlink":
if not self.require_owner(json_mode=True):
return
self.unlink_social_account("github")
return
if path == "/api/auth/social/vk/unlink":
if not self.require_owner(json_mode=True):
return
self.unlink_social_account("vk")
return
if path == "/api/session/client-hint":
payload = self.read_payload()
session = update_hub_session_client_hint(self.current_session_token(), payload.get("client_hint", ""))
if not session:
self.send_json(400, {"ok": False, "error": "session not found"})
return
self.send_json(200, {"ok": True, "client": session.get("client", ""), "hint": normalize_client_hint(payload.get("client_hint", ""))})
return
if path == "/api/session/revoke":
payload = self.read_payload()
session_id = payload.get("id", "")
if not session_id:
self.send_text(400, "session id is empty")
return
current = self.current_hub_session(touch=False)
if current and session_id == current.get("id"):
self.send_text(400, "Текущую сессию заверши кнопкой Выйти")
return
if not self.owner_ok():
session_allowed = next(
(
session
for session in list_hub_sessions(self.current_session_token(), self.current_or_owner_session_scope())
if session.get("id") == session_id
),
None,
)
if not session_allowed:
self.send_json(403, {"ok": False, "error": "not authorized"})
return
removed = revoke_hub_session(session_id=session_id)
self.send_json(200, {"ok": True, "removed": removed})
return
if path == "/api/session/revoke-others":
current = self.current_hub_session(touch=False)
current_id = current.get("id", "") if current else ""
removed = 0
for session in list_hub_sessions(self.current_session_token(), self.current_or_owner_session_scope()):
if session.get("id") != current_id:
removed += revoke_hub_session(session_id=session.get("id", ""))
self.send_json(200, {"ok": True, "removed": removed})
return
if path == "/api/notifications/clear":
if not self.require_owner(json_mode=True):
return
clear_notifications()
self.send_json(200, {"ok": True})
return
if path == "/api/backup/restore":
if not self.require_owner(json_mode=True):
return
self.backup_restore()
return
if path == "/api/routers/rewrite-endpoints":
if not self.require_owner(json_mode=True):
return
self.router_endpoints_rewrite()
return
if path == "/api/push/subscribe":
if not self.require_owner(json_mode=True):
return
payload = {}
session = self.current_hub_session(touch=False) or {}
username = session.get("username", current_username())
user_agent = self.headers.get("User-Agent", "")
client_ip = self.client_ip()
try:
payload = self.read_payload()
subscription = save_push_subscription(
payload,
username,
client_ip,
user_agent,
)
if not bool(payload.get("push_test", True)):
self.send_json(
200,
{
"ok": True,
"delivery": "registered",
"subscription": {
"id": subscription.get("id"),
"client": subscription.get("client"),
},
},
)
return
test_payload = {
"title": APP_NAME,
"body": "Push включён на этом устройстве.",
"tag": "owrt-push-test",
"url": "/",
"kind": "push-test",
"ts": now_ts(),
}
test_payload["web_push"] = 8030
test_payload["notification"] = {
"title": test_payload["title"],
"body": test_payload["body"],
"tag": test_payload["tag"],
"navigate": test_payload["url"],
"silent": False,
}
result = send_web_push(subscription, test_payload)
remember_push_delivery(
test_payload,
[
{
"client": subscription.get("client") or "браузер",
"endpoint_host": push_endpoint_host(subscription.get("endpoint", "")),
"result": result,
}
],
"ok" if result == "ok" else "partial",
)
if result in ("gone", "stale"):
remove_push_subscription(subscription.get("endpoint", ""))
if result != "ok":
self.send_json(503, {"ok": False, "error": push_result_message(result, subscription), "delivery": result, "subscription": {"id": subscription.get("id"), "client": subscription.get("client")}})
return
self.send_json(200, {"ok": True, "delivery": result, "subscription": {"id": subscription.get("id"), "client": subscription.get("client")}})
except Exception as exc:
detail = " ".join(str(exc).split())[:160] or exc.__class__.__name__
client = client_label(user_agent, normalize_client_hint((payload or {}).get("client_hint", "")))
remember_push_delivery(
{
"title": APP_NAME,
"body": "Не удалось сохранить push-подписку.",
"tag": "owrt-push-test",
"url": "/",
"kind": "push-test",
"ts": now_ts(),
},
[
{
"client": client or "браузер",
"endpoint_host": push_endpoint_host((payload or {}).get("endpoint", "")),
"result": f"subscribe_error:{detail}",
}
],
"subscribe_error",
)
self.log_message("push subscribe error: %s", detail)
self.send_json(400, {"ok": False, "error": str(exc)})
return
if path == "/api/push/unsubscribe":
if not self.require_owner(json_mode=True):
return
try:
payload = self.read_payload()
removed = remove_push_subscription(payload.get("endpoint", ""))
self.send_json(200, {"ok": True, "removed": removed})
except Exception as exc:
self.send_json(400, {"ok": False, "error": str(exc)})
return
if path == "/api/xray/reload":
if not self.require_owner(json_mode=True):
return
try:
result = reload_vps_xray(self.app.db_path)
self.send_json(200, {"ok": True, **result})
except Exception as exc:
self.send_text(500, str(exc))
return
if path == "/api/xray/restart":
if not self.require_owner(json_mode=True):
return
try:
result = restart_vps_xray()
self.send_json(200, {"ok": True, **result})
except Exception as exc:
self.send_text(500, str(exc))
return
if path == "/api/router-groups/save":
if not self.require_owner(json_mode=True):
return
try:
payload = self.read_payload()
name = clean_router_group_name(payload.get("name"))
group_id = clean_router_group_id(payload.get("id"))
if not name:
raise ValueError("Название группы не должно быть пустым")
with self.app.conn() as conn:
if group_id:
row = conn.execute("select * from router_groups where id = ?", (group_id,)).fetchone()
if not row:
raise ValueError("Группа не найдена")
duplicate = conn.execute(
"select 1 from router_groups where lower(name) = lower(?) and id != ?",
(name, group_id),
).fetchone()
if duplicate:
raise ValueError("Группа с таким названием уже есть")
conn.execute("update router_groups set name = ?, updated_at = ? where id = ?", (name, now_ts(), group_id))
else:
duplicate = conn.execute("select 1 from router_groups where lower(name) = lower(?)", (name,)).fetchone()
if duplicate:
raise ValueError("Группа с таким названием уже есть")
group_id = make_router_group_id(conn, name)
ts = now_ts()
conn.execute(
"insert into router_groups (id, name, sort_order, created_at, updated_at) values (?, ?, ?, ?, ?)",
(group_id, name, len(list_router_groups(conn)), ts, ts),
)
conn.commit()
groups = list_router_groups(conn)
self.send_json(200, {"ok": True, "groups": groups})
except Exception as exc:
self.send_json(400, {"ok": False, "error": str(exc)})
return
if path == "/api/router-groups/delete":
if not self.require_owner(json_mode=True):
return
try:
payload = self.read_payload()
group_id = clean_router_group_id(payload.get("id"))
if not group_id:
raise ValueError("Не указана группа")
with self.app.conn() as conn:
deleted = conn.execute("delete from router_groups where id = ?", (group_id,)).rowcount
if deleted:
conn.execute("update routers set group_id = '', updated_at = ? where group_id = ?", (now_ts(), group_id))
conn.commit()
groups = list_router_groups(conn)
self.send_json(200, {"ok": True, "deleted": bool(deleted), "groups": groups})
except Exception as exc:
self.send_json(400, {"ok": False, "error": str(exc)})
return
if path.startswith("/api/router/") and path.endswith("/group"):
if not self.require_owner(json_mode=True):
return
try:
router_id = urllib.parse.unquote(path.split("/")[3])
payload = self.read_payload()
group_id = clean_router_group_id(payload.get("group_id"))
with self.app.conn() as conn:
row = get_active_router(conn, router_id)
if not row:
raise ValueError("Роутер не найден")
if not router_group_exists(conn, group_id):
raise ValueError("Группа не найдена")
conn.execute("update routers set group_id = ?, updated_at = ? where id = ?", (group_id, now_ts(), router_id))
conn.commit()
router = row_to_router(get_router(conn, router_id))
self.send_json(200, {"ok": True, "router": router})
except Exception as exc:
self.send_json(400, {"ok": False, "error": str(exc)})
return
if path.startswith("/api/router/") and path.endswith("/vps-host"):
if not self.require_owner(json_mode=True):
return
try:
parts = path.strip("/").split("/")
if len(parts) != 4:
raise ValueError("Некорректный путь")
router_id = urllib.parse.unquote(parts[2])
payload = self.read_payload()
host = validate_router_vps_host(payload.get("vps_host"))
mode = str(payload.get("vps_host_mode") or "manual")
script = make_router_vps_host_script(host, mode)
with self.app.conn() as conn:
row = get_active_router(conn, router_id)
if not row:
raise ValueError("Роутер не найден")
output = self.run_router_ssh_script(row, script, timeout=35, ssh_password=payload.get("ssh_password", ""))
if "VPS_HOST_APPLIED" not in output:
raise ValueError("Роутер не подтвердил применение настройки")
with self.app.conn() as conn:
fresh = get_active_router(conn, router_id)
status = row_to_router(fresh).get("status", {})
status.update({"vps_host": host, "vps_host_mode": mode})
conn.execute("update routers set vps_host = ?, status_json = ?, updated_at = ? where id = ?", (host, json.dumps(status, ensure_ascii=False), now_ts(), router_id))
conn.commit()
router = row_to_router(get_router(conn, router_id))
self.send_json(200, {"ok": True, "router": router})
except Exception as exc:
self.send_json(400, {"ok": False, "error": 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"))
payload["group_id"] = clean_router_group_id(payload.get("group_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
if not router_group_exists(conn, payload["group_id"]):
self.send_text(400, "Группа роутера не найдена")
return
payload["ssh_entry_port"] = ssh_entry_port
row = upsert_router(conn, payload)
router = row_to_router(row)
if current and not current.get("is_owner"):
grant_delegated_router_flag(load_auth(), current.get("username", ""), router_id, "G")
self.send_json(200, {"ok": True, "router": router, "auth": self.build_auth_meta()})
except Exception as exc:
self.send_text(400, str(exc))
return
if path.startswith("/api/router/") and path.endswith("/wol/devices"):
parts = path.strip("/").split("/")
if len(parts) != 5 or parts[0] != "api" or parts[1] != "router" or parts[3] != "wol" or parts[4] != "devices":
self.send_text(404, "not found")
return
router_id = urllib.parse.unquote(parts[2])
if not self.require_router_access(router_id, "G", json_mode=True):
return
try:
payload = self.read_payload()
with self.app.conn() as conn:
row = get_active_router(conn, router_id)
if not row:
self.send_json(404, {"ok": False, "error": "router not found"})
return
devices = self.discover_router_wol_devices(row, payload.get("ssh_password", ""))
self.send_json(200, {"ok": True, "router_id": router_id, "devices": devices})
except Exception as exc:
self.send_json(400, {"ok": False, "error": str(exc), "router_id": router_id, "devices": []})
return
if path.startswith("/api/router/") and path.endswith("/traffic/clients"):
parts = path.strip("/").split("/")
if len(parts) != 5 or parts[0] != "api" or parts[1] != "router" or parts[3] != "traffic" or parts[4] != "clients":
self.send_text(404, "not found")
return
router_id = urllib.parse.unquote(parts[2])
if not self.require_router_access(router_id, "G", json_mode=True):
return
try:
payload = self.read_payload()
with self.app.conn() as conn:
row = get_active_router(conn, router_id)
if not row:
self.send_json(404, {"ok": False, "error": "router not found"})
return
result = self.discover_router_client_traffic(row, payload.get("ssh_password", ""))
self.send_json(200, {"ok": True, "router_id": router_id, **result})
except Exception as exc:
self.send_json(
400,
{
"ok": False,
"error": str(exc),
"router_id": router_id,
"clients": [],
"traffic_source": "none",
"traffic_supported": False,
"flow_hits": 0,
},
)
return
if path.startswith("/api/router/") and path.endswith("/traffic/reset"):
parts = path.strip("/").split("/")
if len(parts) != 5 or parts[0] != "api" or parts[1] != "router" or parts[3] != "traffic" or parts[4] != "reset":
self.send_text(404, "not found")
return
router_id = urllib.parse.unquote(parts[2])
if not self.require_router_access(router_id, "G", json_mode=True):
return
try:
payload = self.read_payload()
with self.app.conn() as conn:
row = get_active_router(conn, router_id)
if not row:
self.send_json(404, {"ok": False, "error": "router not found"})
return
result = self.reset_router_client_traffic(row, payload.get("ssh_password", ""))
self.send_json(200, {"ok": True, "router_id": router_id, **result})
except Exception as exc:
self.send_json(400, {"ok": False, "error": str(exc), "router_id": router_id})
return
if path.startswith("/api/router/") and path.endswith("/wol"):
parts = path.strip("/").split("/")
if len(parts) != 4 or parts[0] != "api" or parts[1] != "router" or parts[3] != "wol":
self.send_text(404, "not found")
return
router_id = urllib.parse.unquote(parts[2])
if not self.require_router_access(router_id, "G", json_mode=True):
return
try:
payload = self.read_payload()
with self.app.conn() as conn:
row = get_active_router(conn, router_id)
if not row:
self.send_json(404, {"ok": False, "error": "router not found"})
return
result = self.send_router_wol_packet(
row,
payload.get("mac"),
payload.get("iface", ""),
payload.get("ssh_password", ""),
)
self.send_json(200, {"ok": True, "router_id": router_id, **result})
except Exception as exc:
self.send_json(400, {"ok": False, "error": str(exc), "router_id": router_id})
return
if path.startswith("/api/router/") and path.endswith("/rename"):
try:
router_id = urllib.parse.unquote(path.split("/")[3])
if not self.require_router_access(router_id, "G", json_mode=True):
return
payload = self.read_payload()
with self.app.conn() as conn:
row = rename_router(conn, router_id, payload.get("name"))
self.send_json(200, {"ok": True, "router": row_to_router(row)})
except Exception as exc:
self.send_text(400, str(exc))
return
if path.startswith("/api/router/") and path.endswith("/notes"):
try:
router_id = urllib.parse.unquote(path.split("/")[3])
if not self.require_router_access(router_id, "G", json_mode=True):
return
payload = self.read_payload()
with self.app.conn() as conn:
row = update_router_notes(conn, router_id, payload.get("notes", ""))
router = router_with_access(row_to_router(row), self.current_account_profile())
self.send_json(200, {"ok": True, "router": router})
except Exception as exc:
self.send_text(400, str(exc))
return
if path.startswith("/router/") and path.endswith("/notes"):
self.router_notes_submit(self.router_id_from_path("/router/"))
return
if path.startswith("/api/router/") and path.endswith("/delete"):
router_id = urllib.parse.unquote(path.split("/")[3])
if not self.require_owner(json_mode=True):
return
deleted = False
xray_result = None
warnings = []
with self.app.conn() as conn:
row = get_router(conn, router_id)
if row and not router_deleted(row):
ts = now_ts()
conn.execute(
"update routers set deleted_at = ?, updated_at = ? where id = ?",
(ts, ts, router_id),
)
conn.execute('delete from router_logs where router_id = ?', (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)
with backend.getresponse() as resp:
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.