maenekoandClaude Sonnet 5.5
e9df363dd2
Baseline TypeScript version before the Go rewrite: CAKE fair sharing with automatic deprioritisation of heavy devices, per-key priority, /metrics with a metrics token, the built-in Prometheus install/remove, the Monitor tab, grouped sidebar tabs and the dead-peer audit. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
1166 lines
78 KiB
TypeScript
1166 lines
78 KiB
TypeScript
// Copyright (c) 2026 Ivan Vasilev
|
||
// This source code is licensed under the MIT license found in the
|
||
// LICENSE file in the root directory of this source tree.
|
||
//
|
||
// sen://-подписка: реестр мастер-ключей/устройств (ui.db), админ-роуты панели
|
||
// (/ui/masterkeys, /ui/devices, за JWT) и публичный листенер /sub/v1/* на
|
||
// отдельном порту SUB_PORT. Протокол и формат ссылки — docs/sen-link.md.
|
||
//
|
||
// awg-ctrl про мастер-ключи ничего не знает: сюда он отдаёт только пиров по
|
||
// публичному ключу (/api/peers*) и общий профиль сервера (/api/profile).
|
||
//
|
||
// Несколько серверов. Мастер-ключ отдаёт набор серверов (master_servers): локальный
|
||
// awg-ctrl (id 0) и/или ноды. Устройство регистрирует один ключ WireGuard, и он
|
||
// становится пиром на каждом сервере набора — IP и PSK на каждом свои (device_peers).
|
||
// Нода может быть не в сети, поэтому изменения не «толкаются», а сводятся: device_peers
|
||
// хранит, какой ключ сейчас стоит на сервере, peer_tombstones — что там надо удалить,
|
||
// а reconcile() приводит сервер к нужному состоянию, как только до него можно достучаться
|
||
// (сразу при действии, при подключении ноды и раз в минуту).
|
||
//
|
||
// Каждый проход заканчивается сведением пиров панели (PUT /api/peers/sync): awg-ctrl
|
||
// получает полный список ключей, которые этой панели нужны на сервере, и снимает из её
|
||
// области всё остальное. Это страховка от пиров, чья судьба потерялась (ответ ноды не
|
||
// дошёл, устройство удалили посреди прохода). Область — id панели в owner пира
|
||
// («<panel>/m1/d2»): у ноды может быть своя панель на том же awg-ctrl, чужих не трогаем.
|
||
// Удаляем только по такому списку, никогда по времени: панель не на связи — ничего не
|
||
// происходит, неактивные устройства никто не снимает.
|
||
import crypto from "crypto";
|
||
import fs from "fs";
|
||
import http from "http";
|
||
import https from "https";
|
||
import path from "path";
|
||
import express, { Request, Response, NextFunction, Router } from "express";
|
||
import type Database from "better-sqlite3";
|
||
import {
|
||
encodeSenLink, rawPublicKey, publicKeyFromRaw, spkiPin,
|
||
signResponse, verifyRequest,
|
||
} from "./sen";
|
||
|
||
type Ctrl = (method: string, urlPath: string, body?: unknown) => Promise<{ status: number; data: any }>;
|
||
|
||
/** Что подписке нужно от реестра серверов (awg-ui/nodes.ts). */
|
||
export interface Servers {
|
||
ctrlFor(id: number): Ctrl;
|
||
exists(id: number): boolean;
|
||
isOnline(id: number): boolean;
|
||
ids(): number[];
|
||
defaultId(): number;
|
||
onOnline(cb: (id: number) => void): void;
|
||
beforeDelete(cb: (id: number, force: boolean) => Promise<{ error: string; forcible: boolean } | null>): void;
|
||
afterDelete(cb: (id: number) => void): void;
|
||
}
|
||
|
||
interface MasterRow {
|
||
id: number; uuid: string; label: string; secret: Buffer; device_limit: number;
|
||
server_id: number; created_at: number; revoked_at: number | null;
|
||
}
|
||
interface DeviceRow {
|
||
id: number; master_id: number; device_id: string; device_name: string; platform: string;
|
||
pub_key: string; auth_pub: string; created_at: number; last_seen: number | null;
|
||
rekey_requested: number; version: string;
|
||
}
|
||
interface LinkRow {
|
||
device_id: number; server_id: number; peer_pub: string | null;
|
||
ip: string | null; psk: string | null; psk_pending: number;
|
||
}
|
||
interface Profile {
|
||
name: string; endpoint: string; server_pub: string; gen: string;
|
||
dns: string[]; keepalive: string; mtu: number; awg: Record<string, string>;
|
||
}
|
||
|
||
const TS_WINDOW = 300; // секунд, ±
|
||
const DEFAULT_LIMIT = 3;
|
||
const MAX_SERVERS = 32; // серверов в одном мастер-ключе
|
||
const SYNC_EVERY = 60_000; // фоновое сведение серверов
|
||
const AUDIT_HOUR = 3_600_000;
|
||
const AUDIT_FIRST = 120_000; // первый аудит — вскоре после старта, когда ноды подключились
|
||
const B64_PUB = /^[A-Za-z0-9+/]{43}=$/;
|
||
const CLIENT_VERSION = /^[\w.+-]{1,32}$/; // версия приложения, чисто информационная
|
||
|
||
// pub_key WireGuard в пути к awg-ctrl — base64url (в обычном base64 есть «/»).
|
||
const pubParam = (pub: string) => Buffer.from(pub, "base64").toString("base64url");
|
||
|
||
// ── Простой лимитер по IP ──────────────────────────────────────────────────
|
||
// onLimited зовётся один раз за окно — на первом отказе, чтобы лог не забивало.
|
||
function makeLimiter(max: number, windowMs: number, onLimited?: (ip: string) => void) {
|
||
const hits = new Map<string, { n: number; reset: number }>();
|
||
return (ip: string): boolean => {
|
||
const now = Date.now();
|
||
const e = hits.get(ip);
|
||
if (!e || e.reset < now) { hits.set(ip, { n: 1, reset: now + windowMs }); return true; }
|
||
if (e.n >= max) {
|
||
if (e.n === max) { e.n++; onLimited?.(ip); }
|
||
return false;
|
||
}
|
||
e.n++;
|
||
return true;
|
||
};
|
||
}
|
||
|
||
export function createSub(deps: { uidb: Database.Database; servers: Servers; baseDir: string }) {
|
||
const { uidb, servers } = deps;
|
||
|
||
// ── Настройка из окружения ─────────────────────────────────────────────
|
||
const SUB_PORT = Number(process.env.SUB_PORT) || 0;
|
||
const SUB_TLS = (process.env.SUB_TLS ?? "off").toLowerCase() === "on";
|
||
// Публичный адрес панели для ссылок и endpoints. Без него — адрес локального сервера,
|
||
// а у панели без своего VPN — тот, по которому к ней пришли.
|
||
const SUB_HOST = (process.env.SUB_HOST ?? "").trim();
|
||
const file = (env: string | undefined, name: string) => env || path.join(deps.baseDir, name);
|
||
|
||
let signKey: crypto.KeyObject | null = null;
|
||
let signPub: Buffer | null = null;
|
||
try {
|
||
signKey = crypto.createPrivateKey(fs.readFileSync(file(process.env.SUB_SIGN_KEY_FILE, "sub_sign.key")));
|
||
signPub = rawPublicKey(crypto.createPublicKey(signKey));
|
||
} catch {
|
||
console.warn("sub: ключ подписи не найден — sen://-подписка отключена");
|
||
}
|
||
|
||
let tlsMaterial: { key: Buffer; cert: Buffer } | null = null;
|
||
let tlsPin: Buffer | null = null;
|
||
if (SUB_TLS) {
|
||
try {
|
||
tlsMaterial = {
|
||
key: fs.readFileSync(file(process.env.SUB_TLS_KEY_FILE, "sub_tls.key")),
|
||
cert: fs.readFileSync(file(process.env.SUB_TLS_CERT_FILE, "sub_tls.crt")),
|
||
};
|
||
tlsPin = spkiPin(tlsMaterial.cert.toString());
|
||
} catch {
|
||
console.warn("sub: SUB_TLS=on, но сертификат не найден — подписка отключена");
|
||
signKey = null;
|
||
}
|
||
}
|
||
|
||
// ── Схема ──────────────────────────────────────────────────────────────
|
||
uidb.exec(`
|
||
CREATE TABLE IF NOT EXISTS master_keys (
|
||
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
||
label TEXT NOT NULL,
|
||
secret BLOB NOT NULL UNIQUE,
|
||
device_limit INTEGER NOT NULL DEFAULT ${DEFAULT_LIMIT},
|
||
server_id INTEGER NOT NULL DEFAULT 0,
|
||
created_at INTEGER NOT NULL,
|
||
revoked_at INTEGER
|
||
);
|
||
CREATE TABLE IF NOT EXISTS devices (
|
||
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
||
master_id INTEGER NOT NULL REFERENCES master_keys(id) ON DELETE CASCADE,
|
||
device_id TEXT NOT NULL,
|
||
device_name TEXT NOT NULL DEFAULT '',
|
||
platform TEXT NOT NULL DEFAULT '',
|
||
pub_key TEXT NOT NULL UNIQUE,
|
||
auth_pub TEXT NOT NULL UNIQUE,
|
||
created_at INTEGER NOT NULL,
|
||
last_seen INTEGER,
|
||
rekey_requested INTEGER NOT NULL DEFAULT 0,
|
||
UNIQUE (master_id, device_id)
|
||
);
|
||
-- Серверы мастер-ключа. master_keys.server_id остался от времени одного сервера и
|
||
-- дальше не читается (кроме переноса ниже).
|
||
CREATE TABLE IF NOT EXISTS master_servers (
|
||
master_id INTEGER NOT NULL REFERENCES master_keys(id) ON DELETE CASCADE,
|
||
server_id INTEGER NOT NULL,
|
||
PRIMARY KEY (master_id, server_id)
|
||
);
|
||
-- Пир устройства на сервере. peer_pub — ключ, который сейчас стоит на сервере
|
||
-- (NULL — ещё не добавлен); расходится с devices.pub_key после смены ключа, пока
|
||
-- сервер не догнали. ip/psk — как их выдал awg-ctrl этого сервера.
|
||
CREATE TABLE IF NOT EXISTS device_peers (
|
||
device_id INTEGER NOT NULL REFERENCES devices(id) ON DELETE CASCADE,
|
||
server_id INTEGER NOT NULL,
|
||
peer_pub TEXT,
|
||
ip TEXT,
|
||
psk TEXT,
|
||
psk_pending INTEGER NOT NULL DEFAULT 0,
|
||
PRIMARY KEY (device_id, server_id)
|
||
);
|
||
-- Пиры, которые надо удалить с сервера, когда до него дотянемся.
|
||
CREATE TABLE IF NOT EXISTS peer_tombstones (
|
||
server_id INTEGER NOT NULL,
|
||
pub_key TEXT NOT NULL,
|
||
PRIMARY KEY (server_id, pub_key)
|
||
);
|
||
-- Последний известный профиль сервера: config собирается из него, даже когда
|
||
-- нода не в сети, — иначе сервер пропадал бы из подписки на время обрыва.
|
||
CREATE TABLE IF NOT EXISTS server_profiles (
|
||
server_id INTEGER PRIMARY KEY,
|
||
profile TEXT NOT NULL,
|
||
updated_at INTEGER NOT NULL
|
||
);
|
||
CREATE TABLE IF NOT EXISTS sub_meta (
|
||
key TEXT PRIMARY KEY,
|
||
value TEXT NOT NULL
|
||
);
|
||
`);
|
||
// Версия клиента — необязательное поле, добавленное позже: у уже созданной
|
||
// таблицы колонки может не быть.
|
||
if (!(uidb.prepare("PRAGMA table_info(devices)").all() as { name: string }[]).some(c => c.name === "version"))
|
||
uidb.exec("ALTER TABLE devices ADD COLUMN version TEXT NOT NULL DEFAULT ''");
|
||
// uuid мастер-ключа — постоянный идентификатор: не меняется ни при перевыпуске ссылки,
|
||
// ни при правке метки. Существующим ключам выдаётся здесь один раз.
|
||
if (!(uidb.prepare("PRAGMA table_info(master_keys)").all() as { name: string }[]).some(c => c.name === "uuid"))
|
||
uidb.exec("ALTER TABLE master_keys ADD COLUMN uuid TEXT");
|
||
{
|
||
const setUuid = uidb.prepare<[string, number]>("UPDATE master_keys SET uuid = ? WHERE id = ?");
|
||
for (const { id } of uidb.prepare("SELECT id FROM master_keys WHERE uuid IS NULL").all() as { id: number }[])
|
||
setUuid.run(crypto.randomUUID(), id);
|
||
}
|
||
uidb.exec("CREATE UNIQUE INDEX IF NOT EXISTS master_keys_uuid ON master_keys (uuid)");
|
||
uidb.pragma("foreign_keys = ON");
|
||
|
||
// Перенос со времени одного сервера: ключ отдавал master_keys.server_id, а пир устройства
|
||
// уже стоит там под devices.pub_key (ip/psk подтянет reconcile). У ключа всегда есть хотя
|
||
// бы один сервер, поэтому «ни одной строки» бывает только у ключей из старой схемы.
|
||
uidb.exec(`
|
||
INSERT OR IGNORE INTO master_servers (master_id, server_id)
|
||
SELECT id, server_id FROM master_keys
|
||
WHERE revoked_at IS NULL AND id NOT IN (SELECT master_id FROM master_servers);
|
||
INSERT OR IGNORE INTO device_peers (device_id, server_id, peer_pub)
|
||
SELECT d.id, m.server_id, d.pub_key FROM devices d JOIN master_keys m ON m.id = d.master_id
|
||
WHERE d.id NOT IN (SELECT device_id FROM device_peers);
|
||
`);
|
||
|
||
// Id панели — область её пиров на серверах. Живёт, пока живёт ui.db; копия в panel.id
|
||
// нужна CLI (у него нет SQLite), чтобы отличать пиров этой панели на awg-ctrl.
|
||
uidb.prepare("INSERT OR IGNORE INTO sub_meta (key, value) VALUES ('panel_id', ?)").run(crypto.randomBytes(6).toString("hex"));
|
||
const panelId = (uidb.prepare("SELECT value FROM sub_meta WHERE key = 'panel_id'").get() as { value: string }).value;
|
||
try { fs.writeFileSync(path.join(deps.baseDir, "panel.id"), panelId + "\n"); }
|
||
catch (e) { console.warn(`sub: не удалось записать panel.id: ${(e as Error).message}`); }
|
||
|
||
const q = {
|
||
// И отозванные: удалённый ключ висит в списке, пока все его серверы не подтвердят удаление.
|
||
masters: uidb.prepare("SELECT m.*, (SELECT COUNT(*) FROM devices d WHERE d.master_id = m.id) AS devices FROM master_keys m ORDER BY id"),
|
||
masterById: uidb.prepare<[number]>("SELECT * FROM master_keys WHERE id = ? AND revoked_at IS NULL"),
|
||
masterRow: uidb.prepare<[number]>("SELECT m.*, (SELECT COUNT(*) FROM devices d WHERE d.master_id = m.id) AS devices FROM master_keys m WHERE id = ?"),
|
||
masterBySecret: uidb.prepare<[Buffer]>("SELECT * FROM master_keys WHERE secret = ? AND revoked_at IS NULL"),
|
||
masterInsert: uidb.prepare<[string, string, Buffer, number, number, number]>("INSERT INTO master_keys (uuid, label, secret, device_limit, server_id, created_at) VALUES (?, ?, ?, ?, ?, ?)"),
|
||
masterIdByUuid: uidb.prepare<[string]>("SELECT id FROM master_keys WHERE uuid = ?"),
|
||
masterUpdate: uidb.prepare<[string, number, number]>("UPDATE master_keys SET label = ?, device_limit = ? WHERE id = ?"),
|
||
masterSecret: uidb.prepare<[Buffer, number]>("UPDATE master_keys SET secret = ? WHERE id = ?"),
|
||
masterRevoke: uidb.prepare<[number, number]>("UPDATE master_keys SET revoked_at = ? WHERE id = ?"),
|
||
// Сервер сведён и надгробий на нём нет — отозванным ключам он больше не нужен.
|
||
revokedServerDone: uidb.prepare<[number]>(
|
||
"DELETE FROM master_servers WHERE server_id = ? AND master_id IN (SELECT id FROM master_keys WHERE revoked_at IS NOT NULL)"),
|
||
revokedGone: uidb.prepare("DELETE FROM master_keys WHERE revoked_at IS NOT NULL AND id NOT IN (SELECT master_id FROM master_servers)"),
|
||
liveOnServer: uidb.prepare<[number]>(
|
||
"SELECT m.label FROM master_servers s JOIN master_keys m ON m.id = s.master_id WHERE s.server_id = ? AND m.revoked_at IS NULL"),
|
||
revokedOnServer: uidb.prepare<[number]>(
|
||
"SELECT m.label FROM master_servers s JOIN master_keys m ON m.id = s.master_id WHERE s.server_id = ? AND m.revoked_at IS NOT NULL"),
|
||
serverRelease: uidb.prepare<[number]>("DELETE FROM master_servers WHERE server_id = ?"),
|
||
serversOf: uidb.prepare<[number]>("SELECT server_id FROM master_servers WHERE master_id = ? ORDER BY server_id"),
|
||
serverAdd: uidb.prepare<[number, number]>("INSERT OR IGNORE INTO master_servers (master_id, server_id) VALUES (?, ?)"),
|
||
serverDel: uidb.prepare<[number, number]>("DELETE FROM master_servers WHERE master_id = ? AND server_id = ?"),
|
||
usedServers: uidb.prepare("SELECT server_id FROM master_servers UNION SELECT server_id FROM peer_tombstones"),
|
||
devicesOf: uidb.prepare<[number]>("SELECT * FROM devices WHERE master_id = ? ORDER BY id"),
|
||
deviceById: uidb.prepare<[number]>("SELECT * FROM devices WHERE id = ?"),
|
||
deviceByKey: uidb.prepare<[number, string]>("SELECT * FROM devices WHERE master_id = ? AND device_id = ?"),
|
||
deviceCount: uidb.prepare<[number]>("SELECT COUNT(*) AS n FROM devices WHERE master_id = ?"),
|
||
deviceInsert: uidb.prepare<[number, string, string, string, string, string, number, string]>(
|
||
"INSERT INTO devices (master_id, device_id, device_name, platform, pub_key, auth_pub, created_at, version) VALUES (?, ?, ?, ?, ?, ?, ?, ?)"),
|
||
deviceVersion: uidb.prepare<[string, number]>("UPDATE devices SET version = ? WHERE id = ?"),
|
||
deviceDelete: uidb.prepare<[number]>("DELETE FROM devices WHERE id = ?"),
|
||
deviceSeen: uidb.prepare<[number, number]>("UPDATE devices SET last_seen = ? WHERE id = ?"),
|
||
devicePub: uidb.prepare<[string, number, number]>("UPDATE devices SET pub_key = ?, rekey_requested = ? WHERE id = ?"),
|
||
deviceFlag: uidb.prepare<[number, number]>("UPDATE devices SET rekey_requested = 1 WHERE id = ? OR master_id = ?"),
|
||
linksOf: uidb.prepare<[number]>("SELECT * FROM device_peers WHERE device_id = ? ORDER BY server_id"),
|
||
linkAdd: uidb.prepare<[number, number]>("INSERT OR IGNORE INTO device_peers (device_id, server_id) VALUES (?, ?)"),
|
||
linkDel: uidb.prepare<[number, number]>("DELETE FROM device_peers WHERE device_id = ? AND server_id = ?"),
|
||
linkSet: uidb.prepare<[string | null, string | null, string | null, number, number, number]>(
|
||
"UPDATE device_peers SET peer_pub = ?, ip = ?, psk = ?, psk_pending = ? WHERE device_id = ? AND server_id = ?"),
|
||
linkPskDue: uidb.prepare<[number]>("UPDATE device_peers SET psk_pending = 1 WHERE device_id = ? AND peer_pub IS NOT NULL"),
|
||
// Что на сервере расходится с нужным: пира нет, стоит старый ключ, не знаем ip/psk, ждёт новый PSK.
|
||
linksToFix: uidb.prepare<[number]>(`
|
||
SELECT l.*, d.pub_key AS dev_pub, d.master_id FROM device_peers l JOIN devices d ON d.id = l.device_id
|
||
WHERE l.server_id = ? AND (l.peer_pub IS NULL OR l.peer_pub <> d.pub_key
|
||
OR l.ip IS NULL OR l.psk IS NULL OR l.psk_pending = 1)`),
|
||
tombsOf: uidb.prepare<[number]>("SELECT pub_key FROM peer_tombstones WHERE server_id = ?"),
|
||
tombAdd: uidb.prepare<[number, string]>("INSERT OR IGNORE INTO peer_tombstones (server_id, pub_key) VALUES (?, ?)"),
|
||
tombDel: uidb.prepare<[number, string]>("DELETE FROM peer_tombstones WHERE server_id = ? AND pub_key = ?"),
|
||
tombCount: uidb.prepare<[number]>("SELECT COUNT(*) AS n FROM peer_tombstones WHERE server_id = ?"),
|
||
// Что панели нужно на сервере: текущий ключ каждого устройства и ключ, который там стоит
|
||
// сейчас (расходится с текущим, пока смена ключа не догнала сервер).
|
||
keepOf: uidb.prepare<[number, number]>(`
|
||
SELECT d.pub_key AS pub FROM device_peers l JOIN devices d ON d.id = l.device_id WHERE l.server_id = ?
|
||
UNION SELECT peer_pub FROM device_peers WHERE server_id = ? AND peer_pub IS NOT NULL`),
|
||
// Связи, которые считаются сведёнными: на сервере должен стоять текущий ключ устройства.
|
||
linksSettled: uidb.prepare<[number]>(`
|
||
SELECT l.device_id, l.peer_pub FROM device_peers l JOIN devices d ON d.id = l.device_id
|
||
WHERE l.server_id = ? AND l.peer_pub = d.pub_key`),
|
||
profileGet: uidb.prepare<[number]>("SELECT profile FROM server_profiles WHERE server_id = ?"),
|
||
profileSet: uidb.prepare<[number, string, number]>(
|
||
"INSERT INTO server_profiles (server_id, profile, updated_at) VALUES (?, ?, ?) ON CONFLICT(server_id) DO UPDATE SET profile = excluded.profile, updated_at = excluded.updated_at"),
|
||
};
|
||
|
||
const now = () => Math.floor(Date.now() / 1000);
|
||
const hasCtrlOk = (s: number) => s >= 200 && s < 300;
|
||
const serverIdsOf = (masterId: number) => (q.serversOf.all(masterId) as { server_id: number }[]).map(r => r.server_id);
|
||
|
||
// ── Сведение серверов ──────────────────────────────────────────────────
|
||
function storedProfile(id: number): Profile | null {
|
||
const row = q.profileGet.get(id) as { profile: string } | undefined;
|
||
try { return row ? JSON.parse(row.profile) as Profile : null; } catch { return null; }
|
||
}
|
||
|
||
async function refreshProfile(id: number, ctrl: Ctrl): Promise<boolean> {
|
||
const r = await ctrl("GET", "/api/profile");
|
||
if (!hasCtrlOk(r.status) || typeof r.data?.endpoint !== "string") return false;
|
||
const json = JSON.stringify(r.data);
|
||
const row = q.profileGet.get(id) as { profile: string } | undefined;
|
||
if (row?.profile !== json) q.profileSet.run(id, json, now());
|
||
return true;
|
||
}
|
||
|
||
// Один проход на сервер за раз: параллельные проходы добавили бы одного пира дважды.
|
||
const locks = new Map<number, Promise<void>>();
|
||
function reconcile(id: number): Promise<void> {
|
||
const next = (locks.get(id) ?? Promise.resolve()).then(() => reconcileNow(id)).catch(e => {
|
||
console.warn(`sub: сервер #${id} не сведён: ${(e as Error).message}`);
|
||
});
|
||
locks.set(id, next);
|
||
return next;
|
||
}
|
||
const reconcileAll = (ids: Iterable<number>) => Promise.all([...new Set(ids)].map(reconcile));
|
||
|
||
async function reconcileNow(id: number) {
|
||
if (!servers.exists(id) || !servers.isOnline(id)) return;
|
||
const ctrl = servers.ctrlFor(id);
|
||
if (!await refreshProfile(id, ctrl)) return; // сервер не отвечает — попробуем позже
|
||
|
||
// Список пиров сервера — лениво, только если понадобится (409, потерянный ip/psk).
|
||
let listed: Map<string, { ip: string; psk_key: string }> | null = null;
|
||
const onServer = async (pub: string) => {
|
||
if (!listed) {
|
||
const r = await ctrl("GET", "/api/peers");
|
||
if (!hasCtrlOk(r.status)) throw new Error(`peers ${r.status}`);
|
||
listed = new Map((r.data.peers as { pub_key: string; ip: string; psk_key: string }[]).map(p => [p.pub_key, p]));
|
||
}
|
||
return listed.get(pub) ?? null;
|
||
};
|
||
const gone = (s: number) => s === 502 || s === 504; // связь пропала посреди прохода
|
||
|
||
for (const { pub_key } of q.tombsOf.all(id) as { pub_key: string }[]) {
|
||
const r = await ctrl("DELETE", `/api/peers/${pubParam(pub_key)}`);
|
||
if (hasCtrlOk(r.status) || r.status === 404) q.tombDel.run(id, pub_key);
|
||
else if (gone(r.status)) return;
|
||
}
|
||
|
||
type Peer = { ip: string; psk_key: string };
|
||
for (const l of q.linksToFix.all(id) as (LinkRow & { dev_pub: string; master_id: number })[]) {
|
||
// null — не вышло, попробуем в следующий проход; "gone" — связь пропала, проход прекращаем.
|
||
const add = async (): Promise<Peer | null | "gone"> => {
|
||
const r = await ctrl("POST", "/api/peers", { pub_key: l.dev_pub, owner: `${panelId}/m${l.master_id}/d${l.device_id}` });
|
||
if (hasCtrlOk(r.status)) return r.data;
|
||
if (r.status === 409) return onServer(l.dev_pub); // уже добавлен, но ответ потерялся
|
||
return gone(r.status) ? "gone" : null;
|
||
};
|
||
|
||
let peer: Peer | null | "gone";
|
||
if (l.peer_pub === null) {
|
||
peer = await add();
|
||
} else if (l.peer_pub !== l.dev_pub) {
|
||
// Ключ сменили, пока сервер был недоступен: тот же IP и PSK, новый ключ.
|
||
const r = await ctrl("PUT", `/api/peers/${pubParam(l.peer_pub)}`, { pub_key: l.dev_pub });
|
||
peer = hasCtrlOk(r.status) ? r.data
|
||
: r.status === 404 ? await add() // старого пира на сервере уже нет
|
||
: r.status === 409 ? await onServer(l.dev_pub)
|
||
: gone(r.status) ? "gone" : null;
|
||
} else {
|
||
peer = await onServer(l.dev_pub) ?? await add(); // ip/psk не знаем или пир пропал с сервера
|
||
}
|
||
if (peer === "gone") return;
|
||
if (!peer) continue;
|
||
|
||
let pending = 0;
|
||
if (l.psk_pending === 1) {
|
||
const r = await ctrl("POST", `/api/peers/${pubParam(l.dev_pub)}/psk`);
|
||
if (hasCtrlOk(r.status)) peer = r.data as Peer;
|
||
else if (gone(r.status)) return;
|
||
else pending = 1; // пир на месте, PSK сменим позже
|
||
}
|
||
q.linkSet.run(l.dev_pub, peer.ip, peer.psk_key, pending, l.device_id, id);
|
||
}
|
||
|
||
await syncPeers(id, ctrl);
|
||
}
|
||
|
||
// Сведение пиров панели на сервере — в конце прохода и под его блокировкой: список строится
|
||
// из ui.db сейчас, поэтому устройство, удалённое посреди прохода, в него уже не попадёт, и
|
||
// ключ, поставленный для него этим проходом, снимется здесь же.
|
||
async function syncPeers(id: number, ctrl: Ctrl) {
|
||
const keep = (q.keepOf.all(id, id) as { pub: string }[]).map(r => r.pub);
|
||
const r = await ctrl("PUT", "/api/peers/sync", { owner: panelId, keep });
|
||
if (hasCtrlOk(r.status)) {
|
||
// Самолечение: ключ считается стоящим, а его нет (откат смены ключа после потерянного
|
||
// ответа, пир сняли руками) — забываем и ставим заново следующим проходом.
|
||
const present = new Set(r.data?.present as string[]);
|
||
let lost = 0;
|
||
for (const l of q.linksSettled.all(id) as { device_id: number; peer_pub: string }[]) {
|
||
if (present.has(l.peer_pub)) continue;
|
||
q.linkSet.run(null, null, null, 0, l.device_id, id);
|
||
lost++;
|
||
}
|
||
if (lost) void reconcile(id);
|
||
} else if (r.status !== 400 && r.status !== 413) {
|
||
return; // 400/413 — awg-ctrl старше sync: чистим, как раньше, одними надгробиями
|
||
}
|
||
if ((q.tombCount.get(id) as { n: number }).n > 0) return;
|
||
q.revokedServerDone.run(id);
|
||
q.revokedGone.run();
|
||
}
|
||
|
||
// ── Аудит серверов ─────────────────────────────────────────────────────
|
||
// Периодически (по умолчанию раз в час) core обходит все серверы и ищет «мёртвых»: пиров, которые живы на сервере, хотя
|
||
// панель про них не знает. Сообщает и — если включена очистка (настройки аудита) или оператор нажал кнопку — снимает подтверждённых: мёртвых два прохода подряд.
|
||
// ghosts — есть в ядре (awg show), но неизвестны awg-ctrl: строку удалили, а `awg set … remove`
|
||
// не сработал, и никто про такого пира уже не вспомнит;
|
||
// orphans — есть у awg-ctrl в области этой панели, но панели не нужны (sync их не снял);
|
||
// key — мастер-ключ пира, если он отозван или удалён.
|
||
// Пиры чужой области (другая панель, пиры до областей) в отчёт не попадают — считаются в foreign.
|
||
// seen_before — «мёртвый» и в прошлом проходе тоже: только такие снимает очистка (пир, которого
|
||
// прямо сейчас добавляют или удаляют, за два прохода подряд мёртвым не окажется).
|
||
interface AuditPeer { pub_key: string; owner?: string; key?: string | null; online: boolean; lastHandshake: number; seen_before?: boolean }
|
||
interface AuditEntry {
|
||
server_id: number; status: "ok" | "offline" | "error";
|
||
ghosts_checked: boolean; // false — awg-ctrl старше /api/audit, «призраков» не видно
|
||
ghosts: AuditPeer[]; orphans: AuditPeer[]; foreign: number;
|
||
blocked?: number; // очистка отказалась снимать столько пиров разом (предохранитель)
|
||
}
|
||
interface AuditReport { at: number; servers: AuditEntry[] }
|
||
interface CleanedPeer { at: number; server_id: number; pub_key: string; kind: "ghost" | "orphan"; key?: string | null; auto: boolean }
|
||
// Настройки аудита (панель, вкладка «Аудит»). clean — снимать «мёртвых» сами; every_h — период;
|
||
// max — предохранитель: больше пиров на сервере за проход не снимаем, только сообщаем.
|
||
interface AuditSettings { clean: boolean; every_h: number; max: number }
|
||
const AUDIT_DEFAULTS: AuditSettings = { clean: false, every_h: 1, max: 10 };
|
||
|
||
const AUDIT_ON = (process.env.AUDIT ?? "on").toLowerCase() !== "off"; // выключен у ноды со своей панелью
|
||
const metaGet = <T,>(key: string, dflt: T): T => {
|
||
try {
|
||
const row = uidb.prepare("SELECT value FROM sub_meta WHERE key = ?").get(key) as { value: string } | undefined;
|
||
return row ? JSON.parse(row.value) as T : dflt;
|
||
} catch { return dflt; }
|
||
};
|
||
const metaSet = (key: string, v: unknown) =>
|
||
uidb.prepare("INSERT INTO sub_meta (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value").run(key, JSON.stringify(v));
|
||
let lastAudit: AuditReport | null = metaGet<AuditReport | null>("audit", null);
|
||
let auditSettings: AuditSettings = { ...AUDIT_DEFAULTS, ...metaGet<Partial<AuditSettings>>("audit_settings", {}) };
|
||
let cleanedLog: CleanedPeer[] = metaGet<CleanedPeer[]>("audit_cleaned", []);
|
||
|
||
async function auditNow(id: number): Promise<AuditEntry> {
|
||
const entry: AuditEntry = { server_id: id, status: "ok", ghosts_checked: true, ghosts: [], orphans: [], foreign: 0 };
|
||
if (!servers.exists(id) || !servers.isOnline(id)) return { ...entry, status: "offline", ghosts_checked: false };
|
||
const ctrl = servers.ctrlFor(id);
|
||
// Сначала обычное сведение: отчёт — про то, что не снялось само.
|
||
await reconcileNow(id);
|
||
const [a, p] = [await ctrl("GET", "/api/audit"), await ctrl("GET", "/api/peers")];
|
||
if (!hasCtrlOk(p.status)) return { ...entry, status: "error", ghosts_checked: false };
|
||
if (hasCtrlOk(a.status)) entry.ghosts = (a.data.ghosts as AuditPeer[]).map(g => ({
|
||
pub_key: g.pub_key, online: g.online, lastHandshake: g.lastHandshake,
|
||
}));
|
||
else if (a.status === 404) entry.ghosts_checked = false;
|
||
else return { ...entry, status: "error", ghosts_checked: false };
|
||
|
||
const keep = new Set((q.keepOf.all(id, id) as { pub: string }[]).map(r => r.pub));
|
||
const prefix = panelId + "/";
|
||
for (const peer of p.data.peers as { pub_key: string; owner: string; online: boolean; lastHandshake: number }[]) {
|
||
if (!peer.owner.startsWith(prefix)) { if (peer.owner.includes("/")) entry.foreign++; continue; }
|
||
if (keep.has(peer.pub_key)) continue;
|
||
const mid = Number(peer.owner.match(/^[^/]+\/m(\d+)\//)?.[1]);
|
||
const m = Number.isSafeInteger(mid) ? q.masterRow.get(mid) as MasterRow | undefined : undefined;
|
||
entry.orphans.push({
|
||
pub_key: peer.pub_key, owner: peer.owner, online: peer.online, lastHandshake: peer.lastHandshake,
|
||
key: m ? (m.revoked_at !== null ? `${m.label} (удалён)` : m.label) : "(нет в ui.db)",
|
||
});
|
||
}
|
||
return entry;
|
||
}
|
||
|
||
// Под той же блокировкой, что и сведение: пир, которого прямо сейчас добавляет проход, не «призрак».
|
||
function audit(id: number): Promise<AuditEntry> {
|
||
const run = (locks.get(id) ?? Promise.resolve()).then(() => auditNow(id));
|
||
locks.set(id, run.then(() => {}, () => {}));
|
||
return run.catch((): AuditEntry => ({ server_id: id, status: "error", ghosts_checked: false, ghosts: [], orphans: [], foreign: 0 }));
|
||
}
|
||
|
||
// Снять «мёртвых» этого сервера: только подтверждённых (seen_before), не больше max за проход.
|
||
// «Призраки» — через awg-ctrl (он сам перепроверяет ключи), лишние — обычным DELETE.
|
||
async function cleanEntry(e: AuditEntry, auto: boolean): Promise<void> {
|
||
const ghosts = e.ghosts.filter(p => p.seen_before);
|
||
const orphans = e.orphans.filter(p => p.seen_before);
|
||
if (ghosts.length + orphans.length === 0 || e.status !== "ok") return;
|
||
if (auto && ghosts.length + orphans.length > auditSettings.max) {
|
||
e.blocked = ghosts.length + orphans.length;
|
||
console.warn(`sub: очистка сервера #${e.server_id} пропущена: ${e.blocked} пиров больше предела ${auditSettings.max}`);
|
||
return;
|
||
}
|
||
const ctrl = servers.ctrlFor(e.server_id);
|
||
const done: CleanedPeer[] = [];
|
||
const log = (p: AuditPeer, kind: CleanedPeer["kind"]) =>
|
||
done.push({ at: now(), server_id: e.server_id, pub_key: p.pub_key, kind, key: p.key, auto });
|
||
if (ghosts.length) {
|
||
const r = await ctrl("POST", "/api/audit/clean", { pub_keys: ghosts.map(g => g.pub_key) });
|
||
if (hasCtrlOk(r.status)) {
|
||
const gone = new Set(r.data.removed as string[]);
|
||
for (const g of ghosts) if (gone.has(g.pub_key)) log(g, "ghost");
|
||
}
|
||
}
|
||
for (const p of orphans) {
|
||
const r = await ctrl("DELETE", `/api/peers/${pubParam(p.pub_key)}`);
|
||
if (hasCtrlOk(r.status) || r.status === 404) log(p, "orphan");
|
||
else if (gone502(r.status)) break;
|
||
}
|
||
if (!done.length) return;
|
||
const cleaned = new Set(done.map(d => d.pub_key));
|
||
e.ghosts = e.ghosts.filter(p => !cleaned.has(p.pub_key));
|
||
e.orphans = e.orphans.filter(p => !cleaned.has(p.pub_key));
|
||
cleanedLog = [...done, ...cleanedLog].slice(0, 100);
|
||
metaSet("audit_cleaned", cleanedLog);
|
||
console.warn(`sub: ${auto ? "автоочистка" : "очистка"} сервера #${e.server_id}: снято ${done.length} (${done.map(d => d.pub_key.slice(0, 8)).join(", ")})`);
|
||
}
|
||
const gone502 = (s: number) => s === 502 || s === 504;
|
||
|
||
let auditing: Promise<AuditReport> | null = null;
|
||
// auto — плановый проход: очищает сам, если включено. Ручной только смотрит и обновляет «видели раньше».
|
||
function auditAll(auto = false): Promise<AuditReport> {
|
||
auditing ??= (async () => {
|
||
const prev = lastAudit;
|
||
const report: AuditReport = { at: now(), servers: await Promise.all(servers.ids().map(audit)) };
|
||
for (const e of report.servers) {
|
||
const before = prev?.servers.find(x => x.server_id === e.server_id);
|
||
const was = new Set([...(before?.ghosts ?? []), ...(before?.orphans ?? [])].map(p => p.pub_key));
|
||
for (const p of [...e.ghosts, ...e.orphans]) p.seen_before = was.has(p.pub_key);
|
||
if (auto && auditSettings.clean) await audit_clean(e);
|
||
}
|
||
lastAudit = report;
|
||
metaSet("audit", report);
|
||
for (const e of report.servers) {
|
||
if (e.status === "error") console.warn(`sub: аудит сервера #${e.server_id} не удался`);
|
||
if (e.ghosts.length || e.orphans.length)
|
||
console.warn(`sub: аудит сервера #${e.server_id}: мёртвых пиров ${e.ghosts.length + e.orphans.length} ` +
|
||
`(в ядре без записи: ${e.ghosts.length}, лишних у awg-ctrl: ${e.orphans.length}, онлайн: ` +
|
||
`${[...e.ghosts, ...e.orphans].filter(x => x.online).length})`);
|
||
}
|
||
return report;
|
||
})().finally(() => { auditing = null; });
|
||
return auditing;
|
||
}
|
||
// Очистка под блокировкой сервера — как и сам аудит.
|
||
function audit_clean(e: AuditEntry): Promise<void> {
|
||
const run = (locks.get(e.server_id) ?? Promise.resolve()).then(() => cleanEntry(e, true));
|
||
locks.set(e.server_id, run.then(() => {}, () => {}));
|
||
return run.catch(err => { console.warn(`sub: очистка сервера #${e.server_id} не удалась: ${(err as Error).message}`); });
|
||
}
|
||
|
||
// Ручная очистка подтверждённых «мёртвых» по последнему отчёту (кнопка на вкладке «Аудит»).
|
||
async function cleanNow(): Promise<AuditReport | null> {
|
||
if (!lastAudit) return null;
|
||
for (const e of lastAudit.servers) {
|
||
const run = (locks.get(e.server_id) ?? Promise.resolve()).then(() => cleanEntry(e, false));
|
||
locks.set(e.server_id, run.then(() => {}, () => {}));
|
||
await run.catch(() => {});
|
||
}
|
||
metaSet("audit", lastAudit);
|
||
return lastAudit;
|
||
}
|
||
const auditState = () => ({ enabled: AUDIT_ON, settings: auditSettings, report: lastAudit, cleaned: cleanedLog });
|
||
|
||
/** Устройство удаляется: его пиров — в список на удаление, строку — из реестра. */
|
||
function forgetDevice(dev: DeviceRow): number[] {
|
||
const links = q.linksOf.all(dev.id) as LinkRow[];
|
||
uidb.transaction(() => {
|
||
for (const l of links) if (l.peer_pub) q.tombAdd.run(l.server_id, l.peer_pub);
|
||
q.deviceDelete.run(dev.id); // device_peers уйдут каскадом
|
||
})();
|
||
return links.map(l => l.server_id);
|
||
}
|
||
|
||
// ── config ─────────────────────────────────────────────────────────────
|
||
const hostOf = (endpoint: string) => endpoint.slice(0, endpoint.lastIndexOf(":"));
|
||
|
||
function subHost(req?: Request): string {
|
||
if (SUB_HOST) return SUB_HOST;
|
||
const local = servers.exists(0) ? storedProfile(0) : null;
|
||
if (local) return hostOf(local.endpoint);
|
||
return (req?.hostname ?? "").replace(/^\[|\]$/g, "");
|
||
}
|
||
|
||
// В servers[] — только серверы, где уже стоит текущий ключ устройства и известны ip/psk.
|
||
// Сервер, который ещё не догнали (нода не в сети при регистрации или смене ключа), появится,
|
||
// когда его сведут, — rev при этом сменится, и клиент подтянет.
|
||
function buildConfig(dev: DeviceRow, req?: Request) {
|
||
const list = [];
|
||
for (const l of q.linksOf.all(dev.id) as LinkRow[]) {
|
||
const prof = storedProfile(l.server_id);
|
||
if (!prof || l.peer_pub !== dev.pub_key || !l.ip || !l.psk) continue;
|
||
list.push({
|
||
id: l.server_id, name: prof.name, endpoint: prof.endpoint, server_pub: prof.server_pub,
|
||
psk: l.psk, address: `${l.ip}/32`, dns: prof.dns,
|
||
keepalive: prof.keepalive, mtu: prof.mtu, gen: prof.gen, awg: prof.awg,
|
||
});
|
||
}
|
||
const cfg = {
|
||
rekey: dev.rekey_requested === 1,
|
||
endpoints: [`${subHost(req)}:${SUB_PORT}`],
|
||
servers: list,
|
||
};
|
||
// rev меняется при любом изменении; клиент по нему решает, трогать ли туннель.
|
||
const rev = crypto.createHash("sha256").update(JSON.stringify(cfg)).digest("hex").slice(0, 16);
|
||
return { rev, ...cfg };
|
||
}
|
||
|
||
// Конфиг, в котором есть хотя бы один сервер. Пустой не отдаём: клиент снёс бы туннель
|
||
// из-за временной недоступности нод — пусть лучше живёт со старым конфигом.
|
||
async function readyConfig(dev: DeviceRow, req: Request) {
|
||
let cfg = buildConfig(dev, req);
|
||
if (cfg.servers.length === 0) {
|
||
await reconcileAll((q.linksOf.all(dev.id) as LinkRow[]).map(l => l.server_id));
|
||
cfg = buildConfig(q.deviceById.get(dev.id) as DeviceRow, req);
|
||
}
|
||
if (cfg.servers.length === 0) throw new Error("no servers");
|
||
return cfg;
|
||
}
|
||
|
||
// ── Публичная часть: /sub/v1 ───────────────────────────────────────────
|
||
const sub = express();
|
||
sub.disable("x-powered-by");
|
||
sub.use(express.json({
|
||
limit: "4kb",
|
||
verify: (req, _res, buf) => { (req as any).rawBody = buf; },
|
||
}));
|
||
|
||
const limited = (what: string) => (ip: string) => console.warn(`sub: 429 ${what} ip=${ip} — лимит исчерпан на 15 минут`);
|
||
const registerLimit = makeLimiter(30, 15 * 60 * 1000, limited("register"));
|
||
const failLimit = makeLimiter(30, 15 * 60 * 1000, limited("неудачные запросы"));
|
||
const seenSigs = new Map<string, number>(); // подпись → когда забыть
|
||
const ipOf = (req: Request) => req.socket.remoteAddress ?? "unknown";
|
||
|
||
// Ответ подписан и несёт эхо запроса: device (X-Sen-Device) и ts (X-Sen-Ts). Клиент сверяет
|
||
// их со своим запросом — иначе подсунуть ему можно было бы чужой подписанный ответ (чужой
|
||
// revoked, старый config), подпись ведь на запрос не завязана.
|
||
function send(req: Request, res: Response, status: number, payload: object) {
|
||
const echo: { device?: number; ts?: number } = {};
|
||
const device = Number(req.headers["x-sen-device"]), ts = Number(req.headers["x-sen-ts"]);
|
||
if (req.headers["x-sen-device"] !== undefined && Number.isSafeInteger(device)) echo.device = device;
|
||
if (req.headers["x-sen-ts"] !== undefined && Number.isSafeInteger(ts)) echo.ts = ts;
|
||
// Поля ответа важнее эха: device из тела register не перетрёт лишний заголовок.
|
||
res.status(status).json(signResponse({ ...echo, ...payload }, signKey as crypto.KeyObject));
|
||
}
|
||
|
||
// Проверка подписи запроса + защита от повторов. auth_pub — 32 байта.
|
||
// null — всё верно, иначе причина отказа (для лога).
|
||
function signFailure(req: Request, authPub: Buffer): string | null {
|
||
const ts = Number(req.headers["x-sen-ts"]);
|
||
const sig = String(req.headers["x-sen-sig"] ?? "");
|
||
if (!Number.isInteger(ts) || !sig) return "no_signature";
|
||
if (Math.abs(ts - now()) > TS_WINDOW) return `ts_window (часы клиента расходятся на ${ts - now()} с)`;
|
||
const body = ((req as any).rawBody as Buffer | undefined) ?? Buffer.alloc(0);
|
||
if (!verifyRequest(req.method, req.path, ts, body, sig, authPub)) return "bad_signature";
|
||
const t = Date.now();
|
||
for (const [k, exp] of seenSigs) if (exp < t) seenSigs.delete(k);
|
||
if (seenSigs.has(sig)) return "replay";
|
||
seenSigs.set(sig, t + 2 * TS_WINDOW * 1000);
|
||
return null;
|
||
}
|
||
|
||
interface DevReq extends Request { device?: DeviceRow }
|
||
|
||
function deviceAuth(req: Request, res: Response, next: NextFunction) {
|
||
const id = Number(req.headers["x-sen-device"]);
|
||
const dev = Number.isSafeInteger(id) && id > 0 ? q.deviceById.get(id) as DeviceRow | undefined : undefined;
|
||
// Устройства нет — его удалили (id не переиспользуются: AUTOINCREMENT). Отвечаем 410,
|
||
// чтобы клиент снял конфиг, и не считаем в лимит неудач: такие клиенты опрашивают
|
||
// по таймеру и иначе выбивали бы лимит соседям за тем же NAT. Существующему
|
||
// устройству 410 не выдать, поэтому подписанный ответ тут можно отдать без проверки.
|
||
if (!dev && Number.isSafeInteger(id) && id > 0) { send(req, res, 410, { error: "revoked" }); return; }
|
||
const why = dev ? signFailure(req, Buffer.from(dev.auth_pub, "base64url")) : "no_device";
|
||
if (!why) {
|
||
(req as DevReq).device = dev;
|
||
next();
|
||
return;
|
||
}
|
||
// Лимитируем только неудачи: живой клиент, опрашивающий config, под лимит не попадает.
|
||
const ip = ipOf(req);
|
||
if (!failLimit(ip)) { send(req, res, 429, { error: "rate_limited" }); return; }
|
||
console.warn(`sub: 401 ${req.method} ${req.path} device=${req.headers["x-sen-device"] ?? "-"} ${why} ip=${ip}`);
|
||
send(req, res, 401, { error: "unauthorized" });
|
||
}
|
||
|
||
const wrap = (fn: (req: Request, res: Response) => Promise<void>) =>
|
||
(req: Request, res: Response) => { fn(req, res).catch(() => { send(req, res, 502, { error: "unavailable" }); }); };
|
||
|
||
sub.post("/sub/v1/register", wrap(async (req, res) => {
|
||
const ip = ipOf(req);
|
||
if (!registerLimit(ip)) { send(req, res, 429, { error: "rate_limited" }); return; }
|
||
|
||
const b = (req.body ?? {}) as Record<string, unknown>;
|
||
const str = (v: unknown, re: RegExp) => typeof v === "string" && re.test(v) ? v : null;
|
||
const secretB = str(b.sub, /^[A-Za-z0-9_-]{22}$/);
|
||
const deviceId = str(b.device_id, /^[\w.-]{1,64}$/);
|
||
const pubKey = str(b.pub_key, B64_PUB);
|
||
const authPubS = str(b.auth_pub, /^[A-Za-z0-9_-]{43}$/);
|
||
const name = typeof b.device_name === "string" ? b.device_name.slice(0, 64) : "";
|
||
const platform = typeof b.platform === "string" ? b.platform.slice(0, 32) : "";
|
||
const version = str(b.version, CLIENT_VERSION) ?? "";
|
||
if (!secretB || !deviceId || !pubKey || !authPubS) { send(req, res, 400, { error: "bad_request" }); return; }
|
||
|
||
// Регистрация подписана ключом auth_pub из самого тела — доказательство владения.
|
||
const authPub = Buffer.from(authPubS, "base64url");
|
||
const why = authPub.length !== 32 ? "bad_auth_pub" : signFailure(req, authPub);
|
||
if (why) {
|
||
console.warn(`sub: 401 register ${why} ip=${ip}`);
|
||
send(req, res, 401, { error: "unauthorized" });
|
||
return;
|
||
}
|
||
|
||
const master = q.masterBySecret.get(Buffer.from(secretB, "base64url")) as MasterRow | undefined;
|
||
if (!master) { send(req, res, 404, { error: "not_found" }); return; }
|
||
const serverIds = serverIdsOf(master.id).filter(id => servers.exists(id));
|
||
if (serverIds.length === 0) { send(req, res, 502, { error: "unavailable" }); return; }
|
||
|
||
let deviceRowId = 0;
|
||
let touched: number[] = [];
|
||
try {
|
||
uidb.transaction(() => {
|
||
const existing = q.deviceByKey.get(master.id, deviceId) as DeviceRow | undefined;
|
||
if (existing) touched = forgetDevice(existing); // переустановка — старые пиры на удаление
|
||
else if ((q.deviceCount.get(master.id) as { n: number }).n >= master.device_limit)
|
||
throw Object.assign(new Error("limit"), { code: "limit" });
|
||
deviceRowId = Number(q.deviceInsert.run(master.id, deviceId, name, platform, pubKey, authPubS, now(), version).lastInsertRowid);
|
||
for (const sid of serverIds) q.linkAdd.run(deviceRowId, sid);
|
||
})();
|
||
} catch (e: any) {
|
||
if (e?.code === "limit") { send(req, res, 403, { error: "device_limit" }); return; }
|
||
send(req, res, 409, { error: "conflict" }); return; // UNIQUE: pub_key/auth_pub уже заняты
|
||
}
|
||
|
||
await reconcileAll([...touched, ...serverIds]);
|
||
const dev = q.deviceById.get(deviceRowId) as DeviceRow;
|
||
const cfg = buildConfig(dev, req);
|
||
if (cfg.servers.length === 0) {
|
||
// Ни один сервер пира не принял — регистрацию откатываем, клиент повторит позже.
|
||
await reconcileAll(forgetDevice(dev));
|
||
send(req, res, 502, { error: "unavailable" });
|
||
return;
|
||
}
|
||
// devices / device_limit: сколько мест занято с этим устройством — клиент показывает это сразу,
|
||
// без отдельного запроса списка.
|
||
send(req, res, 201, {
|
||
device: dev.id, config: cfg, key_uuid: master.uuid,
|
||
devices: (q.deviceCount.get(master.id) as { n: number }).n, device_limit: master.device_limit,
|
||
});
|
||
}));
|
||
|
||
// Сколько мест у ключа занято — клиент показывает это, пока ссылку только вставили и ещё ничего не
|
||
// регистрировали. Запрос не подписан устройством (его ещё нет): доступ по секрету из ссылки, как у register,
|
||
// а ответ подписан, как всегда. Неверный секрет считается в failLimit — секрет не перебрать.
|
||
sub.post("/sub/v1/peek", wrap(async (req, res) => {
|
||
const ip = ipOf(req);
|
||
const secretB = typeof (req.body as any)?.sub === "string" && /^[A-Za-z0-9_-]{22}$/.test((req.body as any).sub) ? (req.body as any).sub as string : null;
|
||
const master = secretB ? q.masterBySecret.get(Buffer.from(secretB, "base64url")) as MasterRow | undefined : undefined;
|
||
if (!master) {
|
||
if (!failLimit(ip)) { send(req, res, 429, { error: "rate_limited" }); return; }
|
||
send(req, res, secretB ? 404 : 400, { error: secretB ? "not_found" : "bad_request" });
|
||
return;
|
||
}
|
||
send(req, res, 200, { key_uuid: master.uuid, devices: (q.deviceCount.get(master.id) as { n: number }).n, device_limit: master.device_limit });
|
||
}));
|
||
|
||
sub.get("/sub/v1/config", deviceAuth, wrap(async (req, res) => {
|
||
const dev = (req as DevReq).device as DeviceRow;
|
||
q.deviceSeen.run(now(), dev.id);
|
||
// Версия клиента меняется при обновлении приложения; заголовок не подписан — это лишь подпись в панели.
|
||
const v = String(req.headers["x-sen-version"] ?? "");
|
||
if (CLIENT_VERSION.test(v) && v !== dev.version) q.deviceVersion.run(v, dev.id);
|
||
send(req, res, 200, { config: await readyConfig(dev, req) });
|
||
}));
|
||
|
||
// Устройства того же мастер-ключа: клиент показывает их на вкладке «Ключ». Только чтение — отвязать
|
||
// можно лишь себя (DELETE /sub/v1/device); чужие устройства убирает панель.
|
||
sub.get("/sub/v1/devices", deviceAuth, wrap(async (req, res) => {
|
||
const dev = (req as DevReq).device as DeviceRow;
|
||
const master = q.masterById.get(dev.master_id) as MasterRow | undefined;
|
||
if (!master) { send(req, res, 404, { error: "not_found" }); return; }
|
||
send(req, res, 200, {
|
||
name: master.label,
|
||
key_uuid: master.uuid,
|
||
device_limit: master.device_limit,
|
||
devices: (q.devicesOf.all(master.id) as DeviceRow[]).map(d => ({
|
||
id: d.id, name: d.device_name, platform: d.platform, version: d.version,
|
||
created_at: d.created_at, last_seen: d.last_seen, current: d.id === dev.id,
|
||
})),
|
||
});
|
||
}));
|
||
|
||
// Новый ключ ставится на все серверы ключа: где сервер доступен — сразу (тот же IP и PSK),
|
||
// где нет — когда он появится. Если не принял ни один — ключ не меняем, клиент повторит.
|
||
sub.post("/sub/v1/rekey", deviceAuth, wrap(async (req, res) => {
|
||
const dev = (req as DevReq).device as DeviceRow;
|
||
const pub = (req.body as { pub_key?: unknown } | undefined)?.pub_key;
|
||
if (typeof pub !== "string" || !B64_PUB.test(pub)) { send(req, res, 400, { error: "bad_request" }); return; }
|
||
if (pub === dev.pub_key) { send(req, res, 200, { config: await readyConfig(dev, req) }); return; }
|
||
try { q.devicePub.run(pub, 0, dev.id); }
|
||
catch { send(req, res, 409, { error: "conflict" }); return; } // этот ключ уже у другого устройства
|
||
|
||
const ids = (q.linksOf.all(dev.id) as LinkRow[]).map(l => l.server_id);
|
||
await reconcileAll(ids);
|
||
const cfg = buildConfig(q.deviceById.get(dev.id) as DeviceRow, req);
|
||
if (cfg.servers.length === 0) {
|
||
q.devicePub.run(dev.pub_key, dev.rekey_requested, dev.id);
|
||
await reconcileAll(ids); // вернуть старый ключ туда, где успели сменить
|
||
send(req, res, 502, { error: "unavailable" });
|
||
return;
|
||
}
|
||
send(req, res, 200, { config: cfg });
|
||
}));
|
||
|
||
sub.delete("/sub/v1/device", deviceAuth, wrap(async (req, res) => {
|
||
const dev = (req as DevReq).device as DeviceRow;
|
||
await reconcileAll(forgetDevice(dev));
|
||
send(req, res, 200, { ok: true });
|
||
}));
|
||
|
||
sub.use((req, res) => { send(req, res, 404, { error: "not_found" }); });
|
||
// Битый JSON и т. п.: ответ всё равно подписан, чтобы клиент мог ему доверять.
|
||
sub.use((_err: unknown, req: Request, res: Response, _next: NextFunction) => { send(req, res, 400, { error: "bad_request" }); });
|
||
|
||
// ── Мастер-ключи: общая логика панели и внешнего API ───────────────────
|
||
// Панель (/ui/masterkeys, /ui/devices, за JWT) видит всё. Внешний API (/api/v1/masterkeys,
|
||
// ключ awgk_) — только ключи, чьи серверы целиком входят в набор серверов API-ключа:
|
||
// иначе он мог бы удалить или перенастроить раздачу на сервере, которого не видит.
|
||
// Scope: null — панель, иначе набор серверов API-ключа.
|
||
type Scope = number[] | null;
|
||
|
||
class ApiError extends Error {
|
||
constructor(public status: number, message: string) { super(message); }
|
||
}
|
||
const fail = (status: number, message: string): never => { throw new ApiError(status, message); };
|
||
|
||
// ApiError — её статус; остальное (awg-ctrl не ответил посреди действия) — 502.
|
||
const aw = (fn: (req: Request, res: Response) => unknown) => (req: Request, res: Response) => {
|
||
Promise.resolve().then(() => fn(req, res)).catch(e => {
|
||
if (e instanceof ApiError) res.status(e.status).json({ error: e.message });
|
||
else res.status(502).json({ error: "awg-ctrl недоступен" });
|
||
});
|
||
};
|
||
const idOf = (v: string) => { const n = Number(v); return Number.isSafeInteger(n) ? n : -1; }; // -1 — не найдётся
|
||
// Мастер-ключ в пути — числовой id или uuid.
|
||
const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
|
||
const masterIdOf = (v: string) => UUID_RE.test(v)
|
||
? (q.masterIdByUuid.get(v.toLowerCase()) as { id: number } | undefined)?.id ?? -1
|
||
: idOf(v);
|
||
const LABEL = /^[^\r\n<>]{1,40}$/;
|
||
const limitOk = (n: unknown): n is number => Number.isInteger(n) && (n as number) >= 1 && (n as number) <= 100;
|
||
|
||
const visible = (masterId: number, scope: Scope) =>
|
||
scope === null || serverIdsOf(masterId).every(id => scope.includes(id));
|
||
|
||
// Живой (не удаляемый) ключ в пределах области; чужой — как несуществующий.
|
||
function masterFor(id: number, scope: Scope): MasterRow {
|
||
const m = q.masterById.get(id) as MasterRow | undefined;
|
||
return m && visible(m.id, scope) ? m : fail(404, "Не найден");
|
||
}
|
||
|
||
// Устройство — только вместе со своим мастер-ключом (у внешнего API пути вложенные).
|
||
function deviceFor(id: number, master?: MasterRow): DeviceRow {
|
||
const d = q.deviceById.get(id) as DeviceRow | undefined;
|
||
return d && (!master || d.master_id === master.id) ? d : fail(404, "Не найдено");
|
||
}
|
||
|
||
// Набор серверов из тела запроса: непустой, без повторов, только существующие и — для
|
||
// внешнего API — только из области его ключа.
|
||
function parseServers(v: unknown, scope: Scope): number[] {
|
||
if (!Array.isArray(v) || v.length === 0) fail(400, "Нужен хотя бы один сервер");
|
||
const list = v as unknown[];
|
||
if (list.length > MAX_SERVERS) fail(400, `Не больше ${MAX_SERVERS} серверов`);
|
||
const ids = [...new Set(list)];
|
||
if (!ids.every(id => Number.isInteger(id) && servers.exists(id as number))) fail(400, "Такого сервера нет");
|
||
if (scope && !ids.every(id => scope.includes(id as number))) fail(403, "Сервер вне области API-ключа");
|
||
return (ids as number[]).sort((a, b) => a - b);
|
||
}
|
||
|
||
// deleting — ключ удалён, но эти серверы ещё не подтвердили, что сняли его пиров.
|
||
function masterOut(m: MasterRow & { devices: number }) {
|
||
return {
|
||
id: m.id, uuid: m.uuid, label: m.label, device_limit: m.device_limit,
|
||
devices: m.devices, servers: serverIdsOf(m.id), created_at: m.created_at,
|
||
...(m.revoked_at !== null ? { deleting: serverIdsOf(m.id) } : {}),
|
||
};
|
||
}
|
||
const masterOutById = (id: number) => masterOut(q.masterRow.get(id) as MasterRow & { devices: number });
|
||
|
||
const listMasters = (scope: Scope) =>
|
||
(q.masters.all() as (MasterRow & { devices: number })[]).filter(m => visible(m.id, scope)).map(masterOut);
|
||
|
||
// Серверы по умолчанию: у панели — сервер по умолчанию, у API-ключа — вся его область.
|
||
function createMaster(body: unknown, scope: Scope) {
|
||
const { label, device_limit, servers: wanted } = (body ?? {}) as { label?: unknown; device_limit?: unknown; servers?: unknown };
|
||
if (typeof label !== "string" || !LABEL.test(label)) fail(400, "Метка: до 40 символов, без переводов строк и <>");
|
||
const limit = device_limit === undefined ? DEFAULT_LIMIT : device_limit;
|
||
if (!limitOk(limit)) fail(400, "Лимит устройств: от 1 до 100");
|
||
let ids: number[];
|
||
try { ids = parseServers(wanted ?? scope ?? [servers.defaultId()], scope); }
|
||
catch (e) { throw wanted === undefined && scope === null ? new ApiError(400, "Сначала добавьте сервер") : e; }
|
||
let id = 0;
|
||
uidb.transaction(() => {
|
||
id = Number(q.masterInsert.run(crypto.randomUUID(), label as string, crypto.randomBytes(16), limit as number, ids[0], now()).lastInsertRowid);
|
||
for (const sid of ids) q.serverAdd.run(id, sid);
|
||
})();
|
||
return masterOutById(id);
|
||
}
|
||
|
||
async function updateMaster(m: MasterRow, body: unknown, scope: Scope) {
|
||
const { label, device_limit, servers: wanted } = (body ?? {}) as { label?: unknown; device_limit?: unknown; servers?: unknown };
|
||
const nl = label ?? m.label, nd = device_limit ?? m.device_limit;
|
||
if (typeof nl !== "string" || !LABEL.test(nl)) fail(400, "Неверная метка");
|
||
if (!limitOk(nd)) fail(400, "Лимит устройств: от 1 до 100");
|
||
|
||
let ids = serverIdsOf(m.id);
|
||
const affected: number[] = [];
|
||
if (wanted !== undefined) {
|
||
const next = parseServers(wanted, scope);
|
||
const added = next.filter(s => !ids.includes(s)), removed = ids.filter(s => !next.includes(s));
|
||
const devices = q.devicesOf.all(m.id) as DeviceRow[];
|
||
uidb.transaction(() => {
|
||
for (const sid of removed) {
|
||
q.serverDel.run(m.id, sid);
|
||
for (const d of devices) {
|
||
const l = (q.linksOf.all(d.id) as LinkRow[]).find(x => x.server_id === sid);
|
||
if (l?.peer_pub) q.tombAdd.run(sid, l.peer_pub);
|
||
q.linkDel.run(d.id, sid);
|
||
}
|
||
}
|
||
for (const sid of added) {
|
||
q.serverAdd.run(m.id, sid);
|
||
for (const d of devices) q.linkAdd.run(d.id, sid);
|
||
}
|
||
})();
|
||
affected.push(...added, ...removed);
|
||
ids = next;
|
||
}
|
||
q.masterUpdate.run(nl as string, nd as number, m.id);
|
||
// Лимит стал меньше, чем устройств: лишние отвязываются, начиная с подключившихся последними, —
|
||
// первые, кто занял места, их сохраняют. Как отзыв в панели: пиры снимаются, устройство получит 410.
|
||
const unbound: number[] = [];
|
||
const devices = q.devicesOf.all(m.id) as DeviceRow[];
|
||
if (devices.length > (nd as number)) {
|
||
const newest = [...devices].sort((a, b) => b.created_at - a.created_at || b.id - a.id);
|
||
for (const d of newest.slice(0, devices.length - (nd as number))) {
|
||
affected.push(...forgetDevice(d));
|
||
unbound.push(d.id);
|
||
}
|
||
}
|
||
await reconcileAll(affected);
|
||
return { id: m.id, label: nl as string, device_limit: nd as number, servers: ids, unbound };
|
||
}
|
||
|
||
// Новая ссылка; устройства продолжают работать: у них auth_pub, а не secret.
|
||
const rotateMaster = (m: MasterRow) => { q.masterSecret.run(crypto.randomBytes(16), m.id); };
|
||
const rekeyMaster = (m: MasterRow) => { q.deviceFlag.run(-1, m.id); };
|
||
|
||
// Ключ сразу перестаёт работать (ссылка, регистрация, устройства), но строка остаётся
|
||
// отозванной, пока каждый его сервер не подтвердит, что снял пиров, — иначе панель
|
||
// сказала бы «удалён», пока на офлайн-ноде устройства ещё подключаются.
|
||
async function deleteMaster(m: MasterRow) {
|
||
const affected = serverIdsOf(m.id);
|
||
uidb.transaction(() => {
|
||
for (const d of q.devicesOf.all(m.id) as DeviceRow[]) affected.push(...forgetDevice(d));
|
||
q.masterRevoke.run(now(), m.id);
|
||
})();
|
||
await reconcileAll(affected);
|
||
return { success: true, id: m.id, pending: serverIdsOf(m.id) };
|
||
}
|
||
|
||
// Выдать ссылку можно, только если подписка настроена и известен адрес панели.
|
||
function linkProblem(req: Request): string | null {
|
||
if (!signKey || !signPub || !SUB_PORT) return "Подписка не настроена на сервере";
|
||
if (!subHost(req)) return "Не удалось определить адрес панели — задайте SUB_HOST";
|
||
return null;
|
||
}
|
||
|
||
function linkOf(m: MasterRow, req: Request) {
|
||
const problem = linkProblem(req);
|
||
if (problem) fail(503, problem);
|
||
const link = encodeSenLink({
|
||
tls: tlsPin !== null,
|
||
addrs: [{ host: subHost(req), port: SUB_PORT }],
|
||
secret: m.secret, signPub: signPub as Buffer, tlsPin: tlsPin ?? undefined, name: m.label,
|
||
});
|
||
return { link, tls: tlsPin !== null };
|
||
}
|
||
|
||
// Статистика устройства — по всем серверам ключа: онлайн, если есть свежий handshake хоть
|
||
// на одном; трафик суммируется. servers_ok — на скольких серверах уже стоит его текущий ключ.
|
||
async function masterDevices(m: MasterRow) {
|
||
const stats = new Map<string, { online: boolean; lastHandshake: number; rx: number; tx: number; background: boolean }>();
|
||
await Promise.all(serverIdsOf(m.id).filter(id => servers.isOnline(id)).map(async id => {
|
||
const r = await servers.ctrlFor(id)("GET", "/api/peers");
|
||
if (!hasCtrlOk(r.status)) return;
|
||
for (const p of r.data.peers as { pub_key: string; online: boolean; lastHandshake: number; rx: number; tx: number; priority?: string }[]) {
|
||
const s = stats.get(p.pub_key) ?? { online: false, lastHandshake: 0, rx: 0, tx: 0, background: false };
|
||
stats.set(p.pub_key, {
|
||
online: s.online || p.online, lastHandshake: Math.max(s.lastHandshake, p.lastHandshake),
|
||
rx: s.rx + p.rx, tx: s.tx + p.tx,
|
||
// Устройство стоит на каждом сервере со своим IP; фоновым его делает любой из них.
|
||
background: s.background || p.priority === "background",
|
||
});
|
||
}
|
||
}));
|
||
return (q.devicesOf.all(m.id) as DeviceRow[]).map(d => {
|
||
const links = q.linksOf.all(d.id) as LinkRow[];
|
||
const s = stats.get(d.pub_key);
|
||
return {
|
||
id: d.id, device_id: d.device_id, device_name: d.device_name, platform: d.platform, version: d.version, created_at: d.created_at,
|
||
last_seen: d.last_seen, rekey_requested: d.rekey_requested === 1,
|
||
online: s?.online ?? false, lastHandshake: s?.lastHandshake ?? 0, rx: s?.rx ?? 0, tx: s?.tx ?? 0,
|
||
priority: s?.background ? "background" : "normal",
|
||
servers_total: links.length, servers_ok: links.filter(l => l.peer_pub === d.pub_key && l.ip).length,
|
||
};
|
||
});
|
||
}
|
||
|
||
async function deleteDevice(d: DeviceRow) {
|
||
await reconcileAll(forgetDevice(d));
|
||
return { success: true, id: d.id };
|
||
}
|
||
const rekeyDevice = (d: DeviceRow) => { q.deviceFlag.run(d.id, -1); };
|
||
|
||
// Новый PSK на каждом сервере; недоступные получат его, когда появятся.
|
||
async function rotatePsk(d: DeviceRow) {
|
||
q.linkPskDue.run(d.id);
|
||
await reconcileAll((q.linksOf.all(d.id) as LinkRow[]).map(l => l.server_id));
|
||
return { id: d.id, pending: (q.linksOf.all(d.id) as LinkRow[]).filter(l => l.psk_pending === 1).length };
|
||
}
|
||
|
||
// ── Роуты панели (монтируются в server.ts за JWT) ──────────────────────
|
||
const masterKeys = Router();
|
||
masterKeys.get("/", (_req, res) => {
|
||
res.json({ enabled: signKey !== null, tls: tlsPin !== null, keys: listMasters(null) });
|
||
});
|
||
// Аудит серверов (только core): отчёт, внеочередной проход, ручная очистка, настройки.
|
||
masterKeys.get("/audit", (_req, res) => { res.json(auditState()); });
|
||
masterKeys.post("/audit", aw(async (_req, res) => {
|
||
if (!AUDIT_ON) fail(409, "Аудит выключен на этой панели");
|
||
await auditAll();
|
||
res.json(auditState());
|
||
}));
|
||
masterKeys.post("/audit/clean", aw(async (_req, res) => {
|
||
if (!AUDIT_ON) fail(409, "Аудит выключен на этой панели");
|
||
await cleanNow();
|
||
res.json(auditState());
|
||
}));
|
||
masterKeys.put("/audit/settings", aw((req, res) => {
|
||
if (!AUDIT_ON) fail(409, "Аудит выключен на этой панели");
|
||
const b = (req.body ?? {}) as Partial<AuditSettings>;
|
||
const next = { ...auditSettings };
|
||
if (b.clean !== undefined) { if (typeof b.clean !== "boolean") fail(400, "clean: true или false"); next.clean = b.clean; }
|
||
if (b.every_h !== undefined) {
|
||
if (!Number.isInteger(b.every_h) || b.every_h < 1 || b.every_h > 168) fail(400, "Период: от 1 до 168 часов");
|
||
next.every_h = b.every_h;
|
||
}
|
||
if (b.max !== undefined) {
|
||
if (!Number.isInteger(b.max) || b.max < 1 || b.max > 1000) fail(400, "Предел: от 1 до 1000");
|
||
next.max = b.max;
|
||
}
|
||
auditSettings = next;
|
||
metaSet("audit_settings", next);
|
||
res.json(auditState());
|
||
}));
|
||
masterKeys.post("/", aw((req, res) => { res.status(201).json(createMaster(req.body, null)); }));
|
||
masterKeys.patch("/:id", aw(async (req, res) => { res.json(await updateMaster(masterFor(masterIdOf(req.params.id), null), req.body, null)); }));
|
||
masterKeys.post("/:id/rotate", aw((req, res) => { const m = masterFor(masterIdOf(req.params.id), null); rotateMaster(m); res.json({ id: m.id }); }));
|
||
masterKeys.post("/:id/rekey", aw((req, res) => { const m = masterFor(masterIdOf(req.params.id), null); rekeyMaster(m); res.json({ id: m.id }); }));
|
||
masterKeys.delete("/:id", aw(async (req, res) => { res.json(await deleteMaster(masterFor(masterIdOf(req.params.id), null))); }));
|
||
masterKeys.get("/:id/link", aw((req, res) => { res.json(linkOf(masterFor(masterIdOf(req.params.id), null), req)); }));
|
||
masterKeys.get("/:id/devices", aw(async (req, res) => { res.json({ devices: await masterDevices(masterFor(masterIdOf(req.params.id), null)) }); }));
|
||
|
||
const devices = Router();
|
||
devices.delete("/:id", aw(async (req, res) => { res.json(await deleteDevice(deviceFor(idOf(req.params.id)))); }));
|
||
devices.post("/:id/rekey", aw((req, res) => { const d = deviceFor(idOf(req.params.id)); rekeyDevice(d); res.json({ id: d.id }); }));
|
||
devices.post("/:id/psk", aw(async (req, res) => { res.json(await rotatePsk(deviceFor(idOf(req.params.id)))); }));
|
||
|
||
// ── Внешний API: /api/v1/masterkeys (ключ awgk_, монтируется в server.ts) ─
|
||
// scopeOf — набор серверов API-ключа запроса. Устройства — вложенными путями, чтобы
|
||
// область проверялась через их мастер-ключ.
|
||
function apiRouter(scopeOf: (req: Request) => number[]) {
|
||
const r = Router();
|
||
const master = (req: Request) => masterFor(masterIdOf(req.params.id), scopeOf(req));
|
||
const device = (req: Request) => deviceFor(idOf(req.params.device), master(req));
|
||
|
||
r.get("/", aw((req, res) => { res.json({ keys: listMasters(scopeOf(req)) }); }));
|
||
r.post("/", aw((req, res) => {
|
||
const problem = linkProblem(req); // без ссылки ключ внешней программе бесполезен
|
||
if (problem) fail(503, problem);
|
||
const out = createMaster(req.body, scopeOf(req));
|
||
res.status(201).json({ ...out, ...linkOf(masterFor(out.id, null), req) });
|
||
}));
|
||
r.get("/:id", aw(async (req, res) => {
|
||
const m = master(req);
|
||
// devices — счётчик, как в списке; сами устройства — в device_list.
|
||
res.json({ ...masterOutById(m.id), ...(linkProblem(req) ? { link: null, tls: tlsPin !== null } : linkOf(m, req)), device_list: await masterDevices(m) });
|
||
}));
|
||
r.patch("/:id", aw(async (req, res) => { res.json(await updateMaster(master(req), req.body, scopeOf(req))); }));
|
||
r.post("/:id/rotate", aw((req, res) => {
|
||
const m = master(req);
|
||
rotateMaster(m);
|
||
res.json({ id: m.id, ...linkOf(masterFor(m.id, null), req) });
|
||
}));
|
||
r.post("/:id/rekey", aw((req, res) => { const m = master(req); rekeyMaster(m); res.json({ id: m.id }); }));
|
||
r.delete("/:id", aw(async (req, res) => { res.json(await deleteMaster(master(req))); }));
|
||
r.get("/:id/devices", aw(async (req, res) => { res.json({ devices: await masterDevices(master(req)) }); }));
|
||
r.delete("/:id/devices/:device", aw(async (req, res) => { res.json(await deleteDevice(device(req))); }));
|
||
r.post("/:id/devices/:device/rekey", aw((req, res) => { const d = device(req); rekeyDevice(d); res.json({ id: d.id }); }));
|
||
r.post("/:id/devices/:device/psk", aw(async (req, res) => { res.json(await rotatePsk(device(req))); }));
|
||
return r;
|
||
}
|
||
|
||
// ── Листенер и фоновое сведение ────────────────────────────────────────
|
||
servers.onOnline(id => { void reconcile(id); });
|
||
|
||
// Сервер удаляют из реестра: пока им пользуется живой мастер-ключ — нельзя. Иначе сперва
|
||
// сводим его (ключи его не используют, значит, список пуст и пиры панели снимутся) — после
|
||
// удаления до него уже не дотянуться. Не вышло (нода не в сети) — удалять только с force;
|
||
// тогда отозванные ключи перестают его ждать уже после удаления (afterDelete).
|
||
servers.beforeDelete(async (id, force) => {
|
||
const live = (q.liveOnServer.all(id) as { label: string }[]).map(r => r.label);
|
||
if (live.length) return { error: `Сервер в мастер-ключах: ${live.join(", ")} — сначала уберите его оттуда`, forcible: false };
|
||
if (servers.isOnline(id)) await reconcile(id);
|
||
const waiting = (q.revokedOnServer.all(id) as { label: string }[]).map(r => r.label);
|
||
const tombs = (q.tombCount.get(id) as { n: number }).n;
|
||
if (!waiting.length && !tombs || force) return null;
|
||
return {
|
||
error: "Сервер не подтвердил, что снял пиров" + (waiting.length ? ` удалённых мастер-ключей (${waiting.join(", ")})` : "") +
|
||
". Дождитесь, пока он выйдет на связь, или удалите принудительно — тогда пиры могут остаться на нём (снять: awg-ctrl peers drop)",
|
||
forcible: true,
|
||
};
|
||
});
|
||
servers.afterDelete(id => {
|
||
q.serverRelease.run(id);
|
||
q.revokedGone.run();
|
||
});
|
||
|
||
function start() {
|
||
// Сводим и без подписки: у ключей могут остаться хвосты на удаление.
|
||
setInterval(() => {
|
||
void reconcileAll((q.usedServers.all() as { server_id: number }[]).map(r => r.server_id));
|
||
}, SYNC_EVERY).unref();
|
||
|
||
if (AUDIT_ON) {
|
||
// Период читается из настроек каждый раз: смена в панели действует без рестарта.
|
||
const next = (ms: number) => setTimeout(() => {
|
||
auditAll(true).catch(e => console.warn(`sub: аудит не удался: ${(e as Error).message}`))
|
||
.finally(() => next(auditSettings.every_h * AUDIT_HOUR));
|
||
}, ms).unref();
|
||
next(AUDIT_FIRST);
|
||
}
|
||
|
||
if (!signKey) return;
|
||
if (!SUB_PORT) { console.warn("sub: SUB_PORT не задан — подписка отключена"); signKey = null; return; }
|
||
const server = tlsMaterial ? https.createServer(tlsMaterial, sub) : http.createServer(sub);
|
||
server.listen(SUB_PORT, () => {
|
||
console.log(`sub: listening on :${SUB_PORT} (${tlsMaterial ? "https" : "http"})`);
|
||
});
|
||
}
|
||
|
||
return { masterKeys, devices, apiRouter, start };
|
||
}
|