"""
def clean_router_id(value):
value = (value or "").strip()
out = []
for ch in value:
if ch.isalnum() or ch in "._-":
out.append(ch)
else:
out.append("-")
result = "".join(out).strip(".-_")
if not result:
raise ValueError("router id is empty")
return result[:64]
def clean_router_name(value):
text = " ".join(str(value or "").replace("\r", " ").replace("\n", " ").split()).strip()
if not text:
raise ValueError("router name is empty")
return text[:80]
ROUTER_NOTE_TEXT_MAX_CHARS = 2000
ROUTER_LOG_MAX_BYTES = 2 * 1024 * 1024
ROUTER_LOG_BATCH_MAX_BYTES = 65536
def router_log_storage(db_path):
"""Describe the archive's real backing mount, including symlinked DB paths."""
path = Path(db_path).resolve()
result = {'path': str(path), 'filesystem': 'unknown', 'persistent': None,
'limit_bytes': ROUTER_LOG_MAX_BYTES}
if sys.platform != 'linux':
return result
def unescape(value):
return re.sub(r'\\([0-7]{3})', lambda m: chr(int(m[1], 8)), value)
try:
mounts = []
with open('/proc/self/mountinfo', encoding='utf-8') as source:
for line in source:
fields, separator, tail = line.partition(' - ')
left, right = fields.split(), tail.split()
if not separator or len(left) < 6 or len(right) < 3:
continue
mount = Path(unescape(left[4]))
if path.is_relative_to(mount):
mounts.append((len(mount.parts), right[0], left[5]))
if mounts:
_, filesystem, flags = max(mounts, key=lambda item: item[0])
persistent = (False if filesystem in {'tmpfs', 'ramfs', 'rootfs'} else
True if filesystem in {'ext2', 'ext3', 'ext4', 'xfs', 'btrfs', 'f2fs',
'jfs', 'zfs', 'ubifs', 'jffs2', 'nfs', 'nfs4', 'ceph'} else None)
result.update(filesystem=filesystem, persistent=persistent,
writable='rw' in flags.split(','))
except OSError:
pass
return result
def redact_router_log_bytes(raw):
"""Defense in depth: do not archive credentials supplied by older agents."""
secret = re.compile(rb'authorization|hub_token|vless_uuid|ssh_vless_uuid|password|passwd|web[._ -]?key|[?&](?:key|token)=|"(?:uuid|privatekey)"|[0-9a-f]{8}-[0-9a-f-]{27,}', re.I)
redacted = []
for line in raw.splitlines(keepends=True):
if secret.search(line):
level = re.match(rb'\[(OK|WARN|ERROR)\]', line)
prefix = level.group(0) if level else b'[WARN]'
line = prefix + ' [строка с ключом или паролем скрыта]\n'.encode('utf-8')
redacted.append(line)
return b''.join(redacted)
def receive_router_logs(conn, router_id, batch, state=None):
router_id = clean_router_id(router_id)
if not get_active_router(conn, router_id):
raise ValueError('router not found; send a heartbeat first')
if not isinstance(batch, dict):
raise ValueError('invalid log batch')
journal_id = str(batch.get('journal_id') or '')
clear_ack = str(batch.get('clear_ack') or '')
if not re.fullmatch(r'[A-Za-z0-9._:-]{1,80}', journal_id) or (clear_ack and not re.fullmatch(r'[A-Za-z0-9._:-]{1,80}', clear_ack)):
raise ValueError('invalid log journal id')
start, end = batch.get('from'), batch.get('to')
if type(start) is not int or type(end) is not int or not 0 <= start <= end <= 2**53:
raise ValueError('invalid log cursor')
data = batch.get('data')
if not isinstance(data, str) or len(data) > 87384:
raise ValueError('log batch is too large')
raw = base64.b64decode(data, validate=True)
if len(raw) > ROUTER_LOG_BATCH_MAX_BYTES or end - start != len(raw):
raise ValueError('invalid log batch size')
ts = now_ts()
# Serialize ingestion and offline clears using SQLite's existing transaction.
conn.execute('update router_logs set last_sync = last_sync where router_id = ?', (router_id,))
row = conn.execute('select * from router_logs where router_id = ?', (router_id,)).fetchone()
if row is None:
conn.execute('insert into router_logs(router_id) values (?)', (router_id,))
row = conn.execute('select * from router_logs where router_id = ?', (router_id,)).fetchone()
if state is not None:
if (not isinstance(state, dict) or type(state.get('enabled')) is not bool
or state.get('xray') not in {'running', 'stopped'}):
raise ValueError('invalid log delivery state')
conn.execute('update router_logs set state_json = ?, state_at = ? where router_id = ?',
(json.dumps({'enabled': state['enabled'], 'xray': state['xray']}), ts, router_id))
pending = row['clear_request']
if pending and clear_ack != pending:
conn.execute('update router_logs set last_sync = ? where router_id = ?', (ts, router_id))
return {'journal_id': journal_id, 'offset': end, 'clear_request': pending}
cursor = int(row['cursor']) if row['journal_id'] == journal_id else 0
# A status-only packet cannot prove delivery of any journal bytes. Older
# helpers sent from=to=total even when every chunk was skipped. Acknowledging
# that number permanently hid the retained records and invented rotation gaps.
if not raw and not pending:
conn.execute('update router_logs set last_sync = ? where router_id = ?', (ts, router_id))
return {'journal_id': journal_id, 'offset': cursor, 'clear_request': ''}
if not pending and row['journal_id'] == journal_id and end <= cursor:
conn.execute('update router_logs set last_sync = ? where router_id = ?', (ts, router_id))
return {'journal_id': journal_id, 'offset': cursor, 'clear_request': ''}
stored = bytes(row['content'])
if pending:
cursor = start
stored = b''
elif row['journal_id'] and row['journal_id'] != journal_id:
stored += ('[OK] ' + iso_time(ts) + ' Роутер начал новый журнал: очистка или восстановление сохранённой истории.\n').encode('utf-8')
if start > cursor:
stored += ('[WARN] ' + iso_time(ts) + ' Часть записей не доставлена до ротации журнала на роутере.\n').encode('utf-8')
if end > cursor:
stored += redact_router_log_bytes(raw[max(0, cursor - start):])
stored = stored[-ROUTER_LOG_MAX_BYTES:]
conn.execute('''update router_logs set content = ?, journal_id = ?, cursor = ?,
updated_at = case when ? then ? else updated_at end, last_sync = ?, clear_request = ''
where router_id = ?''',
(stored, journal_id, max(cursor, end), bool(raw and end > cursor), ts, ts, router_id))
return {'journal_id': journal_id, 'offset': max(cursor, end), 'clear_request': ''}
def router_log_snapshot(conn, router_id):
row = conn.execute('select * from router_logs where router_id = ?', (router_id,)).fetchone()
raw = bytes(row['content']) if row else b''
# The live browser view stays small; downloading returns the full archive.
live = raw[-65536:]
if len(raw) > 65536 and b'\n' in live:
live = live.split(b'\n', 1)[1]
diagnosis = router_log_diagnosis(conn, router_id, row, raw)
return {'text': live.decode('utf-8', errors='replace'), 'bytes': len(raw), 'diagnosis': diagnosis,
'updated_at': row['updated_at'] if row else 0, 'last_sync': row['last_sync'] if row else 0,
'pending_clear': bool(row and row['clear_request'])}, raw
def router_log_diagnosis(conn, router_id, archive=None, raw=None):
"""Report evidence received on the VPS; never invent a network failure cause."""
router_row = get_active_router(conn, router_id)
router = row_to_router(router_row) if router_row else {}
if archive is None:
archive = conn.execute('select * from router_logs where router_id = ?', (router_id,)).fetchone()
raw = bytes(archive['content']) if raw is None and archive else (raw or b'')
state = json.loads(archive['state_json'] or '{}') if archive else {}
state_at = int(archive['state_at']) if archive else 0
last_seen = int(router.get('last_seen') or 0)
fresh_state = bool(state_at and state_at >= last_seen)
if fresh_state and state.get('enabled') is False:
detail = 'Туннель и Heartbeat остановлены.' if state.get('xray') == 'stopped' else 'Xray ещё запущен.'
return {'level': 'warn', 'text': 'Remote выключен на роутере. ' + detail + ' Отправка логов не отключается вместе с Remote.', 'at': state_at}
if fresh_state and state.get('xray') == 'stopped':
return {'level': 'error', 'text': 'Роутер сообщил: Xray остановлен. Remote включён, но туннель не работает.', 'at': state_at}
# Older agents have no state metadata: use explicit lifecycle facts from
# their delivered journal. A later start cancels the earlier stop reason.
for line in reversed(raw.decode('utf-8', errors='replace').splitlines()):
if ' Hub:' in line:
continue
if 'Сервис: запуск' in line or 'Сервис перезапущен' in line or 'Сервис запущен' in line:
break
if 'Сервис остановлен; результат=warn' in line:
if not state_at:
return {'level': 'warn', 'text': 'Получен журнал: сервис Remote остановлен через панель роутера.', 'at': 0}
break
if router.get('online'):
return {'level': 'ok', 'text': 'Heartbeat поступает.' + (' Роутер сообщил: Xray запущен.' if fresh_state and state.get('xray') == 'running' else ''), 'at': last_seen}
# Highlight a delivered error, without claiming it caused an unseen outage.
for line in reversed(raw.decode('utf-8', errors='replace').splitlines()):
if ' Hub:' in line:
continue
if 'Heartbeat: OK;' in line or 'core: Xray ' in line and ' started' in line:
break
if line.startswith(('[ERROR]', '[WARN]')) and 'строка с ключом' not in line:
return {'level': 'warn', 'text': 'Heartbeat не поступает. Последнее доставленное предупреждение или ошибка: ' + line[:600], 'at': 0}
return {'level': 'warn', 'text': 'Heartbeat не поступает. Причина обрыва не доставлена на VPS; подтверждён только тайм-аут связи.', 'at': 0}
def clear_router_log_archive(conn, router_id):
request = uuid.uuid4().hex
conn.execute('''insert into router_logs(router_id, clear_request) values (?, ?)
on conflict(router_id) do update set content = X'', updated_at = 0, clear_request = excluded.clear_request''',
(router_id, request))
return request
def record_router_connection_log(conn, router_id, online):
# Take the same write lock as ingestion before reading/appending content.
conn.execute('update router_logs set last_sync = last_sync where router_id = ?', (router_id,))
if not get_active_router(conn, router_id):
return
row = conn.execute('select content from router_logs where router_id = ?', (router_id,)).fetchone()
raw = bytes(row['content']) if row else b''
message = ('[OK] ' if online else '[WARN] ') + iso_time(now_ts())
reason = router_log_diagnosis(conn, router_id, raw=raw)['text'] if not online else ''
message += (' Hub: Heartbeat снова поступает.\n' if online else
' Hub: истекло время ожидания Heartbeat, карточка отмечена оффлайн. ' + reason + '\n')
raw = (raw + message.encode('utf-8'))[-ROUTER_LOG_MAX_BYTES:]
conn.execute('''insert into router_logs(router_id, content, updated_at) values (?, ?, ?)
on conflict(router_id) do update set content = excluded.content, updated_at = excluded.updated_at''',
(router_id, raw, now_ts()))
ROUTER_NOTES_MAX_ENTRIES = 200
ROUTER_NOTES_STORAGE_VERSION = 1
ROUTER_NOTES_MEDIA_DIR = STATE_DIR / "router-note-images"
ROUTER_NOTE_IMAGE_MAX_FILES = 8
ROUTER_NOTE_IMAGE_MAX_BYTES = 8 * 1024 * 1024
ROUTER_NOTE_IMAGE_TOTAL_MAX_BYTES = 24 * 1024 * 1024
ROUTER_NOTE_IMAGE_TYPES = {
"image/jpeg": ".jpg",
"image/png": ".png",
"image/webp": ".webp",
"image/gif": ".gif",
}
ROUTER_NOTE_IMAGE_EXTENSIONS = {
".jpg": "image/jpeg",
".jpeg": "image/jpeg",
".png": "image/png",
".webp": "image/webp",
".gif": "image/gif",
}
def clean_router_notes(value):
text = str(value or "").replace("\r\n", "\n").replace("\r", "\n")
lines = [line.rstrip() for line in text.split("\n")]
text = "\n".join(lines).strip()
return text[:ROUTER_NOTE_TEXT_MAX_CHARS]
def clean_router_note_image_name(value):
text = Path(str(value or "").strip()).name
text = re.sub(r"\s+", " ", text).strip(" .")
return (text or "image")[:120]
def clean_router_note_image_item(item):
if not isinstance(item, dict):
return {}
file_name = Path(str(item.get("file_name") or "")).name
if not file_name:
return {}
ext = Path(file_name).suffix.lower()
content_type = str(item.get("content_type") or "").split(";", 1)[0].strip().lower()
if not content_type and ext in ROUTER_NOTE_IMAGE_EXTENSIONS:
content_type = ROUTER_NOTE_IMAGE_EXTENSIONS[ext]
if content_type not in ROUTER_NOTE_IMAGE_TYPES:
return {}
expected_ext = ROUTER_NOTE_IMAGE_TYPES[content_type]
stem = Path(file_name).stem or secrets.token_hex(6)
file_name = f"{stem}{expected_ext}"
size = 0
try:
size = max(0, int(item.get("size") or 0))
except (TypeError, ValueError):
size = 0
return {
"id": str(item.get("id") or stem)[:32],
"file_name": file_name,
"content_type": content_type,
"name": clean_router_note_image_name(item.get("name") or file_name),
"size": size,
}
def clean_router_note_images(items):
clean_items = []
for item in list(items or [])[:ROUTER_NOTE_IMAGE_MAX_FILES]:
clean_item = clean_router_note_image_item(item)
if clean_item:
clean_items.append(clean_item)
return clean_items
def router_note_media_dir(router_id, note_id=""):
base = ROUTER_NOTES_MEDIA_DIR / clean_router_id(router_id)
note_name = str(note_id or "").strip()
if note_name:
return base / note_name[:64]
return base
def router_note_image_path(router_id, note_id, file_name):
return router_note_media_dir(router_id, note_id) / Path(str(file_name or "")).name
def router_note_image_url(router_id, note_id, file_name):
return (
f"/router/{urllib.parse.quote(clean_router_id(router_id))}"
f"/notes-media/{urllib.parse.quote(str(note_id or '')[:64])}"
f"/{urllib.parse.quote(Path(str(file_name or '')).name)}"
)
def save_router_note_images(router_id, note_id, uploads):
uploads = list(uploads or [])
if len(uploads) > ROUTER_NOTE_IMAGE_MAX_FILES:
raise ValueError(f"можно прикрепить не больше {ROUTER_NOTE_IMAGE_MAX_FILES} изображений")
total_size = 0
saved = []
target_dir = router_note_media_dir(router_id, note_id)
target_dir.mkdir(parents=True, exist_ok=True)
for upload in uploads:
raw = bytes((upload or {}).get("body") or b"")
if not raw:
continue
total_size += len(raw)
if len(raw) > ROUTER_NOTE_IMAGE_MAX_BYTES:
raise ValueError("одно изображение слишком большое")
if total_size > ROUTER_NOTE_IMAGE_TOTAL_MAX_BYTES:
raise ValueError("общий размер изображений слишком большой")
content_type = str((upload or {}).get("content_type") or "").split(";", 1)[0].strip().lower()
filename = str((upload or {}).get("filename") or "")
if content_type not in ROUTER_NOTE_IMAGE_TYPES:
content_type = ROUTER_NOTE_IMAGE_EXTENSIONS.get(Path(filename).suffix.lower(), "")
if content_type not in ROUTER_NOTE_IMAGE_TYPES:
raise ValueError("поддерживаются только JPG, PNG, WEBP и GIF")
image_id = secrets.token_hex(6)
file_name = f"{image_id}{ROUTER_NOTE_IMAGE_TYPES[content_type]}"
write_private_bytes(target_dir / file_name, raw)
saved.append(
{
"id": image_id,
"file_name": file_name,
"content_type": content_type,
"name": clean_router_note_image_name(filename or file_name),
"size": len(raw),
}
)
return saved
def delete_router_note_images(router_id, note_id):
target = router_note_media_dir(router_id, note_id)
if target.exists():
shutil.rmtree(target, ignore_errors=True)
def payload_files(payload, field_name):
files = (payload or {}).get("__files__", {})
if not isinstance(files, dict):
return []
items = files.get(field_name, [])
return list(items) if isinstance(items, list) else []
def build_router_note_entry(text, created_at=0, note_id="", images=None):
clean_text = clean_router_notes(text)
clean_images = clean_router_note_images(images)
if not clean_text and not clean_images:
return {}
created = int(created_at or now_ts())
entry = {
"id": str(note_id or secrets.token_hex(6))[:32],
"text": clean_text,
"created_at": created,
}
if clean_images:
entry["images"] = clean_images
return entry
def parse_router_notes_entries(raw_value, fallback_ts=0):
raw_text = str(raw_value or "").strip()
if not raw_text:
return []
payload = None
try:
payload = json.loads(raw_text)
except json.JSONDecodeError:
payload = None
entries = []
if isinstance(payload, dict):
payload_entries = payload.get("entries")
if isinstance(payload_entries, list):
for item in payload_entries:
if not isinstance(item, dict):
continue
entry = build_router_note_entry(
item.get("text", ""),
created_at=item.get("created_at") or fallback_ts or now_ts(),
note_id=item.get("id", ""),
images=item.get("images") or [],
)
if entry:
entries.append(entry)
return entries[:ROUTER_NOTES_MAX_ENTRIES]
elif isinstance(payload, list):
for item in payload:
if not isinstance(item, dict):
continue
entry = build_router_note_entry(
item.get("text", ""),
created_at=item.get("created_at") or fallback_ts or now_ts(),
note_id=item.get("id", ""),
images=item.get("images") or [],
)
if entry:
entries.append(entry)
return entries[:ROUTER_NOTES_MAX_ENTRIES]
legacy_entry = build_router_note_entry(raw_text, created_at=fallback_ts or now_ts())
return [legacy_entry] if legacy_entry else []
def encode_router_notes_entries(entries):
clean_entries = []
for item in list(entries or [])[:ROUTER_NOTES_MAX_ENTRIES]:
if not isinstance(item, dict):
continue
entry = build_router_note_entry(
item.get("text", ""),
created_at=item.get("created_at") or now_ts(),
note_id=item.get("id", ""),
images=item.get("images") or [],
)
if entry:
clean_entries.append(entry)
return json.dumps(
{
"version": ROUTER_NOTES_STORAGE_VERSION,
"entries": clean_entries,
},
ensure_ascii=False,
separators=(",", ":"),
)
@contextmanager
def connect(db_path=DB_PATH):
"""Own the connection: commit/rollback the transaction, then always close.
SQLite's native context manager handles transactions only; it does not close
the connection. Keep every DB operation inside this managed context.
"""
ensure_state()
conn = sqlite3.connect(str(db_path))
try:
conn.row_factory = sqlite3.Row
with conn:
yield conn
finally:
conn.close()
def init_db(conn):
conn.execute(
"""
create table if not exists routers (
id text primary key,
name text not null,
role text not null default 'node',
entry_port integer not null default 0,
vps_host text not null default '',
vless_port integer not null default 8443,
vless_uuid text not null,
vless_encryption text not null default 'none',
vless_decryption text not null default 'none',
vless_flow text not null default '',
reverse_tag text not null default 'reverse-in',
public_url text not null default '',
admin_host text not null default '127.0.0.1',
admin_port integer not null default 80,
ssh_entry_port integer not null default 0,
ssh_vless_uuid text not null default '',
ssh_reverse_tag text not null default '',
ssh_host text not null default '127.0.0.1',
ssh_port integer not null default 22,
notes text not null default '',
created_at integer not null,
updated_at integer not null,
deleted_at integer not null default 0,
last_seen integer,
status_json text not null default '{}'
)
"""
)
conn.execute(
"""
create table if not exists router_groups (
id text primary key,
name text not null,
sort_order integer not null default 0,
created_at integer not null,
updated_at integer not null
)
"""
)
conn.execute('''create table if not exists router_logs (
router_id text primary key, content blob not null default X'',
journal_id text not null default '', cursor integer not null default 0,
updated_at integer not null default 0, last_sync integer not null default 0,
clear_request text not null default '')''')
conn.execute('''create table if not exists router_xray_commands (
id text primary key,
router_id text not null,
action text not null,
status text not null default 'queued',
result text not null default '',
created_at integer not null,
started_at integer not null default 0,
completed_at integer not null default 0,
delivered_at integer not null default 0
)''')
conn.execute('create index if not exists router_xray_commands_router_idx on router_xray_commands(router_id, created_at)')
ensure_column(conn, 'router_xray_commands', 'hidden', 'integer not null default 0')
ensure_column(conn, 'router_logs', 'state_json', "text not null default '{}'")
ensure_column(conn, 'router_logs', 'state_at', 'integer not null default 0')
ensure_column(conn, "routers", "custom_name", "text not null default ''")
ensure_column(conn, "routers", "group_id", "text not null default ''")
ensure_column(conn, "routers", "deleted_at", "integer not null default 0")
ensure_column(conn, "routers", "ssh_entry_port", "integer not null default 0")
ensure_column(conn, "routers", "tachyon_entry_port", "integer not null default 0")
ensure_column(conn, "routers", "ssh_vless_uuid", "text not null default ''")
ensure_column(conn, "routers", "ssh_reverse_tag", "text not null default ''")
ensure_column(conn, "routers", "ssh_host", "text not null default '127.0.0.1'")
ensure_column(conn, "routers", "ssh_port", "integer not null default 22")
ensure_column(conn, "routers", "notes", "text not null default ''")
conn.execute(
"""
update routers
set ssh_entry_port = entry_port + 1000
where entry_port > 0 and (ssh_entry_port is null or ssh_entry_port = 0)
"""
)
for row in conn.execute("select id, reverse_tag, ssh_vless_uuid, ssh_reverse_tag from routers").fetchall():
ssh_uuid = row["ssh_vless_uuid"] or str(uuid.uuid4())
ssh_tag = row["ssh_reverse_tag"] or f"{row['reverse_tag'] or 'reverse-in'}-ssh"
if ssh_uuid != row["ssh_vless_uuid"] or ssh_tag != row["ssh_reverse_tag"]:
conn.execute(
"update routers set ssh_vless_uuid = ?, ssh_reverse_tag = ? where id = ?",
(ssh_uuid, ssh_tag, row["id"]),
)
conn.commit()
def clean_router_group_id(value):
return str(value or "").strip()[:80]
def clean_router_group_name(value):
return " ".join(str(value or "").split())[:120]
def list_router_groups(conn):
rows = conn.execute(
"""
select g.id, g.name, g.sort_order, g.created_at, g.updated_at,
count(r.id) as router_count
from router_groups g
left join routers r on r.group_id = g.id and coalesce(r.deleted_at, 0) = 0
group by g.id
order by g.sort_order, lower(g.name), g.id
"""
).fetchall()
return [dict(row) for row in rows]
def router_group_exists(conn, group_id):
group_id = clean_router_group_id(group_id)
if not group_id:
return True
return bool(conn.execute("select 1 from router_groups where id = ?", (group_id,)).fetchone())
def make_router_group_id(conn, name):
base = re.sub(r"[^a-z0-9]+", "-", name.lower(), flags=re.ASCII).strip("-") or "group"
candidate = base[:64]
suffix = 2
while conn.execute("select 1 from router_groups where id = ?", (candidate,)).fetchone():
candidate = f"{base[:55]}-{suffix}"
suffix += 1
return candidate
def ensure_column(conn, table, column, definition):
cols = {row["name"] for row in conn.execute(f"pragma table_info({table})")}
if column not in cols:
conn.execute(f"alter table {table} add column {column} {definition}")
def get_router(conn, router_id):
return conn.execute("select * from routers where id = ?", (router_id,)).fetchone()
def router_deleted(row):
if not row:
return False
try:
return int(row["deleted_at"] or 0) > 0
except (IndexError, KeyError, TypeError, ValueError):
return False
def get_active_router(conn, router_id):
row = get_router(conn, router_id)
if router_deleted(row):
return None
return row
def get_router_by_entry_port(conn, entry_port, exclude_id=""):
return conn.execute(
"select * from routers where coalesce(deleted_at, 0) = 0 and (entry_port = ? or ssh_entry_port = ? or tachyon_entry_port = ?) and id != ?",
(int(entry_port), int(entry_port), int(entry_port), exclude_id),
).fetchone()
def get_router_by_any_port(conn, port, exclude_id=""):
return conn.execute(
"select * from routers where coalesce(deleted_at, 0) = 0 and (entry_port = ? or ssh_entry_port = ? or tachyon_entry_port = ?) and id != ?",
(int(port), int(port), int(port), exclude_id),
).fetchone()
def normalize_internal_ssh_port(ssh_port, entry_port=0, ssh_entry_port=0):
try:
port = int(ssh_port or 22)
except (TypeError, ValueError):
return 22
if port <= 0 or port in {int(entry_port or 0), int(ssh_entry_port or 0)}:
return 22
return port
def list_router_rows(conn):
return conn.execute(
"""
select * from routers
where coalesce(deleted_at, 0) = 0
order by case role when 'main' then 0 else 1 end, lower(id)
"""
).fetchall()
def normalize_tachyon(value):
if not isinstance(value, dict) or value.get('checked') is not True:
return None
if value.get('installed') is False:
return {'checked': True, 'installed': False}
if value.get('installed') is not True:
return None
mode = value.get('mode')
if mode not in {'standalone', 'luci'}:
return None
port = value.get('port', 0)
if isinstance(port, bool) or not isinstance(port, int):
return None
if mode == 'standalone' and not 1024 <= port <= 65535:
return None
return {'checked': True, 'installed': True, 'mode': mode,
'port': port if mode == 'standalone' else 0,
'version': re.sub(r'[^a-zA-Z0-9.+~_-]', '', str(value.get('version') or ''))[:80],
'package_version': re.sub(r'[^a-zA-Z0-9.+~_-]', '', str(value.get('package_version') or value.get('version') or ''))[:80],
'service': value.get('service') if value.get('service') in {'running', 'stopped'} else 'unknown',
'available': value.get('available') is True,
'api': value.get('api') if value.get('api') in {'/api/agent/v1', '/cgi-bin/tachyon-api', '/cgi-bin/tachyon-agent'} else ''}
def router_tachyon(row):
try:
status = row.get('status') if isinstance(row, dict) and 'status' in row else json.loads(row['status_json'] or '{}')
return normalize_tachyon(status.get('tachyon')) or {}
except (KeyError, IndexError, TypeError, ValueError, AttributeError):
return {}
def allocate_tachyon_entry(conn):
used = {int(row[0]) for column in ('entry_port', 'ssh_entry_port', 'tachyon_entry_port')
for row in conn.execute('select ' + column + ' from routers') if row[0]}
for port in range(24000, 65000):
if port in used:
continue
with socket.socket() as probe:
try:
probe.bind(('127.0.0.1', port))
except OSError:
continue
return port
raise RuntimeError('Нет свободного локального порта для Tachyon.')
def row_to_router(row):
data = dict(row)
try:
status = json.loads(data.get("status_json") or "{}")
except json.JSONDecodeError:
status = {}
note_entries = parse_router_notes_entries(data.get("notes") or "", fallback_ts=data.get("updated_at") or data.get("created_at") or 0)
latest_entry = note_entries[-1] if note_entries else {}
latest_images = list(latest_entry.get("images") or [])
latest_note = latest_entry.get("text") or (f"Фото: {len(latest_images)}" if latest_images else "")
data["notes_entries"] = [
{
**entry,
"images": [
{
**image,
"url": router_note_image_url(data["id"], entry.get("id") or "", image.get("file_name") or ""),
}
for image in list(entry.get("images") or [])
],
"created_at_iso": iso_time(entry.get("created_at") or 0),
"created_at_label": format_router_note_time(entry.get("created_at") or 0),
}
for entry in note_entries
]
data["notes"] = latest_note
data["has_notes"] = bool(note_entries)
data["notes_count"] = len(note_entries)
data["notes_preview"] = " ".join(latest_note.split())[:220]
custom_name = str(data.get("custom_name") or "").strip()
if custom_name:
data["name"] = custom_name
last_seen = data.get("last_seen")
service_enabled = str(status.get("service") or "").lower() != "disabled"
online = bool(last_seen and now_ts() - int(last_seen) <= router_online_timeout(status))
data["status"] = status
data["service_enabled"] = service_enabled
data["online"] = online
tachyon = router_tachyon(data)
if tachyon.get('installed'):
data['tachyon'] = {**tachyon, 'online': bool(online and status.get('xray') == 'running' and tachyon.get('available')),
'url': f"/tachyon/{urllib.parse.quote(data['id'], safe='')}/"}
data["last_seen_iso"] = iso_time(last_seen)
data["access_url"] = f"/access/{urllib.parse.quote(data['id'])}/"
data["ssh_url"] = f"/ssh/{urllib.parse.quote(data['id'])}/"
data["config_url"] = f"/router/{urllib.parse.quote(data['id'])}/config"
data["notes_url"] = f"/router/{urllib.parse.quote(data['id'])}/notes"
data["logs_url"] = f"/router/{urllib.parse.quote(data['id'])}/logs"
data["xray_client_url"] = f"/router/{urllib.parse.quote(data['id'])}/xray-client.json"
data.pop("status_json", None)
return data
def router_online_timeout(status):
"""Return a heartbeat grace period that tolerates WAN/Xray rebinds."""
status = status if isinstance(status, dict) else {}
try:
interval = int(status.get("heartbeat_interval") or 30)
except (TypeError, ValueError):
interval = 30
interval = min(max(interval, 10), 3600)
return max(ONLINE_AFTER_SECONDS, interval * 3 + 30)
def router_with_access(router, account):
router = dict(router or {})
router_id = str(router.get("id") or "")
can_admin = account_has_router_flag(account, router_id, "A")
can_ssh = account_has_router_flag(account, router_id, "B")
can_manage = account_has_router_flag(account, router_id, "G")
router["access_flags"] = sorted(router_flags_for_account(account, router_id))
router["permissions"] = {
"owner": bool(account and account.get("is_owner")),
"admin": bool(can_admin),
"ssh": bool(can_ssh),
"manage": bool(can_manage),
"notes": bool(can_admin),
"notes_edit": bool(can_manage),
"notes_delete": bool(account and account.get("is_owner")),
"config": bool(can_manage),
"wol": bool(can_manage),
"traffic": bool(can_manage),
"logs": bool(can_manage),
"delete": bool(account and account.get("is_owner")),
"diagnose": bool(can_manage),
}
return router
def delegated_auth_meta(auth=None, account=None, router_rows=None):
auth = normalize_auth_state(auth or load_auth())
account = account or account_profile(auth, "")
router_rows = list(router_rows or [])
router_name_map = {}
for row in router_rows:
router = row_to_router(row)
router_name_map[str(router.get("id") or "")] = str(router.get("name") or router.get("id") or "")
assigned = []
for router_id in sorted((account or {}).get("router_ids", []), key=str.lower):
flags = sorted(router_flags_for_account(account, router_id))
if not flags:
continue
assigned.append(
{
"id": router_id,
"name": router_name_map.get(router_id, router_id),
"flags": flags,
"flag_label": "".join(flag for flag in ROUTER_ACCESS_FLAGS if flag in flags) or "-",
}
)
return {
"username": (account or {}).get("username") or auth.get("username", "admin"),
"is_owner": False,
"can_add_router": bool(account_can_add_router(account)),
"current_user": {
"username": (account or {}).get("username") or auth.get("username", "admin"),
"is_owner": False,
},
"assigned_routers": assigned,
"router_access": {item.get("id", ""): item.get("flags", []) for item in assigned},
"passkeys_supported": passkey_supported(),
}
def router_notification_label(router):
router_id = str((router or {}).get("id") or "").strip()
name = str((router or {}).get("name") or router_id or "router").strip()
if router_id and name and name != router_id:
return f"{name} ({router_id})"
return name or router_id or "router"
def router_notification_details(router):
details = []
if not isinstance(router, dict):
return details
last_seen_iso = str(router.get("last_seen_iso") or "").strip()
if last_seen_iso:
details.append(f"Последний heartbeat: {last_seen_iso}")
status = router.get("status") if isinstance(router.get("status"), dict) else {}
wan_ip = str(status.get("wan_ip") or status.get("ip") or "").strip()
if wan_ip:
details.append(f"WAN IP: {wan_ip}")
release = str(status.get("release") or "").strip()
if release:
details.append(f"Система: {release}")
return details[:6]
def notify_router_online(router, dedupe_seconds=45):
label = router_notification_label(router)
add_notification(
"router_online",
"Роутер снова в сети",
f"{label} снова выходит на связь с Hub.",
"info",
router_notification_details(router),
{"router_id": str((router or {}).get("id") or ""), "online": True},
dedupe_seconds=dedupe_seconds,
)
def notify_router_offline(router, dedupe_seconds=0):
label = router_notification_label(router)
grace = router_online_timeout((router or {}).get("status"))
add_notification(
"router_offline",
"Роутер пропал из сети",
f"{label} не присылает heartbeat дольше {grace} сек.",
"bad",
router_notification_details(router),
{"router_id": str((router or {}).get("id") or ""), "online": False},
dedupe_seconds=dedupe_seconds or max(45, grace // 2),
)
def backup_filename():
stamp = dt.datetime.now(dt.timezone.utc).strftime("%Y%m%d-%H%M%S")
return f"owrt-remote-hub-backup-{stamp}.tar.gz"
def copy_sqlite_backup(src_path, dst_path):
src_path = Path(src_path)
dst_path = Path(dst_path)
src_path.parent.mkdir(parents=True, exist_ok=True)
dst_path.parent.mkdir(parents=True, exist_ok=True)
if not src_path.exists():
with connect(src_path) as conn:
init_db(conn)
with connect(src_path) as source, connect(dst_path) as dest:
source.backup(dest)
def write_private_bytes(path, data, mode=0o600):
with atomic_output_path(path) as tmp:
tmp.write_bytes(data)
try:
os.chmod(tmp, mode)
except OSError:
pass
def create_hub_backup(out_path, db_path=DB_PATH):
ensure_state()
out_path = Path(out_path)
out_path.parent.mkdir(parents=True, exist_ok=True)
with tempfile.TemporaryDirectory(prefix="owrt-hub-backup-") as tmp_name:
tmp_dir = Path(tmp_name)
state_dir = tmp_dir / "state"
state_dir.mkdir(parents=True, exist_ok=True)
db_copy = state_dir / "hub.db"
copy_sqlite_backup(db_path, db_copy)
files = ["state/hub.db"]
for path in BACKUP_STATE_FILES:
path = Path(path)
if not path.exists() or not path.is_file():
continue
arcname = f"state/{path.name}"
(state_dir / path.name).write_bytes(path.read_bytes())
files.append(arcname)
manifest = {
"app": APP_NAME,
"version": BACKUP_VERSION,
"created_at": iso_time(now_ts()),
"hostname": socket.gethostname(),
"state_dir": str(STATE_DIR),
"db_path": str(db_path),
"files": files,
}
(tmp_dir / "manifest.json").write_text(json.dumps(manifest, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
with atomic_output_path(out_path) as tmp_archive:
with tarfile.open(tmp_archive, "w:gz") as tar:
tar.add(tmp_dir / "manifest.json", arcname="manifest.json")
for item in state_dir.iterdir():
if item.is_file():
tar.add(item, arcname=f"state/{item.name}")
try:
os.chmod(tmp_archive, 0o600)
except OSError:
pass
return {"path": str(out_path), "filename": out_path.name, "files": files}
def safe_tar_member_name(name):
value = str(name or "").replace("\\", "/")
if not value or value.startswith("/") or ":" in value:
return False
parts = value.split("/")
return all(part and part not in {".", ".."} for part in parts)
def extract_hub_backup(archive_path, tmp_dir):
with tarfile.open(archive_path, "r:gz") as tar:
members = tar.getmembers()
for member in members:
if not safe_tar_member_name(member.name):
raise ValueError(f"unsafe backup member: {member.name}")
if not (member.isfile() or member.isdir()):
raise ValueError(f"unsupported backup member: {member.name}")
tar.extractall(tmp_dir, members)
def rewrite_router_endpoints(conn, vps_host="", public_url="", preserve_vps_fallback=False):
rewritten = {}
next_vps_host = str(vps_host or "").strip()
next_public_url = str(public_url or "").strip()
ts = now_ts()
keep_vps_host = preserve_vps_fallback and should_preserve_router_vps_fallback(next_vps_host, next_public_url)
if next_vps_host and not keep_vps_host:
conn.execute(
"update routers set vps_host = ?, updated_at = ? where deleted_at = 0",
(next_vps_host, ts),
)
rewritten["vps_host"] = next_vps_host
if next_public_url:
conn.execute(
"update routers set public_url = ?, updated_at = ? where deleted_at = 0",
(next_public_url, ts),
)
rewritten["public_url"] = next_public_url
if rewritten:
conn.commit()
return rewritten
def router_current_hub_bundle(router, app_public_url="", request_origin="", fallback_host=""):
row = dict(router or {})
app_origin = public_url_origin(app_public_url)
request_origin = public_url_origin(request_origin)
public_url, hub_url = router_hub_origins(row, app_public_url, request_origin)
hub_url = hub_url or router_fallback_hub_url(row, fallback_host, 8088)
reported_mode, reported_host = router_reported_connection(row)
config_vps_host = (
(reported_host if reported_mode == "manual" else "")
or str(row.get("vps_host") or "").strip()
or vps_host_name(public_url or hub_url)
or vps_host_name(app_origin or request_origin)
or vps_host_name(router_fallback_hub_url(row, fallback_host, 8088))
or ""
)
hub_update = {
"hub_url": hub_url,
"public_url": public_url,
"vps_host": config_vps_host,
}
return hub_update, hub_url, config_vps_host
def restore_hub_backup(archive_path, db_path=DB_PATH, vps_host="", public_url=""):
ensure_state()
archive_path = Path(archive_path)
restored_files = []
warnings = []
with tempfile.TemporaryDirectory(prefix="owrt-hub-restore-") as tmp_name:
tmp_dir = Path(tmp_name)
extract_hub_backup(archive_path, tmp_dir)
manifest_path = tmp_dir / "manifest.json"
if not manifest_path.exists():
raise ValueError("backup manifest.json not found")
manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
if int(manifest.get("version") or 0) > BACKUP_VERSION:
raise ValueError(f"backup version {manifest.get('version')} is newer than this Hub")
state_dir = tmp_dir / "state"
db_src = state_dir / "hub.db"
if not db_src.exists():
raise ValueError("backup has no state/hub.db")
db_path = Path(db_path)
if db_path.exists():
old = db_path.with_name(f"{db_path.name}.before-restore-{now_ts()}")
write_private_bytes(old, db_path.read_bytes())
warnings.append(f"old DB copy saved: {old}")
write_private_bytes(db_path, db_src.read_bytes())
restored_files.append(str(db_path))
for target in BACKUP_STATE_FILES:
src = state_dir / Path(target).name
if not src.exists():
continue
write_private_bytes(target, src.read_bytes())
restored_files.append(str(target))
rewritten = {}
with connect(db_path) as conn:
init_db(conn)
rewritten = rewrite_router_endpoints(conn, vps_host=vps_host, public_url=public_url)
xray = None
try:
xray = reload_vps_xray(db_path)
except Exception as exc:
warnings.append(f"xray reload skipped: {exc}")
if os.environ.get("OWRT_REMOTE_AGENT_TOKEN"):
warnings.append("OWRT_REMOTE_AGENT_TOKEN is set in environment, restored agent.token file may be ignored")
return {
"manifest": manifest,
"restored_files": restored_files,
"rewritten": rewritten,
"xray": xray,
"warnings": warnings,
"restart_required": True,
}
def upsert_router(conn, values):
router_id = clean_router_id(values.get("id"))
current = get_router(conn, router_id)
ts = now_ts()
def keep_str(key, default=""):
value = values.get(key)
if value not in (None, ""):
return value
if current:
return current[key]
return default
def keep_int(key, default=0):
value = values.get(key)
if value not in (None, ""):
return int(value)
if current:
return int(current[key] or default)
return default
reverse_tag = keep_str("reverse_tag", "reverse-in")
ssh_vless_uuid = values.get("ssh_vless_uuid") or (current["ssh_vless_uuid"] if current and current["ssh_vless_uuid"] else str(uuid.uuid4()))
ssh_reverse_tag = values.get("ssh_reverse_tag") or (current["ssh_reverse_tag"] if current and current["ssh_reverse_tag"] else f"{reverse_tag}-ssh")
if "notes" in values:
incoming_notes = values.get("notes", "")
if isinstance(incoming_notes, list):
notes = encode_router_notes_entries(incoming_notes)
else:
notes = encode_router_notes_entries(parse_router_notes_entries(incoming_notes, fallback_ts=ts))
elif current:
notes = str(current["notes"] or "")
else:
notes = encode_router_notes_entries([])
payload = {
"id": router_id,
"name": values.get("name") or router_id,
"role": values.get("role") or "node",
"group_id": clean_router_group_id(keep_str("group_id", "")),
"entry_port": keep_int("entry_port", 0),
"vps_host": keep_str("vps_host", ""),
"vless_port": keep_int("vless_port", DEFAULT_VLESS_PORT),
"vless_uuid": keep_str("vless_uuid", str(uuid.uuid4())),
"vless_encryption": keep_str("vless_encryption", "none"),
"vless_decryption": keep_str("vless_decryption", "none"),
"vless_flow": keep_str("vless_flow", ""),
"reverse_tag": reverse_tag,
"public_url": keep_str("public_url", ""),
"admin_host": keep_str("admin_host", "127.0.0.1"),
"admin_port": keep_int("admin_port", 80),
"ssh_entry_port": keep_int("ssh_entry_port", int(values.get("entry_port") or 0) + 1000 if values.get("entry_port") else 0),
"ssh_vless_uuid": ssh_vless_uuid,
"ssh_reverse_tag": ssh_reverse_tag,
"ssh_host": keep_str("ssh_host", "127.0.0.1"),
"ssh_port": keep_int("ssh_port", 22),
"notes": notes,
"updated_at": ts,
"deleted_at": 0,
}
payload["ssh_port"] = normalize_internal_ssh_port(
payload["ssh_port"],
payload["entry_port"],
payload["ssh_entry_port"],
)
if current and int(current['tachyon_entry_port'] or 0) in {payload['entry_port'], payload['ssh_entry_port']} - {0}:
raise ValueError('Этот локальный порт уже используется интеграцией Tachyon.')
if current:
conn.execute(
"""
update routers set
name = :name,
role = :role,
group_id = :group_id,
entry_port = :entry_port,
vps_host = :vps_host,
vless_port = :vless_port,
vless_uuid = :vless_uuid,
vless_encryption = :vless_encryption,
vless_decryption = :vless_decryption,
vless_flow = :vless_flow,
reverse_tag = :reverse_tag,
public_url = :public_url,
admin_host = :admin_host,
admin_port = :admin_port,
ssh_entry_port = :ssh_entry_port,
ssh_vless_uuid = :ssh_vless_uuid,
ssh_reverse_tag = :ssh_reverse_tag,
ssh_host = :ssh_host,
ssh_port = :ssh_port,
notes = :notes,
deleted_at = :deleted_at,
updated_at = :updated_at
where id = :id
""",
payload,
)
else:
payload["created_at"] = ts
conn.execute(
"""
insert into routers (
id, name, role, group_id, entry_port, vps_host, vless_port, vless_uuid,
vless_encryption, vless_decryption, vless_flow, reverse_tag,
public_url, admin_host, admin_port, ssh_entry_port, ssh_vless_uuid,
ssh_reverse_tag, ssh_host, ssh_port, notes,
created_at, updated_at, deleted_at
) values (
:id, :name, :role, :group_id, :entry_port, :vps_host, :vless_port, :vless_uuid,
:vless_encryption, :vless_decryption, :vless_flow, :reverse_tag,
:public_url, :admin_host, :admin_port, :ssh_entry_port, :ssh_vless_uuid,
:ssh_reverse_tag, :ssh_host, :ssh_port, :notes,
:created_at, :updated_at, :deleted_at
)
""",
payload,
)
conn.commit()
return get_router(conn, router_id)
XRAY_CONTROL_ACTIONS = {'start': 'Запустить', 'stop': 'Остановить', 'restart': 'Перезапустить'}
XRAY_CONTROL_TIMEOUT_SECONDS = 180
XRAY_CONTROL_EXECUTION_SECONDS = 45
def xray_control_audit(conn, router_id, message, level='OK'):
conn.execute('insert or ignore into router_logs(router_id) values (?)', (router_id,))
raw = bytes(conn.execute('select content from router_logs where router_id=?', (router_id,)).fetchone()[0])
raw = (raw + f'[{level}] {iso_time(now_ts())} Hub: Remote Xray: {message}\n'.encode())[-ROUTER_LOG_MAX_BYTES:]
conn.execute('update router_logs set content=?, updated_at=? where router_id=?', (raw, now_ts(), router_id))
def xray_control_expire(conn, router_id):
ts = now_ts()
query = "select * from router_xray_commands where router_id=? and status in ('queued','delivered','running') and created_at < ?"
if not conn.execute(query, (router_id, ts - XRAY_CONTROL_TIMEOUT_SECONDS)).fetchone():
return
# Most UI polls stay read-only. Serialize expiry only when a command is actually overdue.
conn.execute('update routers set last_seen=last_seen where id=?', (router_id,))
rows = conn.execute(query, (router_id, ts - XRAY_CONTROL_TIMEOUT_SECONDS)).fetchall()
for row in rows:
if ts - row['created_at'] <= XRAY_CONTROL_TIMEOUT_SECONDS:
continue
message = ('Команда не доставлена: агент не вышел на связь за 3 минуты. Команда отменена.'
if not row['delivered_at'] else
'Результат не подтверждён: агент не прислал итог за 3 минуты. Проверь журнал и текущий статус Xray.')
status = 'expired' if not row['delivered_at'] else 'unconfirmed'
conn.execute('update router_xray_commands set status=?, result=?, completed_at=? where id=?', (status, message, ts, row['id']))
xray_control_audit(conn, router_id, message, 'WARN')
def xray_control_enqueue(conn, router_id, action, request_id):
if not isinstance(action, str) or action not in XRAY_CONTROL_ACTIONS or not re.fullmatch(r'[a-f0-9]{32}', str(request_id or '')):
raise ValueError('Недопустимая команда или идентификатор запроса.')
# Acquire the DB writer before checking the queue; concurrent tabs cannot enqueue two operations.
conn.execute('update routers set last_seen=last_seen where id=?', (router_id,))
row = get_active_router(conn, router_id)
if not row:
raise ValueError('Роутер не найден.')
previous = conn.execute('select * from router_xray_commands where id=?', (request_id,)).fetchone()
if previous:
if previous['router_id'] != router_id or previous['action'] != action:
raise ValueError('Этот идентификатор уже использован другой командой.')
return
if router_reported_status(row).get('xray_control') != 1:
raise ValueError('Сначала обнови агент на этом роутере: управление через Heartbeat ещё не поддерживается.')
xray_control_expire(conn, router_id)
if conn.execute("select 1 from router_xray_commands where router_id=? and status in ('queued','delivered','running')", (router_id,)).fetchone():
raise ValueError('Предыдущая команда ещё выполняется или ожидает Heartbeat.')
conn.execute('insert into router_xray_commands(id,router_id,action,created_at) values (?,?,?,?)', (request_id, router_id, action, now_ts()))
conn.execute('delete from router_xray_commands where router_id=? and id not in (select id from router_xray_commands where router_id=? order by created_at desc,rowid desc limit 100)', (router_id, router_id))
xray_control_audit(conn, router_id, f'{XRAY_CONTROL_ACTIONS[action]} Xray: команда {request_id[:8]} поставлена в очередь.')
def xray_control_exchange(conn, router_id, payload):
conn.execute('update routers set last_seen=last_seen where id=?', (router_id,))
result = payload.get('xray_control_result')
if isinstance(result, dict):
command = conn.execute('select * from router_xray_commands where id=? and router_id=?',
(str(result.get('id') or ''), router_id)).fetchone()
state, rc, xray = result.get('status'), result.get('rc'), result.get('xray')
if (command and not command['hidden'] and command['delivered_at'] and command['action'] == result.get('action')
and command['status'] in {'delivered', 'running', 'unconfirmed'}
and state in {'running', 'succeeded', 'failed', 'interrupted'}
and not (command['status'] == 'unconfirmed' and state == 'running')
and type(rc) is int and 0 <= rc <= 255 and xray in {'running', 'stopped'}):
if state == 'succeeded' and (rc != 0 or xray != ('stopped' if command['action'] == 'stop' else 'running')):
state = 'failed'
message = str(result.get('message') or '')[:1500]
message = redact_router_log_bytes(message.encode()).decode('utf-8', 'replace')
if state != command['status']:
conn.execute('update router_xray_commands set status=?,result=?,started_at=case when started_at=0 then ? else started_at end,completed_at=? where id=?',
(state, message, now_ts(), 0 if state == 'running' else now_ts(), command['id']))
xray_control_audit(conn, router_id, f'{XRAY_CONTROL_ACTIONS[command["action"]]} Xray: {message} (rc={rc}, Xray={xray}).',
'OK' if state in {'running', 'succeeded'} else 'ERROR')
xray_control_expire(conn, router_id)
if payload.get('xray_control') != 1:
return None
row = conn.execute("select * from router_xray_commands where router_id=? and status in ('queued','delivered') order by created_at limit 1", (router_id,)).fetchone()
if not row:
return None
conn.execute("update router_xray_commands set status='delivered',delivered_at=case when delivered_at=0 then ? else delivered_at end where id=?", (now_ts(), row['id']))
return {'id': row['id'], 'action': row['action']}
def xray_control_clear_history(conn, router_id):
# Keep bounded ID tombstones for retry protection, but erase completed output.
# Active commands must remain visible and deliverable even from another tab.
conn.execute('update routers set last_seen=last_seen where id=?', (router_id,))
if not get_active_router(conn, router_id):
raise ValueError('Роутер не найден.')
xray_control_expire(conn, router_id)
conn.execute("update router_xray_commands set hidden=1,result='' where router_id=? and status not in ('queued','delivered','running')",
(router_id,))
def xray_control_snapshot(conn, router_id):
row = get_active_router(conn, router_id)
if not row:
raise ValueError('Роутер не найден.')
xray_control_expire(conn, router_id)
router = row_to_router(row)
try:
interval = int(router['status'].get('heartbeat_interval') or 30)
except (TypeError, ValueError):
interval = 30
return {'ok': True, 'router_id': router_id, 'name': router['name'], 'online': router['online'],
'last_seen': router['last_seen'], 'xray': router['status'].get('xray', 'unknown'),
'supported': router['status'].get('xray_control') == 1,
'server_time': now_ts(), 'heartbeat_interval': min(max(interval, 10), 3600),
'command_timeout_seconds': XRAY_CONTROL_TIMEOUT_SECONDS, 'execution_timeout_seconds': XRAY_CONTROL_EXECUTION_SECONDS,
'history': [dict(item) for item in conn.execute('select * from router_xray_commands where router_id=? and hidden=0 order by created_at desc,rowid desc limit 30', (router_id,))]}
def heartbeat(conn, payload):
router_id = clean_router_id(payload.get("id"))
row = get_router(conn, router_id)
payload = dict(payload)
tachyon = normalize_tachyon(payload.get('tachyon'))
if tachyon is None:
tachyon = router_tachyon(row) if row else {}
if tachyon:
tachyon = {**tachyon, 'available': False}
payload['tachyon'] = tachyon
ts = now_ts()
status_json = json.dumps(payload, ensure_ascii=False, separators=(",", ":"))
was_deleted = router_deleted(row)
known_before = bool(row and not was_deleted)
was_online = bool(row_to_router(row).get("online")) if known_before else False
old_entry_port = int(row["entry_port"] or 0) if row else 0
old_ssh_entry_port = int(row["ssh_entry_port"] or 0) if row else 0
created_with_xray_ports = False
if row:
entry_port = int(row["entry_port"] or 0)
ssh_entry_port = int(row["ssh_entry_port"] or 0)
else:
entry_port = int(payload.get("entry_port") or 0) if str(payload.get("entry_port", "")).isdigit() else 0
ssh_entry_port = 0
ssh_port = normalize_internal_ssh_port(payload.get("ssh_port") or 22, entry_port, ssh_entry_port)
if not row:
row = upsert_router(
conn,
{
"id": router_id,
"name": payload.get("name") or router_id,
"role": payload.get("role") or "node",
"entry_port": payload.get("entry_port") or 0,
"vps_host": payload.get("vps_host") or "",
"admin_host": payload.get("admin_host") or "127.0.0.1",
"admin_port": payload.get("admin_port") or 80,
"ssh_host": payload.get("ssh_host") or "127.0.0.1",
"ssh_port": ssh_port,
},
)
created_with_xray_ports = bool(int(row["entry_port"] or 0) or int(row["ssh_entry_port"] or 0))
ssh_entry_port = int(row["ssh_entry_port"] or 0)
ssh_port = normalize_internal_ssh_port(payload.get("ssh_port") or 22, int(row["entry_port"] or 0), ssh_entry_port)
conn.execute(
"""
update routers set
name = case
when nullif(custom_name, '') is not null then custom_name
else coalesce(nullif(?, ''), name)
end,
role = coalesce(nullif(?, ''), role),
public_url = coalesce(nullif(?, ''), public_url),
admin_host = coalesce(nullif(?, ''), admin_host),
admin_port = coalesce(?, admin_port),
ssh_host = coalesce(nullif(?, ''), ssh_host),
ssh_port = coalesce(?, ssh_port),
last_seen = ?,
status_json = ?,
updated_at = ?,
deleted_at = 0
where id = ?
""",
(
payload.get("name") or "",
payload.get("role") or "",
payload.get("public_url") or "",
payload.get("admin_host") or "",
int(payload["admin_port"]) if str(payload.get("admin_port", "")).isdigit() else None,
payload.get("ssh_host") or "",
ssh_port,
ts,
status_json,
ts,
router_id,
),
)
conn.commit()
old_tachyon = router_tachyon(row)
old_endpoint = old_tachyon.get('port', 0) if old_tachyon.get('installed') and old_tachyon.get('mode') == 'standalone' else 0
new_endpoint = tachyon.get('port', 0) if tachyon.get('installed') and tachyon.get('mode') == 'standalone' else 0
tachyon_reload = old_endpoint != new_endpoint
if tachyon.get('installed') and tachyon.get('mode') == 'standalone' and not row['tachyon_entry_port']:
conn.execute('begin immediate')
current_entry = conn.execute('select tachyon_entry_port from routers where id=?', (router_id,)).fetchone()[0]
if not current_entry:
conn.execute('update routers set tachyon_entry_port=? where id=?', (allocate_tachyon_entry(conn), router_id))
tachyon_reload = True
conn.commit()
router = row_to_router(get_router(conn, router_id))
entry_now = int(router.get("entry_port") or 0)
ssh_entry_now = int(router.get("ssh_entry_port") or 0)
router["_xray_reload_required"] = bool(
(entry_now or ssh_entry_now)
and (
was_deleted
or tachyon_reload
or created_with_xray_ports
or old_entry_port != entry_now
or old_ssh_entry_port != ssh_entry_now
)
)
router["_became_online"] = bool(known_before and not was_online and router.get("online"))
return router
def rename_router(conn, router_id, name):
router_id = clean_router_id(router_id)
clean_name = clean_router_name(name)
row = get_router(conn, router_id)
if not row:
raise ValueError("router not found")
conn.execute(
"update routers set name = ?, custom_name = ?, updated_at = ? where id = ?",
(clean_name, clean_name, now_ts(), router_id),
)
conn.commit()
return get_router(conn, router_id)
def update_router_notes(conn, router_id, notes):
router_id = clean_router_id(router_id)
row = get_router(conn, router_id)
if not row or router_deleted(row):
raise ValueError("router not found")
clean_notes = clean_router_notes(notes)
stored = encode_router_notes_entries([build_router_note_entry(clean_notes, created_at=now_ts())] if clean_notes else [])
conn.execute(
"update routers set notes = ?, updated_at = ? where id = ?",
(stored, now_ts(), router_id),
)
conn.commit()
return get_router(conn, router_id)
def append_router_note(conn, router_id, note_text, image_uploads=None):
router_id = clean_router_id(router_id)
row = get_router(conn, router_id)
if not row or router_deleted(row):
raise ValueError("router not found")
note_id = secrets.token_hex(6)
saved_images = save_router_note_images(router_id, note_id, image_uploads)
entry = build_router_note_entry(note_text, created_at=now_ts(), note_id=note_id, images=saved_images)
if not entry:
if saved_images:
delete_router_note_images(router_id, note_id)
raise ValueError("note is empty")
try:
entries = parse_router_notes_entries(row["notes"] or "", fallback_ts=row["updated_at"] or row["created_at"] or 0)
entries.append(entry)
entries = entries[-ROUTER_NOTES_MAX_ENTRIES:]
conn.execute(
"update routers set notes = ?, updated_at = ? where id = ?",
(encode_router_notes_entries(entries), now_ts(), router_id),
)
conn.commit()
except Exception:
if saved_images:
delete_router_note_images(router_id, note_id)
raise
return get_router(conn, router_id)
def update_router_note_entry(conn, router_id, note_id, note_text):
router_id = clean_router_id(router_id)
note_id = str(note_id or "").strip()
if not note_id:
raise ValueError("note id is empty")
row = get_router(conn, router_id)
if not row or router_deleted(row):
raise ValueError("router not found")
clean_text = clean_router_notes(note_text)
entries = parse_router_notes_entries(row["notes"] or "", fallback_ts=row["updated_at"] or row["created_at"] or 0)
updated = False
for item in entries:
if str(item.get("id") or "") != note_id:
continue
if not clean_text and not list(item.get("images") or []):
raise ValueError("note is empty")
item["text"] = clean_text
updated = True
break
if not updated:
raise ValueError("note not found")
conn.execute(
"update routers set notes = ?, updated_at = ? where id = ?",
(encode_router_notes_entries(entries), now_ts(), router_id),
)
conn.commit()
return get_router(conn, router_id)
def delete_router_note_entry(conn, router_id, note_id):
router_id = clean_router_id(router_id)
note_id = str(note_id or "").strip()
if not note_id:
raise ValueError("note id is empty")
row = get_router(conn, router_id)
if not row or router_deleted(row):
raise ValueError("router not found")
entries = parse_router_notes_entries(row["notes"] or "", fallback_ts=row["updated_at"] or row["created_at"] or 0)
filtered = [item for item in entries if str(item.get("id") or "") != note_id]
if len(filtered) == len(entries):
raise ValueError("note not found")
conn.execute(
"update routers set notes = ?, updated_at = ? where id = ?",
(encode_router_notes_entries(filtered), now_ts(), router_id),
)
conn.commit()
delete_router_note_images(router_id, note_id)
return get_router(conn, router_id)
def make_server_xray_config(rows, listen_host="0.0.0.0", listen_port=DEFAULT_VLESS_PORT, decryption="none"):
clients = []
inbounds = [
{
"tag": "owrt-remote-vless",
"listen": listen_host,
"port": int(listen_port),
"protocol": "vless",
"settings": {
"clients": clients,
"decryption": decryption,
},
"streamSettings": {
"network": "tcp",
"security": "none",
},
}
]
rules = []
for row in rows:
router_id = clean_router_id(row["id"])
entry_port = int(row["entry_port"] or 0)
if entry_port <= 0:
continue
ssh_entry_port = int(row["ssh_entry_port"] or 0)
reverse_out = f"reverse-{router_id}"
ssh_reverse_out = f"{reverse_out}-ssh"
portal_in = f"entry-{router_id}"
client = {
"id": row["vless_uuid"],
"email": f"{router_id}@owrt-remote",
"reverse": {
"tag": reverse_out,
},
}
if row["vless_flow"]:
client["flow"] = row["vless_flow"]
clients.append(client)
if ssh_entry_port > 0:
ssh_client = {
"id": row["ssh_vless_uuid"],
"email": f"{router_id}-ssh@owrt-remote",
"reverse": {
"tag": ssh_reverse_out,
},
}
if row["vless_flow"]:
ssh_client["flow"] = row["vless_flow"]
clients.append(ssh_client)
inbounds.append(
{
"tag": portal_in,
"listen": "127.0.0.1",
"port": entry_port,
"protocol": "tunnel",
"settings": {
"allowedNetwork": "tcp",
"rewriteAddress": row["admin_host"],
"rewritePort": int(row["admin_port"]),
},
}
)
rules.append(
{
"type": "field",
"inboundTag": [portal_in],
"outboundTag": reverse_out,
}
)
tachyon = router_tachyon(row)
tachyon_entry = int(dict(row).get('tachyon_entry_port') or 0)
if tachyon.get('installed') and tachyon.get('mode') == 'standalone' and tachyon_entry:
tag = f'tachyon-{router_id}'
inbounds.append({'tag': tag, 'listen': '127.0.0.1', 'port': tachyon_entry,
'protocol': 'tunnel', 'settings': {'allowedNetwork': 'tcp',
'rewriteAddress': '127.0.0.1', 'rewritePort': tachyon['port']}})
rules.append({'type': 'field', 'inboundTag': [tag], 'outboundTag': reverse_out})
if ssh_entry_port > 0:
ssh_in = f"ssh-{router_id}"
inbounds.append(
{
"tag": ssh_in,
"listen": "127.0.0.1",
"port": ssh_entry_port,
"protocol": "tunnel",
"settings": {
"allowedNetwork": "tcp",
"rewriteAddress": row["ssh_host"] or "127.0.0.1",
"rewritePort": int(row["ssh_port"] or 22),
},
}
)
rules.append(
{
"type": "field",
"inboundTag": [ssh_in],
"outboundTag": ssh_reverse_out,
}
)
# Xray 26.3.27 accepts the tunnel alias but only reads the original
# dokodemo address/port/network fields. Without them it forwards the
# inbound listener's local port, so the router's Tachyon rule never matches
# and the admin fallback receives the connection. Emit both spellings with
# identical values; newer cores use the explicit rewrite fields.
for inbound in inbounds:
if inbound.get('protocol') == 'tunnel':
settings = inbound['settings']
settings.update(network=settings['allowedNetwork'], address=settings['rewriteAddress'],
port=settings['rewritePort'])
return {
"log": {"loglevel": "warning"},
"inbounds": inbounds,
"outbounds": [{"tag": "direct", "protocol": "freedom"}],
"routing": {"rules": rules},
"remarks": "OpenWrt Remote Hub server config",
}
def make_router_xray_config(row):
bridge_tag = row["reverse_tag"]
ssh_bridge_tag = row["ssh_reverse_tag"] or f"{bridge_tag}-ssh"
config = {
"log": {"loglevel": "warning"},
"inbounds": [],
"outbounds": [
{
"tag": "router-admin",
"protocol": "freedom",
"settings": {
"redirect": f"{row['admin_host']}:{int(row['admin_port'])}",
# VLESS reverse is denied by Freedom's default final rule.
# Redirect fixes the destination; allow only its TCP port.
"finalRules": [{"action": "allow", "network": "tcp", "port": int(row["admin_port"])}],
},
},
{
"tag": "router-ssh",
"protocol": "freedom",
"settings": {
"redirect": f"{row['ssh_host'] or '127.0.0.1'}:{int(row['ssh_port'] or 22)}",
"finalRules": [{"action": "allow", "network": "tcp", "port": int(row["ssh_port"] or 22)}],
},
},
{
"tag": "vps-interconn",
"protocol": "vless",
"settings": {
"address": row["vps_host"],
"port": int(row["vless_port"]),
"id": row["vless_uuid"],
"encryption": row["vless_encryption"],
"flow": row["vless_flow"],
"reverse": {"tag": bridge_tag},
},
"streamSettings": {"network": "tcp", "security": "none"},
},
{
"tag": "vps-ssh-interconn",
"protocol": "vless",
"settings": {
"address": row["vps_host"],
"port": int(row["vless_port"]),
"id": row["ssh_vless_uuid"],
"encryption": row["vless_encryption"],
"flow": row["vless_flow"],
"reverse": {"tag": ssh_bridge_tag},
},
"streamSettings": {"network": "tcp", "security": "none"},
},
],
"routing": {
"rules": [
{
"type": "field",
"inboundTag": [bridge_tag],
"outboundTag": "router-admin",
},
{
"type": "field",
"inboundTag": [ssh_bridge_tag],
"outboundTag": "router-ssh",
}
]
},
"remarks": f"OpenWrt Remote client for {row['id']}",
}
tachyon = router_tachyon(row)
if tachyon.get('installed') and tachyon.get('mode') == 'standalone':
port = tachyon['port']
config['outbounds'].insert(0, {'tag': 'router-tachyon', 'protocol': 'freedom', 'settings': {
'redirect': f'127.0.0.1:{port}', 'finalRules': [{'action': 'allow', 'network': 'tcp', 'port': port}]}})
config['routing']['rules'].insert(0, {'type': 'field', 'inboundTag': [bridge_tag],
'ip': ['127.0.0.1'], 'port': port, 'outboundTag': 'router-tachyon'})
return config
def reload_vps_xray(db_path=DB_PATH):
out = Path(os.environ.get("OWRT_REMOTE_XRAY_CONFIG", "/etc/xray/owrt-remote.json"))
service = os.environ.get("OWRT_REMOTE_XRAY_SERVICE", "owrt-remote-xray")
with connect(db_path) as conn:
init_db(conn)
rows = list_router_rows(conn)
config = make_server_xray_config(rows)
atomic_write_text(out, json.dumps(config, ensure_ascii=False, indent=2) + "\n", mode=0o600)
try:
os.chmod(out, 0o600)
except OSError:
pass
result = subprocess.run(
["systemctl", "restart", service],
text=True,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
timeout=20,
check=False,
)
if result.returncode != 0:
detail = (result.stderr or result.stdout or "").strip()
raise RuntimeError(f"systemctl restart {service} failed: {detail}")
return {"config": str(out), "service": service, "routers": len(rows)}
def restart_vps_xray():
service = os.environ.get("OWRT_REMOTE_XRAY_SERVICE", "owrt-remote-xray")
result = subprocess.run(
["systemctl", "restart", service],
text=True,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
timeout=20,
check=False,
)
if result.returncode != 0:
detail = (result.stderr or result.stdout or "").strip()
raise RuntimeError(f"systemctl restart {service} failed: {detail}")
return {"service": service}
def active_ssh_http_sessions(router_id=None):
with SSH_HTTP_LOCK:
sessions = list(SSH_HTTP_SESSIONS.values())
count = 0
for session in sessions:
if is_vps_terminal_id(session.get("router_id")):
continue
if router_id and str(session.get("router_id") or "") != str(router_id):
continue
with session.get("lock", threading.Lock()):
alive = bool(session.get("alive"))
if alive:
count += 1
return count
def maybe_restart_vps_xray_after_wan_reconnect(router_id):
if str(os.environ.get("OWRT_REMOTE_RESTART_XRAY_ON_WAN_RECONNECT", "1")).lower() in {"0", "no", "false", "off"}:
return {"skipped": "disabled"}
active_sessions = active_ssh_http_sessions(router_id)
if active_sessions:
return {"skipped": "active-ssh-terminal", "active_sessions": active_sessions}
cooldown = int(os.environ.get("OWRT_REMOTE_WAN_RECONNECT_XRAY_COOLDOWN", "90"))
now = now_ts()
last = 0
try:
data = json.loads(XRAY_WAN_RECONNECT_FILE.read_text(encoding="utf-8"))
last = int(data.get("ts") or 0)
except Exception:
pass
if now - last < cooldown:
return {"skipped": "cooldown", "remaining": cooldown - (now - last)}
result = restart_vps_xray()
XRAY_WAN_RECONNECT_FILE.parent.mkdir(parents=True, exist_ok=True)
atomic_write_text(
XRAY_WAN_RECONNECT_FILE,
json.dumps({"ts": now, "router_id": router_id, "result": result}, ensure_ascii=False) + "\n",
mode=0o600,
)
result["reason"] = "wan-reconnect"
return result
def build_openwrt_config_payload(row, hub_url, vps_host_override="", public_url_override=""):
reverse_tag = row_str_value(row, "reverse_tag", "reverse-in")
ssh_reverse_tag = row_str_value(row, "ssh_reverse_tag", "") or f"{reverse_tag}-ssh"
ssh_host = row_str_value(row, "ssh_host", "127.0.0.1")
admin_host = row_str_value(row, "admin_host", "127.0.0.1")
effective_public_url = str(public_url_override or row_str_value(row, "public_url", "")).strip()
effective_vps_host = str(vps_host_override or row_str_value(row, "vps_host", "")).strip()
if not effective_vps_host:
effective_vps_host = vps_host_name(effective_public_url) or vps_host_name(hub_url) or "127.0.0.1"
payload = {
"id": row_str_value(row, "id"),
"name": row_str_value(row, "name"),
"role": row_str_value(row, "role", "node"),
"hub_url": str(hub_url or ""),
"vps_host": effective_vps_host,
"vps_host_mode": router_reported_connection(row, legacy_mode="manual")[0],
"vps_port": row_int_value(row, "vless_port", DEFAULT_VLESS_PORT),
"vless_uuid": row_str_value(row, "vless_uuid"),
"vless_encryption": row_str_value(row, "vless_encryption", "none"),
"vless_flow": row_str_value(row, "vless_flow", ""),
"reverse_tag": reverse_tag,
"ssh_vless_uuid": row_str_value(row, "ssh_vless_uuid"),
"ssh_reverse_tag": ssh_reverse_tag,
"admin_host": admin_host,
"admin_port": row_int_value(row, "admin_port", 80),
"ssh_host": ssh_host,
"ssh_port": normalize_internal_ssh_port(
row_int_value(row, "ssh_port", 22),
row_int_value(row, "entry_port", 0),
row_int_value(row, "ssh_entry_port", 0),
),
"public_url": effective_public_url,
}
return payload
def build_openwrt_config_lines(payload, mode="manual"):
lines = [
"owrt_saved_host=\"$(uci -q get owrtremote.main.vps_host 2>/dev/null || true)\"",
"owrt_saved_mode=\"$(uci -q get owrtremote.main.vps_host_mode 2>/dev/null || echo manual)\"",
"uci -q get owrtremote.main >/dev/null 2>&1 || uci set owrtremote.main=remote",
"uci set owrtremote.main.enabled='1'",
f"uci set owrtremote.main.router_id='{sh_quote(payload['id'])}'",
f"uci set owrtremote.main.router_name='{sh_quote(payload['name'])}'",
f"uci set owrtremote.main.role='{sh_quote(payload['role'])}'",
f"uci set owrtremote.main.hub_url='{sh_quote(payload['hub_url'])}'",
f"uci set owrtremote.main.hub_token='{sh_quote(agent_token())}'",
"uci set owrtremote.main.heartbeat_interval='30'",
"uci set owrtremote.main.xray_bin='/usr/bin/xray'",
"uci set owrtremote.main.xray_config='/etc/xray/owrt-remote-client.json'",
"if [ \"$owrt_saved_mode\" = auto ] || [ -z \"$owrt_saved_host\" ]; then",
f" uci set owrtremote.main.vps_host='{sh_quote(payload['vps_host'])}'",
f" uci set owrtremote.main.vps_host_mode='{sh_quote(payload.get('vps_host_mode', 'manual'))}'",
"else",
" uci set owrtremote.main.vps_host_mode='manual'",
"fi",
f"uci set owrtremote.main.vps_port='{payload['vps_port']}'",
f"uci set owrtremote.main.vless_uuid='{sh_quote(payload['vless_uuid'])}'",
f"uci set owrtremote.main.vless_encryption='{sh_quote(payload['vless_encryption'])}'",
f"uci set owrtremote.main.vless_flow='{sh_quote(payload['vless_flow'])}'",
f"uci set owrtremote.main.reverse_tag='{sh_quote(payload['reverse_tag'])}'",
f"uci set owrtremote.main.ssh_vless_uuid='{sh_quote(payload['ssh_vless_uuid'])}'",
f"uci set owrtremote.main.ssh_reverse_tag='{sh_quote(payload['ssh_reverse_tag'])}'",
f"uci set owrtremote.main.admin_host='{sh_quote(payload['admin_host'])}'",
f"uci set owrtremote.main.admin_port='{payload['admin_port']}'",
f"uci set owrtremote.main.ssh_host='{sh_quote(payload['ssh_host'])}'",
f"uci set owrtremote.main.ssh_port='{payload['ssh_port']}'",
f"uci set owrtremote.main.public_url='{sh_quote(payload['public_url'])}'",
"uci commit owrtremote",
"owrt-remote render-client",
"/etc/init.d/owrt-remote enable",
]
if mode == "ssh-apply":
lines.extend(
[
"owrt-remote heartbeat rebind >/dev/null 2>&1 || true",
"( sleep 1; /etc/init.d/owrt-remote restart >/dev/null 2>&1 ) >/dev/null 2>&1 &",
"echo 'owrt-remote rebind applied'",
]
)
else:
lines.extend(
[
"/etc/init.d/owrt-remote restart",
"owrt-remote heartbeat",
]
)
return lines
def make_openwrt_config(row, hub_url, vps_host_override="", public_url_override=""):
payload = build_openwrt_config_payload(
row,
hub_url,
vps_host_override=vps_host_override,
public_url_override=public_url_override,
)
lines = build_openwrt_config_lines(payload, mode="manual")
return "\n".join(lines) + "\n"
def make_openwrt_ssh_apply_script(row, hub_url, vps_host_override="", public_url_override=""):
payload = build_openwrt_config_payload(
row,
hub_url,
vps_host_override=vps_host_override,
public_url_override=public_url_override,
)
lines = ["set -eu"] + build_openwrt_config_lines(payload, mode="ssh-apply")
return "\n".join(lines) + "\n"
def sh_quote(value):
return str(value).replace("'", "'\"'\"'")
def parse_cookies(header):
cookies = {}
for chunk in (header or "").split(";"):
if "=" in chunk:
key, value = chunk.split("=", 1)
cookies[key.strip()] = value.strip()
return cookies
def clean_forward_cookie(cookie_header):
parts = []
for chunk in (cookie_header or "").split(";"):
if not chunk.strip():
continue
if (
chunk.strip().startswith("owrt_remote_admin=")
or chunk.strip().startswith(f"{SESSION_COOKIE}=")
or chunk.strip().startswith(f"{ROUTER_COOKIE}=")
):
continue
parts.append(chunk.strip())
return "; ".join(parts)
def current_router_cookie(router_id):
return f"{ROUTER_COOKIE}={urllib.parse.quote(router_id)}; HttpOnly; SameSite=Lax; Path=/"
def is_vps_terminal_id(router_id):
return router_id == VPS_TERMINAL_ID
def vps_terminal_row():
return {"id": VPS_TERMINAL_ID, "name": "VPS"}
def vps_terminal_commands(host):
host = (host or "").strip() or "YOUR_VPS_IP"
return [
{
"title": "Обновить Hub",
"note": "Свежий hub.py из GitHub; обновление уходит в отдельный systemd-run",
"command": f'u=owrt-remote-selfupdate-$(date +%s); systemd-run --unit=\"$u\" --collect /bin/sh -lc \'v=$(date +%s); curl -fsSL -o /opt/owrt-remote/owrt-remote-hub.py \"{RAW_REPO_BASE}/vps/owrt-remote-hub.py?v=$v\" && chmod +x /opt/owrt-remote/owrt-remote-hub.py && systemctl restart owrt-remote\' && echo \"$u started; reopen VPS terminal in 3-5 sec\"',
},
{
"title": "Статус Hub",
"note": "Проверка сервиса owrt-remote",
"command": "systemctl status owrt-remote --no-pager -l",
},
{
"title": "Логи Hub",
"note": "Последние строки journald по Hub",
"command": "journalctl -u owrt-remote -n 80 --no-pager -l",
},
{
"title": "Проверка портов",
"note": "Слушают ли 80/443/8088/8443",
"command": "ss -lntp | grep -E ':(80|443|8088|8443)'",
},
{
"title": "Health Hub",
"note": "Локальная health-проверка Hub",
"command": "curl -sS http://127.0.0.1:8088/health",
},
{
"title": "Включить HTTPS",
"note": "Обновить https-конфиг из репо для текущего host",
"command": f'curl -fsSL "{RAW_REPO_BASE}/vps/enable-https.sh?v=$(date +%s)" | sh -s -- {host}',
},
{
"title": "Установить VPS заново",
"note": "install-vps.sh из репо",
"command": f'curl -fsSL "{RAW_REPO_BASE}/vps/install-vps.sh?v=$(date +%s)" | sh',
},
{
"title": "Сделать тест на утечку соединений SQLite панели Hub.",
"note": "60 замеров FD, открытого hub.db и загрузки CPU каждые 10 секунд",
"command": "PID=$(pgrep -f '/opt/owrt-remote/owrt-remote-hub.py' | head -1)\n\nfor i in $(seq 1 60); do\n echo \"$(date '+%H:%M:%S') FD=$(ls /proc/$PID/fd 2>/dev/null | wc -l) HUBDB=$(ls -l /proc/$PID/fd 2>/dev/null | grep '/var/lib/owrt-remote/hub.db' | wc -l) CPU=$(ps -p $PID -o %cpu= | xargs)\"\n sleep 10\ndone",
},
]
def vps_quick_commands_html(host):
cards = []
for item in vps_terminal_commands(host):
title = html.escape(item["title"])
note = html.escape(item["note"])
command = item["command"]
safe_cmd = html.escape(command, quote=True)
preview = html.escape(command)
cards.append(
f"""
{title}{note}
{preview}
""".strip()
)
joined = "\n".join(cards)
return f"""
Быстрые команды
Команды взяты из репозитория luci-app-owrt-remote. Можно копировать или сразу отправлять в VPS terminal.
{joined}
""".strip()
def ssh_ws_token(secret, router_id):
return hmac.new(
secret.encode("utf-8"),
f"ssh:{router_id}".encode("utf-8"),
hashlib.sha256,
).hexdigest()
def strip_access_prefix(path, router_id):
prefix = f"/access/{urllib.parse.quote(router_id)}"
if path == prefix:
return "/"
if path.startswith(prefix + "/"):
return path[len(prefix):] or "/"
return path or "/"
def rewrite_forward_url(value, router_id, port):
if not value:
return value
parsed = urllib.parse.urlsplit(value)
path = strip_access_prefix(parsed.path, router_id)
return urllib.parse.urlunsplit(("http", f"127.0.0.1:{port}", path, parsed.query, parsed.fragment))
def ws_accept_value(key):
raw = hashlib.sha1((key + WS_GUID).encode("ascii")).digest()
return base64.b64encode(raw).decode("ascii")
def recv_exact(sock, size):
chunks = []
left = size
while left > 0:
chunk = sock.recv(left)
if not chunk:
raise ConnectionError("websocket closed")
chunks.append(chunk)
left -= len(chunk)
return b"".join(chunks)
def ws_read_frame(sock):
head = recv_exact(sock, 2)
first, second = head[0], head[1]
opcode = first & 0x0F
masked = bool(second & 0x80)
length = second & 0x7F
if length == 126:
length = struct.unpack("!H", recv_exact(sock, 2))[0]
elif length == 127:
length = struct.unpack("!Q", recv_exact(sock, 8))[0]
mask = recv_exact(sock, 4) if masked else b""
payload = recv_exact(sock, length) if length else b""
if masked and payload:
payload = bytes(b ^ mask[i % 4] for i, b in enumerate(payload))
return opcode, payload
def ws_send_frame(sock, payload, opcode=1):
if isinstance(payload, str):
payload = payload.encode("utf-8", errors="replace")
length = len(payload)
if length < 126:
head = struct.pack("!BB", 0x80 | opcode, length)
elif length < 65536:
head = struct.pack("!BBH", 0x80 | opcode, 126, length)
else:
head = struct.pack("!BBQ", 0x80 | opcode, 127, length)
sock.sendall(head + payload)
def set_pty_size(fd, rows, cols):
try:
rows = max(8, min(80, int(rows or 24)))
cols = max(20, min(260, int(cols or 80)))
except Exception:
return False
try:
import fcntl
import termios
fcntl.ioctl(fd, termios.TIOCSWINSZ, struct.pack("HHHH", rows, cols, 0, 0))
return True
except Exception:
return False
def write_pty_all(fd, data, timeout=10.0, chunk_size=1024):
if isinstance(data, str):
data = data.encode("utf-8", errors="replace")
view = memoryview(data or b"")
total = 0
deadline = time.monotonic() + timeout
while total < len(view):
remaining = deadline - time.monotonic()
if remaining <= 0:
raise TimeoutError("terminal input write timed out")
_, writable, _ = select.select([], [fd], [], min(1.0, remaining))
if fd not in writable:
continue
written = os.write(fd, view[total : total + chunk_size])
if written <= 0:
raise OSError("terminal input write returned 0 bytes")
total += written
return total
def parse_resize_payload(payload):
try:
message = json.loads(payload.decode("utf-8", errors="ignore"))
except Exception:
return None
if not isinstance(message, dict) or message.get("type") != "resize":
return None
return message.get("rows"), message.get("cols")
def vps_resource_widgets_html(mobile=False, resources=None):
kind = "mobile" if mobile else "desktop"
widgets = []
for key, label in (("cpu", "ЦП"), ("memory", "ОЗУ"), ("disk", "ДИСК")):
metric = (resources or {}).get(key) or {}
percent = metric.get("percent")
valid = isinstance(percent, (int, float)) and not isinstance(percent, bool) and math.isfinite(percent)
value = (f"{percent:.1f}".rstrip("0").rstrip(".").replace(".", ",") + "%") if valid else "—"
title = html.escape(label + ": " + (value if valid else "данные пока недоступны"), quote=True)
widgets.append(
f'
'
f'{label}{value}
'
)
return f'
{"".join(widgets)}
'
def hub_design_controls_html():
return '''
Дизайн
Выбор сохраняется в этом браузере.
'''
def hub_design_head():
# Apply the saved palette before the body is painted, including lite mode.
return '''''' + hub_design_runtime_script()
def hub_design_runtime_script():
"""The dashboard renderer and pointer physics shared by every Hub page."""
return r''''''
def inject_hub_appearance(path, body, content_type):
"""Add the shared design head to Hub-owned HTML responses.
Router/LuCI proxy responses deliberately stay untouched; their own CSS and
JavaScript must not inherit the Hub palette.
"""
if "text/html" not in (content_type or "").lower():
return body
request_path = str(path or "").split("?", 1)[0]
if request_path.startswith(("/access/", "/tachyon/", "/api/", "/cgi-bin/")):
return body
try:
text = body.decode("utf-8")
except (AttributeError, UnicodeDecodeError):
return body
if "owrt-hub-design-head" in text or "" not in text.lower():
return body
marker = hub_design_head()
index = text.lower().find("")
text = text[:index] + marker + text[index:]
return text.encode("utf-8")
def dashboard_html(routers, username, sessions=None, notifications=None, auth_bootstrap=None, vps_resources=None):
routers_json = json.dumps(routers, ensure_ascii=False)
sessions_json = json.dumps(sessions or [], ensure_ascii=False)
notifications_json = json.dumps(notifications or [], ensure_ascii=False)
auth_bootstrap_json = json.dumps(auth_bootstrap or {}, ensure_ascii=False)
push_bootstrap = web_push_backend_status()
push_bootstrap_json = json.dumps(
{
"ready": bool(push_bootstrap.get("ready", False)),
"publicKey": str(push_bootstrap.get("public_key", "") or ""),
"subject": str(push_bootstrap.get("subject", "") or ""),
},
ensure_ascii=False,
)
is_owner = bool((auth_bootstrap or {}).get("is_owner"))
safe_username = html.escape(username, quote=True)
return f"""
{branding_head_tags()}
{APP_NAME}
{hub_design_head()}
Обновление панели VPS
Действительно обновить панель до последней доступной сборки?
Сборка: —
Источник: —
После запуска Hub будет перезапущен, затем страница обновится автоматически.
Привязанные сервисы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. Итог команды показан отдельно и не означает, что роутер сейчас онлайн.
'''.replace('__COMMAND__', html.escape(default_command)).replace('__CSRF__', json.dumps(csrf))
def router_xray_control_html(router, csrf):
title = html.escape(str(router.get('name') or router['id']))
endpoint = json.dumps('/api/router/' + urllib.parse.quote(router['id'], safe='') + '/xray-control')
return r'''
Remote управление Xray — __TITLE__
Действия панели, 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=''):
"""Honor the Hub rename before UCI names; keep the stable ID separate."""
try:
cached_name = json.loads(row.get('status_json') or '{}').get('name')
except (ValueError, AttributeError):
cached_name = ''
for value in (row.get('custom_name'), reported_name, cached_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'}
HUB_LOG_MAINTENANCE_RESULT = Path('/var/lib/owrt-remote-log-maintenance/result.json')
# BEGIN EMBEDDED LOG MAINTENANCE
HUB_LOG_MAINTENANCE_SHA256 = '03c6a6843ed2e0b287502f165f716cb56305acc8f8798afd51f57d394862455d'
HUB_LOG_MAINTENANCE_BUNDLE = (
'eNq1PGt32zaW3/UrsEx3SzYSJbtJmpFX0+OkbpttYufYznTnOK6GJiGLY4rU8mFbcby/fe8DIMGX7KQ7nTOxCAIXwMV93ws++bdx'
'kaXjizAey/harDf5Mom/H1iW9Sop4kAG4m/vT0SUXIqVF8a5jL3Yl644lNcyFclaxpnIl1L8WlyIwMu9Cy+TIklFmhQ5dPBSfxle'
'y8wdDD5kkrsGYZan4UWRh0n8bYag0yT3cinSIoIuXhyIVCJksUySq2wobsJ8CU0wNw4ZJDBzGgbQNYyFJ3K5Wiepl26En8SL8LJI'
'PezmiqMYVnITy3Qqsk0G3aqp3DxcydTFXQ5CHJ7DSi/XXprJ8jnL9U/Yl8QB0CaCsvUySi7076WXLaOwfPxnBstUv5NssEiTlVh7'
'OXYRqvk9POouaTkpQJG31QOgKCqfYN3l7+JinSa+zLKyZVP+RHwswqiEiSsfDN7tH/92cCxmwnoi3nmxdwkHe7ERR4Dm36HTsVwl'
'cAKNY7YGbw5PTvffvp2/3z/9FQbjqm1rnKzzcXKT5qOUho1h2MikjvXGcgav9l//9uF9NShNktqo0YXnXxXr0YVcJKkcNWCMrnd2'
'dwAKTH96UAG59tIxYLEGpzESBh1/ODTmLeKHuh+cfHh72pgkuayNMrcH72DUrx9e9WPEHLosLhgjbw9+2X/992qQzP1xRZKBOQh6'
'vz96+4Z6Wx9jAf8FXhht+OfKu83CT1LsTt5xg2KgnfI1nK9+8pPVOgVS4ac4CWTkbapGa/D66PDnN7+cwEx3A+zCC2OWCcb/TIo0'
'9qLARe6qL3IUhaswz+iNNRWKxJ4K5Kqz/+Jx54MTAvTOuwUBMHs+eacafpNy/XMqsalsg04/A+WewN5mO9B6XMRIvWrszouypRz8'
'4tm7Abw+1sLhRPqzHwJvM3itNjjbyAzZfNixNf47bkqF2h67N3eKHc8HR/FrL5Jx4KUz8/d3I/ifmHw/3Z1MJ5PBvu+DTPI3uLad'
'VRgPjkHEJSvYZPATngW2TwbvZZqBYIRtzPK0kI9ecybT69CXj1n1CXc9HxzcSv8k99J8Zvws1YBSAeIRbA4iOx4cAkw4rsGboxN/'
'KYMiCuPL15EHuA8DEEOIK1AGNAlu9fsJ4qCxvfgyjG/HXSQGc66TKPQ3nXt6AlI+2pC2CUHcZ4WPUnFRRCJPvcUi9EWYif8pQpnv'
'CdAaScr6JQE9BMrJR5LJQP7irtzBylsL65siDaffoLQtMkt8g2uZ81rmHgGfo5BkTgnkwiuiXOzs0eP//jH21uE4TvIQZiYtlI1v'
'vDCfnu1+f342Gf2F//lGTGoDsmw5AuWYQf/x2R/j86fjVHrBA4OWEvB5Ib2HgLMiRjxmXT3v+STuB4MB7EZ4ORCmb6OyGpI+H4oV'
'SIzZJHkxmThTAowvtRDD307Z6oIGBQJ2V1dBmNr8kM1OgZyHQt4Cdc+TK3rkIeGCR4XZPNusgGyubDUFyTQvBFNCMfwBnp1tHctF'
'kQF5CdV/KiwgBDAneCEMdhEMReyBup6VuhBWhGyztkEmLMLbmeXiOJqcegIxuRZsOExnxj4YXJ5uqkWRKZJk7iJAA8XGqaybC8tB'
'0wCWIb1V1Rf/w67+ElBo81sXVxMntsN4dWqdVZebNMyljchHDIWwX6BG4Debz+Nik8vMETIC7GCLK2MfQNlOJ7BFVGRL22ktKtvE'
'fnNNVS/okcp15MGkiJ+hqM55EYJUjwyUwBqhO6GNzjijIU4LD0VMJ0wvFbWBFloBO9pge4GZl7OgmO3sToYCJImvaIUhgTBHVpsZ'
'xo8L0keNzfIAhxrv3r95f0DtwPZm+8npT0cfToe11TX/0ytRf2Fp8jbXdExSZGYp/FglKdOKlfWKSwUM5qAC8Wy2EvXCuiOzz/1n'
'EvJ2nPupSP3ZXQvO/Z7QjbzhsxGw5WR6fq+WwV3VAhSSU+knaWBHYLBHQHWAAzAOFFKB99FKzlZwpBrDSA1DEARAoFkuXjwTv4Wv'
'xBrISCTQVT+n8jpMoI24CyUxgotQBs+EHeSutpndOLmxHResaXj4BBDgIcwSMPlWXm5jY7YGpWBlsMo4yICTntaOZmGJszta+/15'
'yex6EyWRgokE7GsJyzmbPgOMnCNHQ5tTMgfLqBSUl42rdAPJ7W6KzsgaGZJYpS6e2DKsCSh0blQzCoN5VoCaubUttApdsFi/QJp9'
'iDNvIU2DmwxwZCWruQTFWg4RmGpDJQU7ALFK1uBTAWxMu3PEX8WL58+/f9EQXGociS4r3SK2lGDIpLyywZq0gSFJaOCETaFRzj/i'
'ORtyqKSUmYaKys3mrmVPpXe2IXZYgqqGPRFoCZJXicr8WoJLCMcqvGswlr2LSIo8ETgfGFfuNlw8fRgZYJXFoNSlPdFqBrYEWCEI'
'DI2wdDT//fjo8O3fxWd+en18sH+qH/bfvz84/Ek/HR79fPT27dHvQ8H6ddCnYrye5dU0Bp28YvpIXoLFOWfLiZTjjL0PRZJAWGCm'
'CFNqm8TKYuRnD3TMYzR1szuuBA/8jFhNMZgAnmcJAW47QcODmaNoRSJeR2FO4xrKCueugUEGwLVTY6RakRfSPEPc2dYTyzknGPIW'
'ZEsu8aDuLPKfUEooZ+kH/E2EC04J/l6FGdoWyRU+kBEHFkO+sdq6wtLuE/as+VPY4CdgQStise5NuWxrBgX9PZuJnQlthhrOQGZB'
'U+V8skX8nUvWplVbQjVotMOj7i1qzCRLt+xsZwqvaBKNA00ZBJcJI5TlqYMEB3vOX7KZRhYW2BzgzARg5GIDW7N7Iqa4jxcEwhMs'
'swWbxSi6LjGmQvAyIMhsBEINeDAQYEulIYZ2Ukk6P0GbXRFSNhUcCBjLIMyRlcMUVVESXcuADTDQiTKnaE/lKwyBxL1rXCgyv4aF'
'D6tMwlDsnoNMcPX21DnEIAqIILTtcWYRPDy40al17ijNOmDXGQNKSMl3fI5IwiT40GgMUdGCHAQ0RZGdWn88qUegqKewz/74GJ8/'
'dabfwBR6fvzlvjNYyLSp9QSo3ggNBkcAM5TWLtPLl3lPNTqCJjjZQprQkbPKGWpcZcxkkRYsBQhIBVyz3bD5ulVeyZMEqo6xTnOe'
'SACEBKCnKTXK9+S6BMEc6TFESKC1gJobCwLzXrKWmAl674ITXay1QDewYPX4fRYeeglm2hIMis/LHk24KfrrGBMFcvl4ES5m7HRw'
'Z6cDXgcKXxcZKEuFPpQO5aYBPLi6QDSwu7jw0KK7DuVNL1ZZgzKgWMoAfWOUFygacsEmmuDwnEjWOAPABNcIaDNHhSo+XMDKim+z'
'BkTtFoPrnYWrNfD6PwzXuSHh+A2Kub1/uE3LAQwAOKsSQ2co1Zo4RZnKBjTpEOXiOcQeu22UKqhPgXdQBlyAuAzq4lUdou4I/eCg'
'eghirxparNHmRdGCp1xcwBHbP66cPz5m31X9P2ZPO/f/ERFg/ziF92d/7JHA+HEPiKNG1OyH1ISBnvTfZvSuxd8ovs7KowdloUeY'
'akn1UwpiEXk5mKNzblWhALAE49khmO+VvjgGPgTnGKgR5jdj+hqeVhbyVvoFKFyK5ougSFFqY6wd/pauQ3dQAadFwxH0mkOyD5+B'
'rHAl7AFji2miIINSLzQ2kDLgN5rDO7svHwot+AUs6ZqyF5hiQNMgMLITYexHBfhyXdwUxotEy6eIzfJeu0mLTuzmnszfnBwf/GIj'
'ADSkKSiAPXRDEdLhTsw27CT+A2zGye7uQx6GPqBqH3w63dtYlHOQYfRXsftid+fZs+2THHUga8skeCIu0LVxzGSzAJH5YMuhnD87'
'HxrW5GPtxitwBUC/ZmbUgAxqcH8BqGlEKlEBDuNQ7Dhge5k8Rf1hLttahOAdcpQQ7QOQCLw9egDvuHqKvGZHkBTX0mrI9HKHuMTy'
'jYz0rKjRcQvUzeoZW2HG1Nn8lsMPLmk3NElA+Ci6BckCSyMfoQ53jSoemcyQodhtSCZSGcFzuuQujXWQQHc1WXPbmTJMGzkOMkKw'
'57ZOQa1H2wYxUyaW80itCb52scZ8WD9PmwTS2C13q+QTL63eyV+GUZCyvKJ5bDXMBVs4xYCo4zCHqdZsTo0sx85Uc129IekTXKRH'
'PUF7wxR9gpcVTMzAGrYGaJb//fzRhT8X3tXnJAo+g8Am2/xzsL66HLlPP6frVSxv8E/mgS3ioLnKQDvCeb0WZHNFeL4q7UVeS80t'
'/VKgxOaut0YutxtqimZjPWUcHqK2PkkNBnvMpVBinjXkUhlztCyOzrHvNjA4gLuQhpk8e/n8hxfbZeXbhoQE5eiT5bUj3oWvuqJ4'
'KpJVBvNUokvvO0uK1De0MsVD0FsDReaDoMzlOCvG9Xy6TqAL8sNKkGINyhrdvk+e8uIo3C6FB1bSZYExnGwDTtUtHaX2ysBXyhCW'
'Nmu0wejFG05LYi6eoL2JialDv4i8dAjCAvzBizCn1L3KYrHLhI6eSvQKH03SGEsJfHD44mJdd+hg9jUGaNdIDGkMm1tStGcoLqLE'
'v1K6pPr/oJKkQ5iHVq4kap/KYQw/RtGQ7FjLprIxRTVPWSdJpZ/06H7d1C3u/4Xqql9llWqruZBtGmyLFuveWoVQinG0oT0RIMtA'
'4oHDsxFACGW9SYssp0DnRMx5wpSEoQIQkS2QFMafb1mmpo8QK0oA70Ro3ZJMnSz2fNjyaKDiX3ysPdttHfKX2ShfjEgzd6L6boHY'
'pxgq71obPmD3gLJj4visVKvDJhCexhaEdElthjPWZoCSGyjsWFxWjrcXrMIYfSEvJxWM/rfltCZjseWCCYtqiCiot5PSVaocBLTB'
'PSY22hqXFlXJPSXTzs7bPNvgMtu6o7hGyW1Jaggjw/q6/5PWFi+NdUjpGtA0TmORWUdshUa3Nfe2YBbrgr79gDkJ5PCt9S3wyret'
'rfHY/vkwSsR4w3ft5erYgmE9MEin01hSvcFCBkTiiZBVvYNrL98p0XHHooNMY5Ip3cT80LmEMWm46niYljtIS6v6uo/Qs6zJ+VbH'
'QUtPhonoU9CnfVyN1Mp96q6ADqNwMNJyXToMMtC5u+OSof5lrF5WGCB3q0W2dQnSrpqkHWBSpojmbrW/h4RAH3Foe6Y0VtCQabiP'
'TXapS46KdmssoQAiczTkbhde3sSY4ohkLltevgre1o1XTfO8FKey0HShCSvqOToXNufuhmjsBSGGp+pZqrLZJACvGTNtZaE4gYih'
'fj3+DC12PfDcXO5FkkQ2RvOLKNI6BMNx7sfgKThO6DGdjdzzj8Hdy3toV7+fDV/cOz861BH+ufz0+fbT54tPu58/Zbnj/AgMwWtw'
'dPIFrfA5pSjLzAs2kZSgIFdpfXLMMwHTWBO1NcYSBkwwa3dy2gwClIPIZwNvMAgvgTWdB8L+tQqXMs3B1ke1jrGwFkH39L2AKuVE'
'8bFF4BrBsRY/ECYoNFTGwwJ5PSxjUoA4pz0UPSjQZFg4eJjkP2PRMtFs90rWXlaFqx83tByiaIXXqU50nRaxnGuzUxHXHF1I8EXk'
'SgLvx/5mprRxnNxQFHWogJghVXiHFUtYM4H/cMATG2vxTmiok02NpKgYh9/URqkl8ybQJARXeZFKAjAZiklJdmUWXccwkCo56MEJ'
'3DUVXRu7dNpkyK+rtJAoAbcCoaq5THSh0vM6kistmqXIiObrak26Aq2HSPUC28LH5TqnStT0RD06bVBF3tXgqIPMy+TaY8K+VCtF'
'FsBjl8DQS4pTafIbMarCxlTD/p8z8fLFs8nk8XD7mRHxzqT1SGgRICfLH4Mqm7uW01aPMLH5SLuaxxyF7F3qsI4F7P/IJVcrVQVs'
'DrqdVHV6LdNwEQIT+VGSwR8tBYY6S87MhKWXbiPDRDyISaiduuAlnoRmMwxfjwmZ3KtkUBBmV3OqkSq1Shm5UvY/sa5Kj7DdWxpQ'
'pndYYFkV2Xl49cAlwNRmBMXY735H1QLBYsp2ORbRYgwHVr+g2x/EZZK5zSzGQbOKylXMgpyyxzwHwyLCLBVO6haI1afqAXdc5ctl'
'6gOfCyyimIjvzP7jFjggp2YTSUUYWgIk9KGt/vr4zemb1/tvLUreqGn+Kv4y4THW7/vHh413PzxX745+swxzhOr0lA2m0mhqzJCn'
'c/qL9lQ8bM51yPpUEbW69AC8UuO6AFas6DKGNNtkeK5Y3sJV4yNdxG/V7CVFIlUlBHf38wjHhtmICdjictpzXZRJuqyiBS6qW1h3'
'2Ol+2qhQ1D4KVijy1q69iPhprhalI5lqaXKxkMoczCTFMqj8AhZktUJzzZUHIw8Abj4RPnwvHzFoAxP16wxVuUet/mjarDvoi+bh'
'65pTctZK+JRbwL71jE/5DqiuvC5hlfVNTeBY1wQb2QNPlfpYM3J42mnfK7kZIpYLqabVHtqMPLS6q62xfQaj9BYxTUzja3tGxBug'
'Yeo7y7zbYYFbpCqp6jc8+AW+6fPErMYVDhyBtzgQlr7IgW0bmVn3qNtXWcP6Lffhgq9lwzJJHdBKHy5K2Y/5PoCmjUYZT3XfDN0+'
'gI1BmL3OUI8OBAUltWOJMmDOl4ptlGPDV7MWfpxH1EDXnFTdvCq4/2EyQa/pgRr64w+HXzOMigxtvCcFZj0KcDDsuRTS40rDelCz'
'7SHgyt0F9rLxn6FqeXv0+rf5wX+Lz+bz4SunaXK/wkHgZr856jK4SaIAUVR1sV6ESV+6bxLDsD2RXVE8pxGtYFFaLTsBIsICEq5H'
'dum5VoDsGMF7b7WGvnzhbMzB1BE6rat1bjVNXDpSFaOGcfXyXG6qZalV7SKwOq2hc78/YYGiUDOWO16Bv74nMHINexejEc9MZa1w'
'KlSxgxjcjogn4nfUuTo3c5OkV1MBKgjvT6rCeOGnXrZEc4ddbkr86BI/qp3EBbjNil3a61BhWhVd95MNM1YVDKBimUZGq5HY60wh'
'N9xAT1d1ndVcFZ5ElQ3wfKULg7c3XfzHVu+cRqC0NKRnmMqyK23/8jlBmRvafM5lYYYVVl+fQvus3qflcnfZCJRhoOFd1WZmZf/C'
'UtPcIRxUxArS1N1Z3P87klCTXXTVtRYDNRwP1Wk1w6xa5ZbdqXRyFMiLAjUtVnt0A3TOnS4ruPJEO31p04sufzVr2E7QKEJbCS+p'
'4S2MjCuSkipYNWRbFJntmmNXq7XUla55IxHUu0u8zYUsOKJBI5Kc9ILY8oHtG1dcnk8mfXhVWkhZYaORmt4Y/aIx9trzi2JVs+Sa'
'QLjLCCHMdoJaG7oYM9RstrUDSpq0aUn8bNeiWm+e3gpIDbaLZUJff3KGI4Twun2h0gcqyXaB+eBt3FTatlj2vQHTgeQT7Dq5ggfW'
'ipZe7lytwpqWJNljqFh098roT2sEUOX2oK383QuF1k2bgO70F0As0JhYymDu5bjeKgx038WypZZSxjbeOIdTxT9uUKzWWVmY0JTJ'
'huBAfwXlho7sBnuiiRO8hEQ/7vdEbfOzO9o7NFeHfFf+xItKTF7lRaXn5j2lx0g9QszDQo+JYYvM26u+S4DKGZpSakFTBNN5TaHI'
'2riflfD0RuRvmu5Ds2xI2TkH9AetSBBJ0Db9usPsJGMVU7RY/09J9MAUTnkpbPvhHxwfHx1baB36TttErgJtzft++F+fiNMxEnWV'
'orI5lVcbe+tsmeS2io9y4b+yifnha4xZOKhwIaFVFZEyJFyffsMo1TmFWv+O6y/6PYCiM4gSL8js+ijDuuNF1LMwBog7C6Og6L9g'
'5saiO+ZzdTMCGvu9b91naOKZhlsNX7xBhd2CR82sfPrpY9z+L5yXJdVVnNyQz45+2plFt9nOaxUTGjlnCjPn960YFRFI9/WIeiSq'
'diECBtLsD19z2HKb6cHMINnedO9w6zVkmgl3jCRAWJhWXZBtie6gsUaF6v6Q6ov5qha2HEMl6K20ibhZltwVZsW6FK4HZ4bTsel3'
'Rz8d1GPTQ1GEwcwoSh6KS6MBfndaliUnMi3Qzs6HRhUv6RRTbrZ2qyNoVLYxMGDX+LEmLfWbMu0GchV8dGnX5E03l9t9wsNps3wP'
'B8Fc607mqeIovZzQTfImJ9XLyeiFoqTzTuXC2Ok+Cad2CEP1Dg/cOm9dGfeXwFkKHHcEMsDT5IdLfNhWeUmH3qcftqAz8MDiiEep'
'xAPSU/T0xYP20rwz9Hle5sBVdPtmGfpLW8VNDc7puhmWNxD/GOHJo5sis7rNjdGAybTHC2hsi/ZewXSaquysoVfOVZmW0jKDBybg'
'jluItn6cfSfFNcVbwHSsWOGLF6yV00MzlafcPw867TUNNKMSS/vXD6+c7TzoPDi9QWZmEP7cvGVuva4FEZUIClyxr0NZtO5gHEiy'
'vavSRRWCuZDVoDKcSN+CiCJ7WVzMy8yUSikzi8/4u0tGxoDv31AChvIGNZe2bt3WkdyIqbcTvTVGqqZ5hDJ9xwJAUI3i/xQh3hdl'
'LWqAGXwBs7U+iPOArcKoqMbTLw/jAdYDt/Z/9/hyHF08VfHI9gfGdEEzGAvs2VU3+rkevh4ypAvNfcXxW24BbvuGFCyyiMH9qV0G'
'NCPUKlD41eE3LCcy6bCVNyHlVevidF7f9EDJ0sfX7NYFN+vo9+PT+fHBu6PTg/mvp6fv5z8dvPrwi0UY60x/dGELv05XVQsECXAZ'
'RTnBMvTCmD9gB7ApO7kIby2ncf03CP3cVt/JcgZ9HNClSgiCu07W9hde1e2WuwxO2WzNq9zVh3jo8v13qjsHpcwvuTncpL4IgB/L'
'sM+0bDxvHau6oKKkW48P1/5UztdZR/WoAB4QRl3D8lJhO/vTsnXUIPqowrNnrW9MmIgYMonOqVBlPm/aQ+CAPn9eI8etF1gUY9fq'
'BKJABAXeqG3Vy+mAJNNcZEQg+/nK2Aac1bCfwfq2oAPw8/+HyPtXpp7agWedEe6LO3ekER4fhK4DN6OYWyMbjWFbDdcvNV67+tdS'
'11RYsulWa9tZpze5XnOYtwutR9nA/1o7+Mtt4T/nFDzMdV9lCdavQiylFyG78rdC3Wzp7T5/gXxcd4XdpbwNwksAbPrFTwR9QI9U'
'1br8VCDFiVO+x8WBUPyYEHB2JL2MbsGklMkFq1Mg6aoaQAboq+8VUiKQqmz5u3g3qD/D1UoGIaCB835kpIBFqtKuGM28KLKN+6cd'
'C8NgfkWapIqlKM3S6vf26Jf5u/03h6cHh/uHrw/mWqAf/aaVZiP2Wqt5MQMBdQtLf5TMPCw0mvC7fPW8fZFGeIJoSgHAAaPzMMFU'
'6u1GyPg6TJMYK+BBkmRLGUXiJowCH7+mIm/XXpzR92mPKYFL9AOeOX2kMFIY9aOQq5vqM7kXBcCZU8ldajfevcfJf4UziODd3b1T'
'RRt0Shkpw4svpb3z3NmS26faAF6BqglY5vl6Oh7v7P7gTuB/O9OXk5cvx4yiH2E/MhqxSTLbsao01fdUSAAoXydx14UOCsIbwRdb'
'd+28IUGfusPiDgx+s9FcNeljsijFrp967kXUU+OKWOyjE7IVh+JvWDRCv52eOmD9iTg3i6Rc26qkps/uZDSpz8MtvBA/iMO8qoWH'
'du6Qd+3yI4tpRkku/V1idz+9LJCm3tMbO5Bctg/7nM3nQeKD+WKMxDLquaeGsKNDSQV/mYAWyWa2pVxJ/iJSFCFL0O8iVh42fgDT'
'2QJzhF+2HZXy0tralTkOqWOzlrP3/H1J/k6I8lj7P8kHHLSeNfxpbYYqTyzMtGtMr8fljrYuSidtGTszi4TDHD+/ag3VrAf6cyil'
'FwX8sqcKIlj6crFnwZ+3DjM1JX7Ij2KvNDP9wbmz6ssQSYbEK4sw4LrniRn8o1FSRZ4LSh9hUWXlRSIslxfOvmzXeZoue7Pk6E+a'
'cF9YQdR7PeCrK4keW0205Sq2+em9scJfu9RIFdoQy6pUaXXdxZBQ5olgMEsfyLTrrh5FcWhEzegoozj0qqmm+i/HacXWOezRa+s8'
'oK8MwfUlQr9w7e2kJNVONveDUstQ8+q7oC4xeJcn3Uzy1rYWAcFTqUSadW2QPI04Ga29S9quiiw5gz+TQW6O7k4K18InVCbf060M'
'LnEBB9gm5lcmVXnERuZWl9fdzsV3VJjXl6vS8Tx+YdXT8MYkzbpm0HywizndxJjP6Sjnc1zqfK7Os0aTrCEHvQn2Ovcre5ES3ZVZ'
'SZ3wc5+giWdw7i5/I9ZY4wbv7oU5Kvb/A/M9qWg='
)
# END EMBEDDED LOG MAINTENANCE
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_log_maintenance_payload(source=None):
"""The confirmed Hub includes its exact maintenance script: no second URL."""
digest, bundle = HUB_LOG_MAINTENANCE_SHA256, HUB_LOG_MAINTENANCE_BUNDLE
if source is not None:
values = {}
with warnings.catch_warnings():
warnings.simplefilter('ignore', SyntaxWarning)
tree = ast.parse(source)
for node in tree.body:
if isinstance(node, ast.Assign) and len(node.targets) == 1 and isinstance(node.targets[0], ast.Name):
name = node.targets[0].id
if name in {'HUB_LOG_MAINTENANCE_SHA256', 'HUB_LOG_MAINTENANCE_BUNDLE'}:
values[name] = ast.literal_eval(node.value)
digest, bundle = values.get('HUB_LOG_MAINTENANCE_SHA256'), values.get('HUB_LOG_MAINTENANCE_BUNDLE')
if not isinstance(digest, str) or not re.fullmatch('[a-f0-9]{64}', digest) or not isinstance(bundle, str):
raise ValueError('В обновлении нет проверяемого скрипта обслуживания журналов.')
unpack = zlib.decompressobj()
data = unpack.decompress(base64.b64decode(bundle, validate=True), 131073)
if not unpack.eof or unpack.unused_data or not 5000 <= len(data) <= 131072:
raise ValueError('Некорректный размер скрипта обслуживания журналов.')
if hashlib.sha256(data).hexdigest() != digest:
raise ValueError('Контрольная сумма скрипта обслуживания журналов не совпала.')
compile(data, 'log-maintenance.py', 'exec', dont_inherit=True)
return data, digest
def hub_log_maintenance_directory(directory, job_id):
if not re.fullmatch('[a-f0-9]{32}', str(job_id)):
raise ValueError('Некорректный идентификатор обновления.')
return Path(directory) / ('log-maintenance-' + job_id)
def hub_log_maintenance_receipt(directory, job_id):
try:
path = hub_log_maintenance_directory(directory, job_id) / 'receipt.json'
with path.open('rb') as stream:
data = json.loads(stream.read(8193))
return data if isinstance(data, dict) else {}
except (OSError, ValueError):
return {}
def hub_log_maintenance_command(args, deadline):
remaining = deadline - time.monotonic()
if remaining <= 0:
raise RuntimeError('Истекло время настройки обслуживания журналов.')
result = subprocess.run(args, capture_output=True, text=True, errors='replace',
timeout=remaining, env={**os.environ, 'DEBIAN_FRONTEND': 'noninteractive'})
if result.returncode:
detail = ((result.stdout or '') + '\n' + (result.stderr or '')).strip()[-2000:]
raise RuntimeError('Обслуживание журналов: rc=' + str(result.returncode) + '; ' + detail)
return result
def hub_rollback_log_maintenance(directory, job_id):
stage = hub_log_maintenance_directory(directory, job_id)
if (stage / 'backup/manifest.json').is_file():
hub_log_maintenance_command([sys.executable, str(stage / 'log-maintenance.py'), 'rollback',
'--backup', str(stage / 'backup')], time.monotonic() + 45)
def hub_install_log_maintenance(directory, job_id, source=None, budget=120):
data, digest = hub_log_maintenance_payload(source)
stage = hub_log_maintenance_directory(directory, job_id)
stage.mkdir(mode=0o700, parents=True, exist_ok=True)
script, backup = stage / 'log-maintenance.py', stage / 'backup'
receipt = {'job_id': job_id, 'sha256': digest, 'status': 'installing'}
def save(status, error=''):
receipt.update(status=status, error=error[:2000], updated_at=time.time())
hub_update_write(stage / 'receipt.json', json.dumps(receipt, ensure_ascii=False).encode())
hub_update_write(script, data, 0o700)
save('installing')
deadline = time.monotonic() + budget
try:
if not shutil.which('logrotate'):
if not shutil.which('apt-get'):
raise RuntimeError('Не найден logrotate и пакетный менеджер apt-get.')
# Existing Ubuntu/Debian package indexes; never an unbounded apt update.
hub_log_maintenance_command(['apt-get', '-o', 'DPkg::Lock::Timeout=5', 'install', '-y', 'logrotate'],
min(deadline, time.monotonic() + 25))
hub_log_maintenance_command([sys.executable, str(script), 'install', '--backup', str(backup)], deadline)
hub_log_maintenance_command([sys.executable, str(script), 'run'], deadline)
result = json.loads(HUB_LOG_MAINTENANCE_RESULT.read_text())
if not result.get('ok') or result.get('day') != dt.date.today().isoformat():
raise RuntimeError('Успешное обслуживание журналов за текущие сутки не подтверждено: ' + str(result.get('error', 'нет результата'))[:500])
hub_log_maintenance_command(['systemctl', 'is-active', 'logrotate.timer'], deadline)
hub_log_maintenance_command(['systemctl', 'is-enabled', 'logrotate.timer'], deadline)
save('ready')
except Exception as exc:
reason = str(exc)
try:
hub_rollback_log_maintenance(directory, job_id)
except Exception as rollback:
reason += '; ошибка отката настроек журналов: ' + str(rollback)
save('failed', reason)
raise RuntimeError(reason) from exc
return receipt
def hub_prune_log_maintenance_backups(directory, job_id):
"""Keep this update's snapshot and one prior snapshot, never router data."""
current = hub_log_maintenance_directory(directory, job_id)
old = sorted((p for p in Path(directory).iterdir() if p != current and not p.is_symlink()
and p.is_dir() and re.fullmatch('log-maintenance-[a-f0-9]{32}', p.name)),
key=lambda p: p.stat().st_mtime, reverse=True)
for path in old[1:]:
shutil.rmtree(path)
def run_hub_log_maintenance_worker(job_id, directory=None):
directory = Path(directory or STATE_DIR / 'panel-update')
job = hub_update_state(directory)
if (job.get('id') != job_id or job.get('revision') != HUB_LOADED_REVISION
or job.get('status') not in {'restarting', 'succeeded'}):
raise RuntimeError('Задача установки обслуживания журналов устарела.')
hub_install_log_maintenance(directory, job_id, budget=40)
def hub_run_log_maintenance_unit(directory, job_id, target):
"""PID 1 launches the worker outside Hub's restricted capability set.
Keep the worker independent of Hub's service: an old updater can roll back
the Hub while this unit safely finishes restoration of logging settings.
Never chmod nginx logs or broaden the web service's capabilities.
"""
hub_log_maintenance_directory(directory, job_id) # Validate before naming a unit.
result = subprocess.run([
'systemd-run', '--quiet', '--wait', '--pipe', '--collect',
'--unit=owrt-remote-log-maintenance-' + job_id,
'--property=Type=exec', '--property=RuntimeMaxSec=100',
'--setenv=OWRT_REMOTE_STATE_DIR=' + str(STATE_DIR),
sys.executable, str(target), 'panel-log-maintenance-worker',
'--job-id', job_id, '--directory', str(directory),
], capture_output=True, text=True, errors='replace', timeout=110)
if result.returncode:
detail = ((result.stdout or '') + '\n' + (result.stderr or '')).strip()[-2000:]
raise RuntimeError('Задача обслуживания журналов: rc=' + str(result.returncode) + '; ' + detail)
receipt = hub_log_maintenance_receipt(directory, job_id)
if receipt.get('status') != 'ready' or receipt.get('sha256') != HUB_LOG_MAINTENANCE_SHA256:
raise RuntimeError('Задача обслуживания журналов не подтвердила установку: ' + str(receipt.get('error', 'нет результата'))[:1000])
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_older_version(candidate_version, installed_version):
candidate = re.fullmatch(r'v([0-9]+)', candidate_version)
installed = re.fullmatch(r'v([0-9]+)', installed_version)
return bool(candidate and installed and int(candidate[1]) < int(installed[1]))
def hub_update_require_version(data, installed_version):
version = hub_update_version(data)
if hub_update_older_version(version, installed_version):
raise ValueError('В источнике более старая версия ' + version + ', установлена '
+ installed_version + '. Понижение версии через обновление панели запрещено.')
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
maintenance_installed = 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_require_version(data, hub_update_version(previous))
hub_update_write(directory / 'previous.py', previous, 0o700)
report('installing', 'Устанавливается обслуживание журналов; проверяется очистка и таймер…')
hub_install_log_maintenance(directory, job_id, source=data)
maintenance_installed = True
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', 'Панель обновлена. Обслуживание журналов и таймер проверены. Страница будет перезагружена.')
try:
hub_prune_log_maintenance_backups(directory, job_id)
except OSError as cleanup_error:
print('Не удалось убрать старую резервную копию обслуживания журналов: ' + str(cleanup_error), file=sys.stderr)
return 0
except Exception as exc:
reason = str(exc)[:500]
if maintenance_installed:
try:
hub_rollback_log_maintenance(directory, job_id)
except Exception as rollback_exc:
reason += ' Ошибка отката настроек журналов: ' + str(rollback_exc)[:300]
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'
self.log_maintenance_status = ''
self.log_maintenance_error = ''
def resume_log_maintenance(self):
"""Bridge the first update, whose still-running worker is from old Hub.
That worker waits for the new Hub's revision health. Hold only that
health confirmation until installation finishes; heartbeat stays live.
New workers install the component beforehand and already have a receipt.
"""
if self.log_maintenance_status:
return
job = hub_update_state(self.directory)
if (job.get('status') not in {'restarting', 'succeeded'} or job.get('revision') != HUB_LOADED_REVISION
or time.time() - job.get('started_at', 0) > 420):
return
receipt = hub_log_maintenance_receipt(self.directory, job.get('id'))
if receipt.get('status') == 'ready' and receipt.get('sha256') == HUB_LOG_MAINTENANCE_SHA256:
return
self.log_maintenance_status = 'installing'
def install():
try:
# Hub has only CAP_NET_BIND_SERVICE. Provision via PID 1, like
# the regular updater, so nginx tests/rotation have root caps.
hub_run_log_maintenance_unit(self.directory, job['id'], self.target)
self.log_maintenance_status = 'ready'
try:
hub_prune_log_maintenance_backups(self.directory, job['id'])
except OSError as cleanup_error:
print('Не удалось убрать старую резервную копию обслуживания журналов: ' + str(cleanup_error), file=sys.stderr)
except Exception as exc:
self.log_maintenance_error = str(exc)[:2000]
self.log_maintenance_status = 'failed'
print('Ошибка установки обслуживания журналов при обновлении: ' + str(exc), file=sys.stderr)
try:
threading.Thread(target=install, name='owrt-log-maintenance-bootstrap', daemon=True).start()
except Exception as exc:
self.log_maintenance_error = str(exc)[:2000]
self.log_maintenance_status = 'failed'
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)
hub_log_maintenance_payload(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('revision') == HUB_LOADED_REVISION:
if self.log_maintenance_status == 'installing':
job = {**job, 'status': 'installing', 'message': 'Настраивается обслуживание журналов; ожидается проверка очистки и таймера…'}
elif self.log_maintenance_status == 'failed':
job = {**job, 'status': 'failed', 'message': 'Обслуживание журналов не установлено: ' + self.log_maintenance_error}
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
source_older = hub_update_older_version(self.remote_version, HUB_LOADED_VERSION)
return {'checking': self.checking, 'error': self.error, 'source': self.source,
'current_revision': revision, 'current_version': HUB_LOADED_VERSION,
'remote_revision': self.remote_revision, 'source_older': source_older,
'remote_version': self.remote_version, 'checked': bool(self.checked_at),
'available': bool(self.remote_revision and self.remote_revision != revision and not source_older),
'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 self.log_maintenance_status == 'installing':
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)
hub_update_require_version(self.candidate, HUB_LOADED_VERSION)
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.xray_control_csrf = secrets.token_urlsafe(32)
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):
# Only suppress ordinary successful access records. Application errors,
# audit events and 4xx/5xx responses must still reach stderr/journald.
path = urllib.parse.urlsplit(str(getattr(self, "path", "") or "")).path
status = 0
if fmt == '"%s" %s %s' and len(args) == 3:
try:
status = int(str(args[1]))
except (TypeError, ValueError):
status = 0
quiet = (
path == "/api/notifications/wait"
or path in ("/api/heartbeat", "/api/router-logs")
or re.fullmatch(r"/api/ssh-session/[^/]+/read", path or "")
)
debug = os.environ.get("OWRT_REMOTE_HTTP_DEBUG", "").lower() in ("1", "true", "yes")
if quiet and 200 <= status < 400 and not debug:
return
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):
body = inject_hub_appearance(getattr(self, "path", ""), body, content_type)
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, extra_headers=None):
body = json.dumps(payload, ensure_ascii=False, separators=(",", ":")).encode("utf-8")
self.send_bytes(status, body, "application/json; charset=utf-8", extra_headers=extra_headers)
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_xray_control_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_xray_control_html(row_to_router(row), self.app.xray_control_csrf).encode(), 'text/html; charset=utf-8')
def router_xray_control_api(self, router_id):
if not self.require_router_access(router_id, 'G', json_mode=True):
return
try:
payload = None
if self.command == 'POST':
if (not secrets.compare_digest(self.headers.get('X-Xray-Control-CSRF', ''), self.app.xray_control_csrf)
or 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 not 0 < int(length) <= 1024
or 'application/json' not in self.headers.get('Content-Type', '')):
self.send_json(400, {'ok': False, 'error': 'Ожидается небольшой запрос JSON.'})
return
payload = self.read_payload()
if not isinstance(payload, dict):
raise ValueError('Ожидается объект JSON.')
with self.app.conn() as conn:
if payload is not None:
if payload.get('action') == 'clear_history':
xray_control_clear_history(conn, router_id)
else:
xray_control_enqueue(conn, router_id, payload.get('action'), payload.get('request_id'))
snapshot = xray_control_snapshot(conn, router_id)
self.send_json(200, snapshot)
except ValueError as exc:
self.send_json(400, {'ok': False, 'error': str(exc)})
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:
rows = [dict(row) for row in list_router_rows(conn)]
routers = [router_update_status(row) for row in rows]
if job:
# A queue may predate a rename, including an in-flight SSH probe.
# Overlay current Hub names on the copy without altering its results.
custom_names = {row['id']: router_update_name(row) for row in rows if row.get('custom_name')}
for item in job['items']:
if item['id'] in custom_names:
item['name'] = custom_names[item['id']]
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
maintenance = self.app.hub_update
if maintenance.log_maintenance_status in {'installing', 'failed'}:
result['ok'] = False
result['log_maintenance'] = {'status': maintenance.log_maintenance_status,
'error': maintenance.log_maintenance_error}
if self.query().get("request-load-fix") == ["1"]:
result["notification_wait"] = notification_wait_metrics()
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("/tachyon/"):
self.proxy_access(path, tachyon=True)
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()
key = notification_wait_context(
self.current_session_token(),
query.get("client_id", [""])[0],
self.client_ip(),
)
if not claim_notification_wait(key):
self.send_json(
429,
{
"ok": False,
"busy": True,
"notifications": [],
"serial": latest_notification_serial(),
"error": "для этого клиента уже выполняется long-poll",
},
extra_headers=[("Retry-After", "5")],
)
return
try:
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(),
},
)
finally:
release_notification_wait(key)
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
control_match = re.fullmatch(r'/api/router/([^/]+)/xray-control', path)
if control_match:
self.router_xray_control_api(urllib.parse.unquote(control_match[1]))
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('/xray-control'):
self.router_xray_control_page(self.router_id_from_path('/router/'))
return
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
control_match = re.fullmatch(r'/api/router/([^/]+)/xray-control', path)
if control_match:
self.router_xray_control_api(urllib.parse.unquote(control_match[1]))
return
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)
xray_command = xray_control_exchange(conn, router['id'], 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_command": xray_command,
"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("/tachyon/"):
self.proxy_access(path, tachyon=True)
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 do_PUT(self):
path = self.parsed().path
if path.startswith('/tachyon/'):
self.proxy_access(path, tachyon=True)
else:
self.send_text(405, 'Method not allowed')
do_PATCH = do_PUT
do_DELETE = do_PUT
def proxy_access(self, path, tachyon=False):
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
if tachyon and self.command not in ('GET', 'HEAD', 'OPTIONS'):
origin = self.headers.get('Origin') or self.headers.get('Referer', '')
parsed_origin = urllib.parse.urlsplit(origin)
if not origin or f'{parsed_origin.scheme}://{parsed_origin.netloc}' != self.request_origin():
self.send_text(403, 'Недопустимый источник запроса Tachyon.')
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)
prefix = f"/{'tachyon' if tachyon else 'access'}/{urllib.parse.quote(router_id, safe='')}"
if tachyon:
integration = router_tachyon(row)
if not integration.get('installed'):
self.send_text(404, 'Tachyon не обнаружен на этом роутере.')
return
if integration.get('mode') == 'standalone':
port = int(row['tachyon_entry_port'] or 0)
elif rest == '/':
self.redirect(f"/access/{urllib.parse.quote(router_id, safe='')}/cgi-bin/luci/admin/services/tachyon")
return
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(('tachyon:' if tachyon else '') + 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", "DELETE") 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":
if tachyon:
parsed = urllib.parse.urlsplit(value)
ref_path = parsed.path.removeprefix(prefix)
value = urllib.parse.urlunsplit(('http', f'127.0.0.1:{port}', ref_path or '/', parsed.query, ''))
else:
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"] = prefix
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 = []
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, prefix + '/' if tachyon else "/")
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 and not tachyon:
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)
if prefix.startswith('/tachyon/'):
# Match only the beginning of a quoted URL. Replacing every /login
# would corrupt /api/login, and replacing every /api can corrupt IDs.
text = re.sub(r"""(["'])(/(?:api|login|assets|favicon[.]ico|cgi-bin/cgi-exec|cgi-bin/cgi-download))(?=[/?#"'\\])""",
lambda m: m[1] + prefix + m[2], text)
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.