maeneko
53d5a08bbd
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.
1414 lines
68 KiB
TypeScript
1414 lines
68 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.
|
||
import fs, { readFileSync, writeFileSync, existsSync, mkdirSync, openSync, closeSync } from "fs";
|
||
import path from "path";
|
||
import os from "os";
|
||
import crypto from "crypto";
|
||
import { execSync, spawnSync, execFile, spawn } from "child_process";
|
||
import * as zlib from "zlib";
|
||
import express, { Request, Response, NextFunction } from "express";
|
||
import Database from "better-sqlite3";
|
||
import winston from "winston";
|
||
import { createShaping } from "./shaping";
|
||
|
||
const logsDir = path.join(process.cwd(), "logs");
|
||
if (!existsSync(logsDir)) mkdirSync(logsDir, { recursive: true });
|
||
|
||
const logger = winston.createLogger({
|
||
level: "debug",
|
||
transports: [
|
||
new winston.transports.Console({
|
||
format: winston.format.combine(
|
||
winston.format.timestamp(),
|
||
winston.format.colorize(),
|
||
winston.format.printf(({ timestamp, level, message }) =>
|
||
`${timestamp} ${level}: ${message}`
|
||
),
|
||
),
|
||
}),
|
||
new winston.transports.File({
|
||
filename: path.join(logsDir, "app.log"),
|
||
format: winston.format.combine(
|
||
winston.format.timestamp(),
|
||
winston.format.json(),
|
||
),
|
||
}),
|
||
],
|
||
});
|
||
|
||
const INTERNAL_AUTH_PUB_FILE = process.env.INTERNAL_AUTH_PUB_FILE
|
||
?? "/etc/amnezia/amneziawg/internal_auth_public.key";
|
||
let internalAuthPubKey: crypto.KeyObject;
|
||
try {
|
||
internalAuthPubKey = crypto.createPublicKey(readFileSync(INTERNAL_AUTH_PUB_FILE));
|
||
} catch {
|
||
logger.error("FATAL: публичный ключ внутренней авторизации не найден: " + INTERNAL_AUTH_PUB_FILE);
|
||
process.exit(1);
|
||
}
|
||
|
||
const SERVER = {
|
||
port: Number(process.env.PORT) || 3005,
|
||
};
|
||
|
||
const dbPath = path.join("/etc/amnezia/amneziawg", "users.db");
|
||
const db = new Database(dbPath);
|
||
|
||
db.exec(`
|
||
CREATE TABLE IF NOT EXISTS users (
|
||
name TEXT PRIMARY KEY,
|
||
ip TEXT NOT NULL UNIQUE,
|
||
pub_key TEXT NOT NULL,
|
||
vpn_key TEXT NOT NULL,
|
||
psk_key TEXT NOT NULL DEFAULT ''
|
||
)
|
||
`);
|
||
|
||
db.exec("CREATE UNIQUE INDEX IF NOT EXISTS idx_users_ip ON users (ip)");
|
||
|
||
// Миграции users: better-sqlite3 синхронный, ALTER TABLE идемпотентным не бывает,
|
||
// поэтому смотрим фактический список колонок.
|
||
// key_gen — поколение протокола, на параметрах которого выдан vpn_key
|
||
// ('2' для всего, что заведено до появления 3.1)
|
||
// vpn_key_prev — предыдущий блоб, чтобы перевыпуск можно было откатить
|
||
{
|
||
const cols = new Set(
|
||
(db.prepare("PRAGMA table_info(users)").all() as { name: string }[]).map(c => c.name),
|
||
);
|
||
if (!cols.has("key_gen"))
|
||
db.exec("ALTER TABLE users ADD COLUMN key_gen TEXT NOT NULL DEFAULT '2'");
|
||
if (!cols.has("vpn_key_prev"))
|
||
db.exec("ALTER TABLE users ADD COLUMN vpn_key_prev TEXT NOT NULL DEFAULT ''");
|
||
}
|
||
|
||
db.exec(`
|
||
CREATE TABLE IF NOT EXISTS config (
|
||
key TEXT PRIMARY KEY,
|
||
value TEXT NOT NULL
|
||
)
|
||
`);
|
||
|
||
// Пиры устройств sen://-подписки. Отдельная таблица, users не трогаем: у этих
|
||
// пиров нет ни vpn_key, ни имени — приватный ключ живёт только на устройстве,
|
||
// сюда приходит лишь публичный. owner — непрозрачная метка от awg-ui
|
||
// («m<masterId>/d<deviceId>»), нужна только для комментария в conf и логов.
|
||
db.exec(`
|
||
CREATE TABLE IF NOT EXISTS peers (
|
||
pub_key TEXT PRIMARY KEY,
|
||
ip TEXT NOT NULL UNIQUE,
|
||
psk_key TEXT NOT NULL,
|
||
owner TEXT NOT NULL DEFAULT '',
|
||
created_at INTEGER NOT NULL
|
||
)
|
||
`);
|
||
|
||
const cfgStmts = {
|
||
get: db.prepare<[string], { value: string }>("SELECT value FROM config WHERE key = ?"),
|
||
set: db.prepare<[string, string]>("INSERT OR REPLACE INTO config (key, value) VALUES (?, ?)"),
|
||
};
|
||
|
||
function getCfg(key: string, fallback: string): string {
|
||
return cfgStmts.get.get(key)?.value ?? fallback;
|
||
}
|
||
|
||
function setCfg(key: string, value: string) {
|
||
cfgStmts.set.run(key, value);
|
||
}
|
||
|
||
function getLocalIp(): string {
|
||
const route = spawnSync("ip", ["route", "show", "default"]);
|
||
const iface = route.stdout.toString().match(/dev\s+(\S+)/)?.[1];
|
||
if (!iface) return "";
|
||
const addr = spawnSync("ip", ["addr", "show", iface]);
|
||
return addr.stdout.toString().match(/inet\s+([\d.]+)/)?.[1] ?? "";
|
||
}
|
||
|
||
function initConfig() {
|
||
const serverIp = getCfg("serverIp", process.env.SERVER_IP ?? getLocalIp());
|
||
const serverPort = getCfg("serverPort", process.env.SERVER_PORT ?? "51820");
|
||
const serverName = getCfg("serverName", process.env.SERVER_NAME ?? "VPN");
|
||
|
||
if (!serverIp) throw new Error("SERVER_IP не задан — передай через env при первом запуске");
|
||
|
||
setCfg("serverIp", serverIp);
|
||
setCfg("serverPort", serverPort);
|
||
setCfg("serverName", serverName);
|
||
|
||
return { serverIp, serverPort: Number(serverPort), serverName };
|
||
}
|
||
|
||
// Ключи, появившиеся в AmneziaWG 3.0/3.1. Пустая строка = ключ не задан, тогда
|
||
// интерфейс работает в режиме 2.0 и его нет ни в conf, ни в vpn:// ключе.
|
||
// Порядок массива = порядок строк в клиентском .conf (см. buildClientConf).
|
||
const AWG3_KEYS = [
|
||
"HeaderProtectionKey",
|
||
"ContentPaddingAddition",
|
||
"RekeyAfterTime",
|
||
"RekeyTimeout",
|
||
"RejectAfterTime",
|
||
"KeepaliveTimeout",
|
||
"MaxHandshakeAttempts",
|
||
"RandomTrailers",
|
||
"DisableCookies",
|
||
] as const;
|
||
|
||
type Awg3Key = (typeof AWG3_KEYS)[number];
|
||
|
||
type AwgParams = {
|
||
Jc: number; Jmin: number; Jmax: number;
|
||
S1: number; S2: number; S3: number; S4: number;
|
||
H1: string; H2: string; H3: string; H4: string;
|
||
I1: string; I2: string; I3: string; I4: string; I5: string;
|
||
} & Record<Awg3Key, string>;
|
||
|
||
const DEFAULT_AWG_PARAMS: AwgParams = {
|
||
Jc: 6, Jmin: 10, Jmax: 50,
|
||
S1: 90, S2: 45, S3: 37, S4: 14,
|
||
H1: "1224800044-2116730834",
|
||
H2: "2122053282-2133204808",
|
||
H3: "2133604274-2140756116",
|
||
H4: "2143656228-2147444225",
|
||
I1: "<r 2><b 0x858000010001000000000669636c6f756403636f6d0000010001c00c000100010000105a00044d583737>",
|
||
I2: "", I3: "", I4: "", I5: "",
|
||
// 3.x по умолчанию выключен: без conf-а сервер остаётся на 2.0.
|
||
HeaderProtectionKey: "", ContentPaddingAddition: "",
|
||
RekeyAfterTime: "", RekeyTimeout: "", RejectAfterTime: "",
|
||
KeepaliveTimeout: "", MaxHandshakeAttempts: "",
|
||
RandomTrailers: "", DisableCookies: "",
|
||
};
|
||
|
||
function readAwgParams(): AwgParams {
|
||
const confFile = path.join("/etc/amnezia/amneziawg", "awg1.conf");
|
||
const params: AwgParams = { ...DEFAULT_AWG_PARAMS };
|
||
if (!existsSync(confFile)) {
|
||
logger.warn("awg1.conf не найден — параметры обфускации по умолчанию");
|
||
return params;
|
||
}
|
||
const iface = readFileSync(confFile, "utf8").split(/^\[Peer\]/m)[0];
|
||
|
||
const numKeys: (keyof AwgParams)[] = ["Jc", "Jmin", "Jmax", "S1", "S2", "S3", "S4"];
|
||
const strKeys: (keyof AwgParams)[] = [
|
||
"H1", "H2", "H3", "H4", "I1", "I2", "I3", "I4", "I5", ...AWG3_KEYS,
|
||
];
|
||
|
||
for (const k of numKeys) {
|
||
const m = iface.match(new RegExp(`^\\s*${k}\\s*=\\s*(\\d+)`, "m"));
|
||
if (m) (params[k] as number) = Number(m[1]);
|
||
}
|
||
for (const k of strKeys) {
|
||
const m = iface.match(new RegExp(`^\\s*${k}\\s*=\\s*(.*)$`, "m"));
|
||
if (m) (params[k] as string) = m[1].trim();
|
||
}
|
||
logger.info("awg params loaded from conf", {
|
||
Jc: params.Jc, H1: params.H1, gen: genOf(params),
|
||
});
|
||
return params;
|
||
}
|
||
|
||
// Поколение протокола выводим из самих параметров, отдельного флага нет: conf
|
||
// остаётся единственным источником правды. Header protection — та фича, которая
|
||
// ломает совместимость с 2.0, поэтому именно она и определяет поколение.
|
||
function genOf(p: AwgParams): "2" | "3.1" {
|
||
return p.HeaderProtectionKey ? "3.1" : "2";
|
||
}
|
||
|
||
// Версия модуля/tools для /health — показывает оператору, что реально работает
|
||
// в ядре сейчас (см. install.sh: apt может обновить пакет, пока в ядре живёт
|
||
// старый загруженный модуль, коммит 6fdacd7). Загруженная версия важнее версии
|
||
// на диске ровно по той же причине. Вызывается на старте и при restartAwg() —
|
||
// это единственные моменты, когда модуль может реально смениться в течение
|
||
// жизни процесса; из обработчика /health не вызывается — этот роут без
|
||
// авторизации, спавнить подпроцессы на каждый его опрос нельзя.
|
||
function readAwgVersions(): { module: string; tools: string } {
|
||
let module = "";
|
||
try {
|
||
module = readFileSync("/sys/module/amneziawg/version", "utf8").trim();
|
||
} catch {
|
||
try { module = run("modinfo -F version amneziawg"); } catch { /* модуль не загружен */ }
|
||
}
|
||
let tools = "";
|
||
try {
|
||
const out = run("awg --version");
|
||
tools = out.split(/\s+/).find(t => /^v?\d/.test(t)) ?? "";
|
||
} catch { /* awg-tools не найден */ }
|
||
return { module, tools };
|
||
}
|
||
|
||
// PersistentKeepalive в 3.1 задаётся диапазоном (дефолт клиента AmneziaVPN);
|
||
// в 2.0 это одно число. Уходит и в серверные [Peer], и в клиентский конфиг.
|
||
const KEEPALIVE_BY_GEN: Record<"2" | "3.1", string> = { "2": "25", "3.1": "25-35" };
|
||
|
||
// Значения 3.1-параметров для перевода уже работающего 2.0-сервера (POST
|
||
// /awg/upgrade) — те же, что пишет install.sh (дефолты клиента AmneziaVPN,
|
||
// protocolConstants.h), в порядке AWG3_KEYS. RandomTrailers/DisableCookies не
|
||
// включаем — как и инсталлятор. HeaderProtectionKey сюда не входит: он
|
||
// генерируется на месте (awg genpsk) и фиксируется на весь срок жизни сервера.
|
||
const AWG31_DEFAULTS: Record<string, string> = {
|
||
ContentPaddingAddition: "10-100",
|
||
RekeyAfterTime: "100-120",
|
||
RekeyTimeout: "3-7",
|
||
RejectAfterTime: "150-180",
|
||
KeepaliveTimeout: "5-15",
|
||
MaxHandshakeAttempts: "15-20",
|
||
};
|
||
|
||
// При заданном HeaderProtectionKey ни один из S1–S4 не может быть меньше 12
|
||
// (HEADER_PROTECTION_NONCE_SIZE). Модуль на нарушение отвечает только
|
||
// «Invalid argument»; причина видна лишь при
|
||
// `echo "module amneziawg +p" > /sys/kernel/debug/dynamic_debug/control`.
|
||
const MIN_S_FOR_HEADER_PROTECTION = 12;
|
||
|
||
const runtimeConfig = initConfig();
|
||
const AWG_PARAMS = readAwgParams();
|
||
const AWG_GEN = genOf(AWG_PARAMS);
|
||
const AWG_VERSIONS = readAwgVersions();
|
||
const CONFIG = {
|
||
interface: "awg1",
|
||
confDir: "/etc/amnezia/amneziawg",
|
||
subnet: "10.9",
|
||
serverIp: runtimeConfig.serverIp,
|
||
serverPort: runtimeConfig.serverPort,
|
||
serverName: runtimeConfig.serverName,
|
||
dns1: "1.1.1.1",
|
||
dns2: "1.0.0.1",
|
||
mtu: 1376,
|
||
keepalive: KEEPALIVE_BY_GEN[AWG_GEN],
|
||
awgParams: AWG_PARAMS,
|
||
gen: AWG_GEN,
|
||
// Мутируются в restartAwg() — единственном месте, где модуль может
|
||
// реально смениться в течение жизни процесса.
|
||
awgModule: AWG_VERSIONS.module,
|
||
awgTools: AWG_VERSIONS.tools,
|
||
};
|
||
|
||
interface UserRow {
|
||
name: string;
|
||
ip: string;
|
||
pub_key: string;
|
||
vpn_key: string;
|
||
psk_key: string;
|
||
key_gen: string;
|
||
vpn_key_prev: string;
|
||
}
|
||
|
||
interface PeerRow {
|
||
pub_key: string;
|
||
ip: string;
|
||
psk_key: string;
|
||
owner: string;
|
||
created_at: number;
|
||
}
|
||
|
||
const stmts = {
|
||
peersAll: db.prepare<[], PeerRow>("SELECT * FROM peers ORDER BY created_at, rowid"),
|
||
peerGet: db.prepare<[string], PeerRow>("SELECT * FROM peers WHERE pub_key = ?"),
|
||
peerInsert: db.prepare<[string, string, string, string, number]>("INSERT INTO peers (pub_key, ip, psk_key, owner, created_at) VALUES (?, ?, ?, ?, ?)"),
|
||
peerDelete: db.prepare<[string]>("DELETE FROM peers WHERE pub_key = ?"),
|
||
peerRekey: db.prepare<[string, string]>("UPDATE peers SET pub_key = ? WHERE pub_key = ?"),
|
||
peerPsk: db.prepare<[string, string]>("UPDATE peers SET psk_key = ? WHERE pub_key = ?"),
|
||
peerOwner: db.prepare<[string, string]>("UPDATE peers SET owner = ? WHERE pub_key = ?"),
|
||
userPubTaken: db.prepare<[string], { n: number }>("SELECT COUNT(*) AS n FROM users WHERE pub_key = ?"),
|
||
get: db.prepare<[string], UserRow>("SELECT * FROM users WHERE name = ?"),
|
||
all: db.prepare<[], UserRow>("SELECT * FROM users"),
|
||
insert: db.prepare<[string, string, string, string, string, string]>("INSERT INTO users (name, ip, pub_key, vpn_key, psk_key, key_gen) VALUES (?, ?, ?, ?, ?, ?)"),
|
||
delete: db.prepare<[string]>("DELETE FROM users WHERE name = ?"),
|
||
ips: db.prepare<[], { ip: string }>("SELECT ip FROM users UNION SELECT ip FROM peers"),
|
||
// Перевыпуск: старый блоб уезжает в vpn_key_prev, pub_key/psk_key могут
|
||
// смениться, если исходный ключ не удалось разобрать.
|
||
reissue: db.prepare<[string, string, string, string, string]>(
|
||
"UPDATE users SET vpn_key_prev = vpn_key, vpn_key = ?, pub_key = ?, psk_key = ?, key_gen = ? WHERE name = ?",
|
||
),
|
||
};
|
||
|
||
function run(cmd: string): string {
|
||
return execSync(cmd, { encoding: "utf8" }).trim();
|
||
}
|
||
|
||
function generateKeys() {
|
||
const privateKey = run("umask 077 && awg genkey");
|
||
const r = spawnSync("awg", ["pubkey"], { input: privateKey, encoding: "utf8" });
|
||
if (r.status !== 0) throw new Error("awg pubkey завершился с ошибкой");
|
||
const publicKey = (r.stdout as string).trim();
|
||
const presharedKey = run("awg genpsk");
|
||
return { privateKey, publicKey, presharedKey };
|
||
}
|
||
|
||
function getServerPublicKey(): string {
|
||
const f = path.join(CONFIG.confDir, "server_public.key");
|
||
if (!existsSync(f)) throw new Error("server_public.key не найден");
|
||
return readFileSync(f, "utf8").trim();
|
||
}
|
||
|
||
function nextIp(): string {
|
||
const usedIps = new Set(stmts.ips.all().map((r: { ip: string }) => r.ip));
|
||
for (let c = 0; c <= 255; c++)
|
||
for (let d = 2; d <= 254; d++) {
|
||
const ip = `${CONFIG.subnet}.${c}.${d}`;
|
||
if (!usedIps.has(ip)) return ip;
|
||
}
|
||
throw new Error("Подсеть заполнена");
|
||
}
|
||
|
||
// Официальный формат .conf: PrivateKey → AWG params (Jc,S,H,I) → 3.x-ключи →
|
||
// Address → DNS. Порядок 3.x-блока взят из client/server_scripts/awg/template.conf
|
||
// клиента AmneziaVPN; пустые ключи не выводятся вовсе — тогда конфиг остаётся
|
||
// ровно тем же 2.0-конфигом, что и до появления поддержки 3.1.
|
||
// ВНИМАНИЕ: пустые I2–I5 должны выводиться как «I2 = » с ОДНИМ хвостовым пробелом
|
||
// (так в рабочих ключах Amnezia). Пробел даётся через ${" "}, чтобы его не срезали
|
||
// ни IDE (strip trailing whitespace), ни инструменты правки. Не «чистить»!
|
||
function buildClientConf(
|
||
keys: ReturnType<typeof generateKeys>,
|
||
ip: string,
|
||
serverPub: string,
|
||
): string {
|
||
const p = CONFIG.awgParams;
|
||
const awg3 = AWG3_KEYS.filter(k => p[k]).map(k => `${k} = ${p[k]}\n`).join("");
|
||
return `[Interface]
|
||
PrivateKey = ${keys.privateKey}
|
||
Jc = ${p.Jc}
|
||
Jmin = ${p.Jmin}
|
||
Jmax = ${p.Jmax}
|
||
S1 = ${p.S1}
|
||
S2 = ${p.S2}
|
||
S3 = ${p.S3}
|
||
S4 = ${p.S4}
|
||
H1 = ${p.H1}
|
||
H2 = ${p.H2}
|
||
H3 = ${p.H3}
|
||
H4 = ${p.H4}
|
||
I1 = ${p.I1}
|
||
I2 =${" "}
|
||
I3 =${" "}
|
||
I4 =${" "}
|
||
I5 =${" "}
|
||
${awg3}Address = ${ip}/32
|
||
DNS = ${CONFIG.dns1}, ${CONFIG.dns2}
|
||
|
||
[Peer]
|
||
PublicKey = ${serverPub}
|
||
PresharedKey = ${keys.presharedKey}
|
||
AllowedIPs = 0.0.0.0/0, ::/0
|
||
Endpoint = ${CONFIG.serverIp}:${CONFIG.serverPort}
|
||
PersistentKeepalive = ${CONFIG.keepalive}
|
||
`;
|
||
}
|
||
|
||
function encodeVpnKey(
|
||
keys: ReturnType<typeof generateKeys>,
|
||
ip: string,
|
||
serverPub: string,
|
||
): string {
|
||
const p = CONFIG.awgParams;
|
||
const clientConf = buildClientConf(keys, ip, serverPub);
|
||
|
||
// Ключи в объектах идут в том же ASCII-алфавитном порядке, в каком их
|
||
// сериализует QJsonObject клиента AmneziaVPN. Незаданные 3.x-ключи
|
||
// выбрасываются в dropEmptyAwg3 — на 2.0 объекты остаются прежними байт-в-байт.
|
||
const dropEmptyAwg3 = <T extends Record<string, unknown>>(o: T): T => {
|
||
for (const k of AWG3_KEYS) if (!p[k]) delete o[k];
|
||
return o;
|
||
};
|
||
|
||
const lastConfigObj = dropEmptyAwg3({
|
||
ContentPaddingAddition: p.ContentPaddingAddition,
|
||
DisableCookies: p.DisableCookies,
|
||
H1: p.H1, H2: p.H2, H3: p.H3, H4: p.H4,
|
||
HeaderProtectionKey: p.HeaderProtectionKey,
|
||
I1: p.I1, I2: "", I3: "", I4: "", I5: "",
|
||
Jc: String(p.Jc),
|
||
Jmax: String(p.Jmax),
|
||
Jmin: String(p.Jmin),
|
||
KeepaliveTimeout: p.KeepaliveTimeout,
|
||
MaxHandshakeAttempts: p.MaxHandshakeAttempts,
|
||
RandomTrailers: p.RandomTrailers,
|
||
RejectAfterTime: p.RejectAfterTime,
|
||
RekeyAfterTime: p.RekeyAfterTime,
|
||
RekeyTimeout: p.RekeyTimeout,
|
||
S1: String(p.S1), S2: String(p.S2), S3: String(p.S3), S4: String(p.S4),
|
||
allowed_ips: ["0.0.0.0/0", "::/0"],
|
||
clientId: keys.publicKey,
|
||
client_ip: ip,
|
||
client_priv_key: keys.privateKey,
|
||
client_pub_key: keys.publicKey,
|
||
config: clientConf,
|
||
hostName: CONFIG.serverIp,
|
||
mtu: String(CONFIG.mtu),
|
||
persistent_keep_alive: String(CONFIG.keepalive),
|
||
port: CONFIG.serverPort,
|
||
psk_key: keys.presharedKey,
|
||
server_pub_key: serverPub,
|
||
});
|
||
|
||
const json = JSON.stringify({
|
||
containers: [{
|
||
container: "amnezia-awg2",
|
||
awg: dropEmptyAwg3({
|
||
ContentPaddingAddition: p.ContentPaddingAddition,
|
||
DisableCookies: p.DisableCookies,
|
||
H1: p.H1, H2: p.H2, H3: p.H3, H4: p.H4,
|
||
HeaderProtectionKey: p.HeaderProtectionKey,
|
||
I1: p.I1, I2: "", I3: "", I4: "", I5: "",
|
||
Jc: String(p.Jc),
|
||
Jmax: String(p.Jmax),
|
||
Jmin: String(p.Jmin),
|
||
KeepaliveTimeout: p.KeepaliveTimeout,
|
||
MaxHandshakeAttempts: p.MaxHandshakeAttempts,
|
||
RandomTrailers: p.RandomTrailers,
|
||
RejectAfterTime: p.RejectAfterTime,
|
||
RekeyAfterTime: p.RekeyAfterTime,
|
||
RekeyTimeout: p.RekeyTimeout,
|
||
S1: String(p.S1), S2: String(p.S2),
|
||
S3: String(p.S3), S4: String(p.S4),
|
||
last_config: JSON.stringify(lastConfigObj, null, 2),
|
||
port: String(CONFIG.serverPort),
|
||
protocol_version: CONFIG.gen,
|
||
subnet_address: `${CONFIG.subnet}.0.0`,
|
||
transport_proto: "udp",
|
||
}),
|
||
}],
|
||
defaultContainer: "amnezia-awg2",
|
||
description: CONFIG.serverName,
|
||
dns1: CONFIG.dns1,
|
||
dns2: CONFIG.dns2,
|
||
hostName: CONFIG.serverIp,
|
||
nameOverriddenByUser: true,
|
||
});
|
||
|
||
const jsonBuf = Buffer.from(json, "utf8");
|
||
const compressed = zlib.deflateSync(jsonBuf);
|
||
const header = Buffer.alloc(4);
|
||
header.writeUInt32BE(jsonBuf.length, 0);
|
||
return "vpn://" + Buffer.concat([header, compressed])
|
||
.toString("base64url")
|
||
.replace(/=+$/, "");
|
||
}
|
||
|
||
// Обратная к encodeVpnKey: vpn:// → base64url → снять 4-байтовый BE-заголовок
|
||
// длины → inflate → JSON. Приватный ключ клиента больше нигде не хранится, поэтому
|
||
// это единственный способ перевыпустить ключ, не меняя личность пира.
|
||
function decodeVpnKey(vpnKey: string): any | null {
|
||
try {
|
||
const buf = Buffer.from(vpnKey.replace(/^vpn:\/\//, ""), "base64url");
|
||
if (buf.length <= 4) return null;
|
||
return JSON.parse(zlib.inflateSync(buf.subarray(4)).toString("utf8"));
|
||
} catch {
|
||
return null;
|
||
}
|
||
}
|
||
|
||
function clientPrivKeyFrom(vpnKey: string): string | null {
|
||
const lastConfig = decodeVpnKey(vpnKey)?.containers?.[0]?.awg?.last_config;
|
||
if (typeof lastConfig !== "string") return null;
|
||
try {
|
||
const priv = JSON.parse(lastConfig).client_priv_key;
|
||
return typeof priv === "string" && priv ? priv : null;
|
||
} catch {
|
||
return null;
|
||
}
|
||
}
|
||
|
||
interface ReissueResult { total: number; reissued: number; regenerated: string[]; backup: string }
|
||
|
||
// Перевыпуск всех vpn:// ключей на текущих параметрах интерфейса. Нужен после
|
||
// смены поколения (2.0 → 3.1): старые ключи собраны на старых параметрах и
|
||
// перестают работать. IP, pub_key и psk_key сохраняются — на проводе ничего не
|
||
// меняется, клиенту достаточно заново импортировать ключ.
|
||
function reissueAll(): ReissueResult {
|
||
const users = stmts.all.all();
|
||
const serverPub = getServerPublicKey();
|
||
const backup = `${dbPath}.bak-${new Date().toISOString().replace(/[:.]/g, "-")}`;
|
||
db.prepare("VACUUM INTO ?").run(backup);
|
||
logger.info("reissue: db backed up", { backup, users: users.length });
|
||
|
||
const regenerated: string[] = [];
|
||
let reissued = 0;
|
||
|
||
for (const u of users) {
|
||
const priv = clientPrivKeyFrom(u.vpn_key);
|
||
let keys: ReturnType<typeof generateKeys>;
|
||
|
||
if (priv) {
|
||
keys = { privateKey: priv, publicKey: u.pub_key, presharedKey: u.psk_key };
|
||
} else {
|
||
// Блоб не разобрался — личность пира восстановить неоткуда, выдаём новую.
|
||
logger.warn("reissue: vpn_key не декодируется, генерируем новую пару", { name: u.name });
|
||
keys = generateKeys();
|
||
spawnSync("awg", ["set", CONFIG.interface, "peer", u.pub_key, "remove"]);
|
||
const r = setPeer(keys.publicKey, keys.presharedKey, u.ip);
|
||
if (r.status !== 0) {
|
||
logger.error("reissue: awg set failed", { name: u.name, stderr: r.stderr?.toString() });
|
||
continue;
|
||
}
|
||
regenerated.push(u.name);
|
||
}
|
||
|
||
stmts.reissue.run(
|
||
encodeVpnKey(keys, u.ip, serverPub),
|
||
keys.publicKey, keys.presharedKey, CONFIG.gen, u.name,
|
||
);
|
||
reissued++;
|
||
}
|
||
|
||
syncPeers();
|
||
logger.info("reissue: done", { total: users.length, reissued, regenerated: regenerated.length });
|
||
return { total: users.length, reissued, regenerated, backup };
|
||
}
|
||
|
||
function getPeersData(): Record<string, { online: boolean; lastHandshake: number; rx: number; tx: number }> {
|
||
try {
|
||
const output = run(`awg show ${CONFIG.interface} dump`);
|
||
const result: Record<string, { online: boolean; lastHandshake: number; rx: number; tx: number }> = {};
|
||
const now = Math.floor(Date.now() / 1000);
|
||
const lines = output.split("\n");
|
||
for (let i = 1; i < lines.length; i++) {
|
||
const parts = lines[i].split("\t");
|
||
const pubKey = parts[0];
|
||
if (!pubKey) continue;
|
||
const lastHandshake = Number(parts[4]);
|
||
const rx = Number(parts[5]);
|
||
const tx = Number(parts[6]);
|
||
result[pubKey] = {
|
||
online: lastHandshake > 0 && (now - lastHandshake) < 180,
|
||
lastHandshake, rx, tx,
|
||
};
|
||
}
|
||
return result;
|
||
} catch (e) { logger.warn("getPeersData failed", { error: e }); return {}; }
|
||
}
|
||
|
||
// Шейпинг (CAKE) и сэмплер тяжёлых устройств. Счётчики читаем асинхронно: цикл
|
||
// не должен блокировать event loop, как это делают остальные вызовы awg.
|
||
const shaping = createShaping({
|
||
iface: CONFIG.interface,
|
||
getCfg, setCfg, logger,
|
||
// CAKE видит только внутренний IP-пакет, на проводе к нему добавляются
|
||
// IPv4 (20) + UDP (8) + заголовок WG (32) = 60 байт и случайный префикс S4.
|
||
// Формулу сверять iperf3-замером на стенде (SHAPE_OVERHEAD перекрывает её).
|
||
overhead: () => 60 + (Number(CONFIG.awgParams.S4) || 0),
|
||
peers: () => new Promise((resolve, reject) => {
|
||
execFile("awg", ["show", CONFIG.interface, "dump"], { encoding: "utf8", timeout: 10_000 }, (err, out) => {
|
||
if (err) { reject(err); return; }
|
||
const rows = out.split("\n").slice(1).map(l => l.split("\t"))
|
||
.filter(f => f[0] && f[3])
|
||
.map(f => ({ ip: f[3].split(",")[0].split("/")[0], rx: Number(f[5]) || 0, tx: Number(f[6]) || 0 }));
|
||
resolve(rows);
|
||
});
|
||
}),
|
||
});
|
||
|
||
function rebuildConf() {
|
||
const users = db.prepare("SELECT name, ip, pub_key, psk_key FROM users").all() as UserRow[];
|
||
const devices = stmts.peersAll.all();
|
||
const confFile = path.join(CONFIG.confDir, `${CONFIG.interface}.conf`);
|
||
if (!existsSync(confFile)) return;
|
||
|
||
const conf = readFileSync(confFile, "utf8");
|
||
const iface = conf.split(/^\[Peer\]/m)[0].trimEnd();
|
||
// Без записей в peers вывод байт-в-байт прежний.
|
||
const peers = [
|
||
...users.map(u => ({ label: u.name, ...u })),
|
||
...devices.map(d => ({ label: d.owner || "device", ...d })),
|
||
].map(u =>
|
||
`\n# ${u.label}\n[Peer]\nPublicKey = ${u.pub_key}\nPresharedKey = ${u.psk_key}\nAllowedIPs = ${u.ip}/32\nPersistentKeepalive = ${CONFIG.keepalive}`
|
||
).join("\n");
|
||
|
||
writeFileSync(confFile, iface + "\n" + peers + "\n");
|
||
logger.info("conf rebuilt", { peers: users.length + devices.length });
|
||
}
|
||
|
||
const SERVER_PRIV_KEY_FILE = "/etc/amnezia/server_private.key";
|
||
|
||
const AWGQUICK_ONLY_KEY = /^\s*(Address|DNS|MTU|Table|PreUp|PostUp|PreDown|PostDown|SaveConfig)\s*=/i;
|
||
|
||
// Готовит «stripped»-конфиг для `awg syncconf`: берёт awg1.conf, выкидывает
|
||
// awg-quick-ключи и оставляет [Interface] (PrivateKey + Jc/S/H + ListenPort) и
|
||
// [Peer]-блоки.
|
||
// 🛑 КРИТИЧНО: [Interface] с PrivateKey ОБЯЗАН попасть в этот конфиг. Раньше
|
||
// syncPeers отдавал в syncconf только [Peer]-блоки — и AmneziaWG обнулял
|
||
// приватный ключ интерфейса и параметры обфускации, после чего сервер
|
||
// поднимался с public-key=(none) и ВСЕ клиенты отваливались.
|
||
// PrivateKey подставляем из server_private.key — это та же идентичность, что в
|
||
// server_public.key (его зашивают в vpn:// ключи клиентов) и в PostUp.
|
||
function buildSyncConf(): string {
|
||
const confFile = path.join(CONFIG.confDir, `${CONFIG.interface}.conf`);
|
||
const priv = readFileSync(SERVER_PRIV_KEY_FILE, "utf8").trim();
|
||
const out: string[] = [];
|
||
let privReplaced = false;
|
||
for (const line of readFileSync(confFile, "utf8").split("\n")) {
|
||
if (AWGQUICK_ONLY_KEY.test(line)) continue;
|
||
if (/^\s*PrivateKey\s*=/.test(line)) {
|
||
out.push(`PrivateKey = ${priv}`);
|
||
privReplaced = true;
|
||
continue;
|
||
}
|
||
out.push(line);
|
||
}
|
||
if (!privReplaced) {
|
||
const idx = out.findIndex(l => /^\s*\[Interface\]/.test(l));
|
||
if (idx >= 0) out.splice(idx + 1, 0, `PrivateKey = ${priv}`);
|
||
}
|
||
return out.join("\n");
|
||
}
|
||
|
||
function syncPeers() {
|
||
rebuildConf();
|
||
const tmpFile = `/tmp/awg_sync_${Date.now()}.conf`;
|
||
try {
|
||
writeFileSync(tmpFile, buildSyncConf(), { mode: 0o600 });
|
||
const r = spawnSync("awg", ["syncconf", CONFIG.interface, tmpFile]);
|
||
if (r.status !== 0) logger.warn("syncPeers syncconf failed", { stderr: r.stderr?.toString() });
|
||
} finally {
|
||
try { fs.unlinkSync(tmpFile); } catch {}
|
||
}
|
||
const n = (db.prepare("SELECT COUNT(*) AS n FROM users").get() as { n: number }).n;
|
||
logger.info("peers synced", { count: n });
|
||
}
|
||
|
||
function getInterfaceStatus(): { up: boolean; peers: number; publicKey: string | null } {
|
||
const r = spawnSync("awg", ["show", CONFIG.interface]);
|
||
if (r.status !== 0) return { up: false, peers: 0, publicKey: null };
|
||
const output = r.stdout.toString();
|
||
const peers = (output.match(/^peer:/gm) ?? []).length;
|
||
const publicKey = output.match(/public key:\s*(.+)/)?.[1]?.trim() ?? null;
|
||
return { up: true, peers, publicKey };
|
||
}
|
||
|
||
function ensureInterfaceUp() {
|
||
const { up } = getInterfaceStatus();
|
||
if (!up) throw new Error(`Interface ${CONFIG.interface} is not up. Run: awg-quick up ${CONFIG.interface}`);
|
||
}
|
||
|
||
// Параметры обфускации и поколение живут в awg1.conf, а не в процессе:
|
||
// перечитываем их после любой правки конфига. Иначе awg-ctrl продолжит
|
||
// собирать vpn:// ключи на старых параметрах — например, на 2.0 уже после
|
||
// перехода интерфейса на 3.1.
|
||
function reloadAwgParams(): "2" | "3.1" {
|
||
CONFIG.awgParams = readAwgParams();
|
||
CONFIG.gen = genOf(CONFIG.awgParams);
|
||
CONFIG.keepalive = KEEPALIVE_BY_GEN[CONFIG.gen];
|
||
return CONFIG.gen;
|
||
}
|
||
|
||
function restartAwg() {
|
||
logger.info("AWG restart: down");
|
||
const down = spawnSync("awg-quick", ["down", CONFIG.interface]);
|
||
if (down.status !== 0) logger.warn("awg-quick down failed", { stderr: down.stderr?.toString() });
|
||
logger.info("AWG restart: up");
|
||
const up = spawnSync("awg-quick", ["up", CONFIG.interface]);
|
||
if (up.status !== 0) throw new Error(`awg-quick up failed: ${up.stderr?.toString()}`);
|
||
// Конфиг мог измениться, пока интерфейс лежал (переход на 3.1, ручная
|
||
// правка awg1.conf) — перечитываем ДО syncPeers: keepalive из CONFIG уходит
|
||
// в [Peer]-блоки, которые rebuildConf() пересобирает прямо сейчас.
|
||
const gen = reloadAwgParams();
|
||
syncPeers();
|
||
void shaping.apply(); // tc-правила жили на интерфейсе, который мы только что пересоздали
|
||
const versions = readAwgVersions();
|
||
CONFIG.awgModule = versions.module;
|
||
CONFIG.awgTools = versions.tools;
|
||
logger.info("AWG restart: done", { ...versions, gen });
|
||
}
|
||
|
||
// ─────────────────────────── переход 2.0 → 3.1 ───────────────────────────
|
||
// 3.1 — основное поколение (install.sh ставит его по умолчанию). Сервера,
|
||
// установленные раньше, переводятся отсюда, без переустановки: панель дёргает
|
||
// POST /awg/upgrade.
|
||
|
||
// Header protection использует библиотечный chacha-API (chacha_init/
|
||
// chacha20_crypt), которого нет до ядра 5.5 — там модуль 3.x просто не
|
||
// соберётся (upstream issue #210).
|
||
function kernelSupportsHeaderProtection(): boolean {
|
||
const [maj, min] = os.release().split(".").map(n => Number.parseInt(n, 10));
|
||
if (!Number.isFinite(maj) || !Number.isFinite(min)) return false;
|
||
return maj > 5 || (maj === 5 && min >= 5);
|
||
}
|
||
|
||
// Пред-проверка перед тем, как трогать конфиг: решает ЗАГРУЖЕННЫЙ модуль
|
||
// (readAwgVersions читает /sys/module/amneziawg/version), а не тот, что лежит
|
||
// на диске после apt — обслуживает интерфейс именно загруженный.
|
||
function checkGen31Support(): string | null {
|
||
const { module } = readAwgVersions();
|
||
if (!module.startsWith("3."))
|
||
return `В ядре загружен модуль amneziawg ${module || "неизвестной версии"} — для 3.1 нужна 3.x. `
|
||
+ "Обнови пакет (apt) и перезагрузи сервер, затем повтори переход.";
|
||
if (!kernelSupportsHeaderProtection())
|
||
return `Ядро ${os.release()} старше 5.5 — header protection в нём не работает (upstream issue #210).`;
|
||
return null;
|
||
}
|
||
|
||
const AWG3_KEY_LINE = new RegExp(`^\\s*(${AWG3_KEYS.join("|")})\\s*=`);
|
||
|
||
// Готовит текст awg1.conf для 3.1: выкидывает старые 3.x-строки (конфиг могли
|
||
// править руками), поднимает S1–S4 до допустимых при header protection и
|
||
// дописывает 3.x-блок в конец [Interface]. [Peer]-блоки не трогаются —
|
||
// личности пиров переход не меняет.
|
||
function confWithGen31(conf: string, headerKey: string): { conf: string; bumpedS: string[] } {
|
||
const peerAt = conf.search(/^\[Peer\]/m);
|
||
let rest = peerAt >= 0 ? conf.slice(peerAt) : "";
|
||
const head = (peerAt >= 0 ? conf.slice(0, peerAt) : conf)
|
||
.split("\n")
|
||
.filter(l => !AWG3_KEY_LINE.test(l));
|
||
|
||
// Пустые строки и «# имя» в хвосте [Interface] относятся уже к первому
|
||
// [Peer] (их пишет rebuildConf) — отделяем, чтобы 3.x-строки встали внутрь
|
||
// [Interface], а не между комментарием и его пиром.
|
||
const tail: string[] = [];
|
||
while (head.length && (head[head.length - 1].trim() === "" || head[head.length - 1].trim().startsWith("#")))
|
||
tail.unshift(head.pop()!);
|
||
rest = tail.join("\n").trim() ? `${tail.join("\n").trim()}\n${rest}` : rest;
|
||
|
||
let iface = head.join("\n");
|
||
|
||
// S ниже 12 (или вовсе отсутствующий) ядро с header protection не примет.
|
||
// Правка безопасна ровно потому, что следом идёт перевыпуск ключей: обе
|
||
// стороны получают новые значения одновременно.
|
||
const bumpedS: string[] = [];
|
||
for (const k of ["S1", "S2", "S3", "S4"] as const) {
|
||
const re = new RegExp(`^\\s*${k}\\s*=\\s*(\\d+)\\s*$`, "m");
|
||
const cur = Number(iface.match(re)?.[1]);
|
||
if (Number.isFinite(cur) && cur >= MIN_S_FOR_HEADER_PROTECTION) continue;
|
||
const val = Math.max(DEFAULT_AWG_PARAMS[k], MIN_S_FOR_HEADER_PROTECTION);
|
||
iface = re.test(iface)
|
||
? iface.replace(re, `${k} = ${val}`)
|
||
: `${iface.trimEnd()}\n${k} = ${val}`;
|
||
bumpedS.push(`${k}: ${Number.isFinite(cur) ? cur : "нет"} → ${val}`);
|
||
}
|
||
|
||
const awg3 = [
|
||
`HeaderProtectionKey = ${headerKey}`,
|
||
...Object.entries(AWG31_DEFAULTS).map(([k, v]) => `${k} = ${v}`),
|
||
].join("\n");
|
||
|
||
return { conf: `${iface.trimEnd()}\n${awg3}\n${rest ? `\n${rest}` : ""}`, bumpedS };
|
||
}
|
||
|
||
interface UpgradeResult { gen: "2" | "3.1"; backup: string; bumpedS: string[]; reissue: ReissueResult }
|
||
|
||
// Перевод интерфейса на 3.1. Единственная настоящая проверка, что ядро приняло
|
||
// параметры, — подъём интерфейса, поэтому шаги такие: бэкап конфига → запись
|
||
// 3.1 → restartAwg() (он же перечитает параметры) → перевыпуск ключей. Если
|
||
// ядро отказало, возвращаем прежний конфиг и поднимаем интерфейс обратно:
|
||
// операция либо применяется целиком, либо не оставляет следов.
|
||
function upgradeToGen31(): UpgradeResult {
|
||
const confFile = path.join(CONFIG.confDir, `${CONFIG.interface}.conf`);
|
||
const before = readFileSync(confFile, "utf8");
|
||
const backup = `${confFile}.bak-${new Date().toISOString().replace(/[:.]/g, "-")}`;
|
||
writeFileSync(backup, before, { mode: 0o600 });
|
||
|
||
const { conf, bumpedS } = confWithGen31(before, run("awg genpsk"));
|
||
writeFileSync(confFile, conf, { mode: 0o600 });
|
||
logger.info("upgrade: conf rewritten for 3.1", { backup, bumpedS });
|
||
|
||
try {
|
||
restartAwg();
|
||
if (CONFIG.gen !== "3.1") throw new Error("интерфейс поднялся, но конфиг всё ещё 2.0");
|
||
} catch (e) {
|
||
logger.error("upgrade: kernel rejected 3.1, rolling back", { error: e });
|
||
writeFileSync(confFile, before, { mode: 0o600 });
|
||
try { restartAwg(); } catch (e2) { logger.error("upgrade: rollback restart failed", { error: e2 }); }
|
||
throw new Error(
|
||
`Ядро не приняло конфиг 3.1 — вернули прежний (копия: ${backup}). `
|
||
+ 'Причина видна в dmesg после `echo "module amneziawg +p" > /sys/kernel/debug/dynamic_debug/control`.',
|
||
);
|
||
}
|
||
|
||
// Ключи, выданные на 2.0-параметрах, после смены поколения не подключатся,
|
||
// поэтому перевыпускаем сразу — сервер не должен оставаться в состоянии
|
||
// «3.1 поднят, у всех нерабочие ключи». Личности пиров сохраняются.
|
||
const reissue = reissueAll();
|
||
logger.info("upgrade: done", { gen: CONFIG.gen, reissued: reissue.reissued, bumpedS });
|
||
return { gen: CONFIG.gen, backup, bumpedS, reissue };
|
||
}
|
||
|
||
function startInterface() {
|
||
const status = getInterfaceStatus();
|
||
if (status.up) { logger.info("AWG already up", { peers: status.peers }); return status; }
|
||
const r = spawnSync("awg-quick", ["up", CONFIG.interface]);
|
||
if (r.status !== 0) throw new Error(`awg-quick up failed: ${r.stderr?.toString()}`);
|
||
syncPeers();
|
||
void shaping.apply();
|
||
return getInterfaceStatus();
|
||
}
|
||
|
||
// PSK уходит во временный файл, а не в аргументы: иначе он виден в /proc/<pid>/cmdline.
|
||
function setPeer(pubKey: string, psk: string, ip: string) {
|
||
const tmpPsk = `/tmp/awg_psk_${Date.now()}.tmp`;
|
||
writeFileSync(tmpPsk, psk, { mode: 0o600 });
|
||
try {
|
||
return spawnSync("awg", [
|
||
"set", CONFIG.interface, "peer", pubKey,
|
||
"preshared-key", tmpPsk,
|
||
"allowed-ips", `${ip}/32`,
|
||
"persistent-keepalive", CONFIG.keepalive,
|
||
]);
|
||
} finally {
|
||
try { fs.unlinkSync(tmpPsk); } catch {}
|
||
}
|
||
}
|
||
|
||
function addUser(username: string): UserRow {
|
||
const keys = generateKeys();
|
||
const serverPub = getServerPublicKey();
|
||
|
||
const ip = db.transaction(() => {
|
||
const ip = nextIp();
|
||
stmts.insert.run(username, ip, keys.publicKey, "", keys.presharedKey, CONFIG.gen);
|
||
return ip;
|
||
})();
|
||
|
||
const vpn_key = encodeVpnKey(keys, ip, serverPub);
|
||
db.prepare("UPDATE users SET vpn_key = ? WHERE name = ?").run(vpn_key, username);
|
||
|
||
const r = setPeer(keys.publicKey, keys.presharedKey, ip);
|
||
if (r.status !== 0) {
|
||
stmts.delete.run(username);
|
||
throw new Error(`awg set failed: ${r.stderr?.toString()}`);
|
||
}
|
||
|
||
rebuildConf();
|
||
logger.info("user created", { name: username, ip, gen: CONFIG.gen });
|
||
return {
|
||
name: username, ip, pub_key: keys.publicKey, vpn_key,
|
||
psk_key: keys.presharedKey, key_gen: CONFIG.gen, vpn_key_prev: "",
|
||
};
|
||
}
|
||
|
||
// Снять пира с интерфейса и убедиться, что его там нет. Раньше результат `awg set … remove`
|
||
// не проверялся: строку из базы удаляли, а пир в ядре оставался живым, и про него уже никто не
|
||
// знал. Теперь порядок такой: сначала ядро, потом база — при отказе строка остаётся, и
|
||
// повторная попытка (надгробие панели, следующий sync) найдёт пира.
|
||
function kernelPeers(): Set<string> | null {
|
||
const r = spawnSync("awg", ["show", CONFIG.interface, "peers"]);
|
||
return r.status === 0 ? new Set(r.stdout.toString().split("\n").map(l => l.trim()).filter(Boolean)) : null;
|
||
}
|
||
|
||
function dropFromKernel(pub: string): boolean {
|
||
const r = spawnSync("awg", ["set", CONFIG.interface, "peer", pub, "remove"]);
|
||
if (r.status === 0) return true;
|
||
const left = kernelPeers();
|
||
if (left && !left.has(pub)) return true; // ответ странный, но пира уже нет
|
||
logger.error("peer remove from kernel failed", { pub, stderr: r.stderr?.toString() });
|
||
return false;
|
||
}
|
||
|
||
function removeUser(username: string) {
|
||
const user = stmts.get.get(username);
|
||
if (!user) throw new Error("Пользователь не найден");
|
||
|
||
if (!dropFromKernel(user.pub_key)) throw new Error("Не удалось снять пира с интерфейса");
|
||
stmts.delete.run(username);
|
||
rebuildConf();
|
||
|
||
for (const ext of [".conf", ".key"]) {
|
||
const f = path.join(CONFIG.confDir, "clients", username + ext);
|
||
if (existsSync(f)) fs.unlinkSync(f);
|
||
}
|
||
logger.info("user removed", { name: username });
|
||
}
|
||
|
||
// ── Пиры устройств (sen://) ────────────────────────────────────────────────
|
||
// awg-ctrl про мастер-ключи ничего не знает: ему приходит «добавь пира с этим
|
||
// публичным ключом». Приватного ключа устройства здесь нет и быть не может.
|
||
class HttpError extends Error {
|
||
constructor(public status: number, message: string) { super(message); }
|
||
}
|
||
|
||
// Публичный ключ WireGuard: base64 от 32 байт (44 символа, последний «=»).
|
||
function checkPubKey(k: unknown): string {
|
||
if (typeof k !== "string" || !/^[A-Za-z0-9+/]{43}=$/.test(k) || Buffer.from(k, "base64").length !== 32)
|
||
throw new HttpError(400, "Неверный публичный ключ");
|
||
return k;
|
||
}
|
||
|
||
// В пути base64url: «/» и «+» обычного base64 в URL ломают маршрут.
|
||
function pubKeyFromParam(p: string): string {
|
||
return checkPubKey(Buffer.from(p, "base64url").toString("base64"));
|
||
}
|
||
|
||
function assertPubKeyFree(pub: string) {
|
||
if (stmts.peerGet.get(pub) || stmts.userPubTaken.get(pub)!.n > 0 || pub === getServerPublicKey())
|
||
throw new HttpError(409, "Публичный ключ уже используется");
|
||
}
|
||
|
||
function addPeer(pubKey: string, owner: string): { ip: string; psk_key: string } {
|
||
checkPubKey(pubKey);
|
||
const psk = run("awg genpsk");
|
||
const ip = db.transaction(() => {
|
||
assertPubKeyFree(pubKey);
|
||
const ip = nextIp();
|
||
stmts.peerInsert.run(pubKey, ip, psk, owner, Math.floor(Date.now() / 1000));
|
||
return ip;
|
||
})();
|
||
|
||
const r = setPeer(pubKey, psk, ip);
|
||
if (r.status !== 0) {
|
||
stmts.peerDelete.run(pubKey);
|
||
throw new Error(`awg set failed: ${r.stderr?.toString()}`);
|
||
}
|
||
rebuildConf();
|
||
logger.info("peer added", { owner, ip });
|
||
return { ip, psk_key: psk };
|
||
}
|
||
|
||
// Смена ключа устройства: IP и PSK остаются, меняется только pub_key.
|
||
function replacePeer(oldPub: string, newPub: string): { ip: string; psk_key: string } {
|
||
checkPubKey(newPub);
|
||
const old = stmts.peerGet.get(oldPub);
|
||
if (!old) throw new HttpError(404, "Пир не найден");
|
||
db.transaction(() => { assertPubKeyFree(newPub); stmts.peerRekey.run(newPub, oldPub); })();
|
||
|
||
const r = setPeer(newPub, old.psk_key, old.ip);
|
||
if (r.status !== 0) {
|
||
stmts.peerRekey.run(oldPub, newPub);
|
||
throw new Error(`awg set failed: ${r.stderr?.toString()}`);
|
||
}
|
||
// Старый ключ не снялся — пир остаётся «призраком» в ядре до аудита панели; смену ключа не откатываем:
|
||
// новый уже стоит, а клиент к этому моменту получил бы ошибку.
|
||
if (!dropFromKernel(oldPub)) logger.error("peer rekey: старый ключ остался в ядре", { owner: old.owner });
|
||
rebuildConf();
|
||
logger.info("peer rekeyed", { owner: old.owner, ip: old.ip });
|
||
return { ip: old.ip, psk_key: old.psk_key };
|
||
}
|
||
|
||
function rotatePeerPsk(pub: string): { ip: string; psk_key: string } {
|
||
const peer = stmts.peerGet.get(pub);
|
||
if (!peer) throw new HttpError(404, "Пир не найден");
|
||
const psk = run("awg genpsk");
|
||
const r = setPeer(pub, psk, peer.ip);
|
||
if (r.status !== 0) throw new Error(`awg set failed: ${r.stderr?.toString()}`);
|
||
stmts.peerPsk.run(psk, pub);
|
||
rebuildConf();
|
||
logger.info("peer psk rotated", { owner: peer.owner });
|
||
return { ip: peer.ip, psk_key: psk };
|
||
}
|
||
|
||
function removePeer(pub: string) {
|
||
const peer = stmts.peerGet.get(pub);
|
||
if (!peer) throw new HttpError(404, "Пир не найден");
|
||
if (!dropFromKernel(pub)) throw new Error("Не удалось снять пира с интерфейса");
|
||
stmts.peerDelete.run(pub);
|
||
rebuildConf();
|
||
logger.info("peer removed", { owner: peer.owner });
|
||
}
|
||
|
||
// Сведение пиров одной панели: панель присылает полный список ключей, которые ей нужны
|
||
// на этом сервере, — всё остальное из её области («<panel>/…») снимается. Удаляем только
|
||
// по такому явному списку, никогда по времени или неактивности: панель не на связи —
|
||
// ничего не происходит. Пиры без области (owner «m1/d2», выданы до областей) панель
|
||
// забирает себе, только если их ключ есть в её списке; остальные не трогаем — чьи они,
|
||
// уже не разобрать.
|
||
const PANEL_ID = /^[a-z0-9]{8,16}$/;
|
||
const LEGACY_OWNER = /^m\d+\/d\d+$/;
|
||
const SYNC_MAX = 10_000;
|
||
|
||
function syncOwnedPeers(panel: string, keep: string[]): {
|
||
present: string[]; removed: number; legacy: { pub_key: string; owner: string; ip: string }[];
|
||
} {
|
||
const want = new Set(keep);
|
||
const prefix = panel + "/";
|
||
const removed: PeerRow[] = [];
|
||
let claimed = 0;
|
||
for (const p of stmts.peersAll.all()) {
|
||
if (p.owner.startsWith(prefix)) {
|
||
// Ядро первым: не снялся — строка остаётся, следующий sync попробует снова.
|
||
if (!want.has(p.pub_key) && dropFromKernel(p.pub_key)) { stmts.peerDelete.run(p.pub_key); removed.push(p); }
|
||
} else if (LEGACY_OWNER.test(p.owner) && want.has(p.pub_key)) {
|
||
stmts.peerOwner.run(prefix + p.owner, p.pub_key);
|
||
claimed++;
|
||
}
|
||
}
|
||
if (removed.length || claimed) rebuildConf();
|
||
if (removed.length) logger.info("peers synced out", { panel, removed: removed.map(p => p.owner) });
|
||
|
||
const all = stmts.peersAll.all();
|
||
return {
|
||
present: all.filter(p => p.owner.startsWith(prefix)).map(p => p.pub_key),
|
||
removed: removed.length,
|
||
legacy: all.filter(p => LEGACY_OWNER.test(p.owner)).map(p => ({ pub_key: p.pub_key, owner: p.owner, ip: p.ip })),
|
||
};
|
||
}
|
||
|
||
const app = express();
|
||
// Сведение пиров несёт полный список ключей панели — ему лимит побольше, остальным хватает 1kb.
|
||
const SYNC_PATH = "/api/peers/sync";
|
||
const jsonSmall = express.json({ limit: "1kb" });
|
||
const jsonSync = express.json({ limit: "512kb" });
|
||
// /api/audit/clean тоже несёт до SYNC_MAX ключей — под 1kb он принимал бы около двадцати.
|
||
const BIG_BODY_PATHS = new Set([SYNC_PATH, "/api/audit/clean"]);
|
||
app.use((req, res, next) => (BIG_BODY_PATHS.has(req.path) ? jsonSync : jsonSmall)(req, res, next));
|
||
|
||
function verifyInternalToken(token: string): boolean {
|
||
try {
|
||
const [h, p, s] = token.split(".");
|
||
if (!h || !p || !s) return false;
|
||
const ok = crypto.verify(null, Buffer.from(`${h}.${p}`), internalAuthPubKey, Buffer.from(s, "base64url"));
|
||
if (!ok) return false;
|
||
const { exp } = JSON.parse(Buffer.from(p, "base64url").toString()) as { exp: number };
|
||
return exp > Math.floor(Date.now() / 1000);
|
||
} catch { return false; }
|
||
}
|
||
|
||
function auth(req: Request, res: Response, next: NextFunction) {
|
||
const header = (req.headers["authorization"] ?? "") as string;
|
||
const token = header.startsWith("Bearer ") ? header.slice(7) : "";
|
||
if (!token || !verifyInternalToken(token)) {
|
||
res.status(401).json({ error: "Неверная авторизация" }); return;
|
||
}
|
||
next();
|
||
}
|
||
|
||
function validateName(req: Request, res: Response, next: NextFunction) {
|
||
const name = req.params.name ?? (req.body as { name?: string }).name;
|
||
if (!name || !/^[a-zA-Z0-9_-]{1,32}$/.test(name)) {
|
||
res.status(400).json({ error: "Имя: буквы, цифры, _ и -, до 32 символов" }); return;
|
||
}
|
||
next();
|
||
}
|
||
|
||
function handler(fn: (req: Request, res: Response) => void | Promise<void>) {
|
||
return async (req: Request, res: Response) => {
|
||
try { await fn(req, res); }
|
||
catch (e) {
|
||
if (e instanceof HttpError) { res.status(e.status).json({ error: e.message }); return; }
|
||
logger.error("handler error", { error: e }); res.status(500).json({ error: "Internal server error" });
|
||
}
|
||
};
|
||
}
|
||
|
||
app.get("/health", (_req, res) => {
|
||
const { up, peers } = getInterfaceStatus();
|
||
res.status(up ? 200 : 503).json({
|
||
status: up ? "ok" : "degraded",
|
||
server: CONFIG.serverName,
|
||
ip: CONFIG.serverIp,
|
||
gen: CONFIG.gen,
|
||
awg: { status: up ? "ok" : "down", peers, module: CONFIG.awgModule, tools: CONFIG.awgTools },
|
||
});
|
||
});
|
||
|
||
app.post("/api/users", auth, validateName, handler((req, res) => {
|
||
const { name } = req.body as { name: string };
|
||
if (stmts.get.get(name)) {
|
||
res.status(409).json({ error: "Пользователь уже существует" }); return;
|
||
}
|
||
res.status(201).json(addUser(name));
|
||
}));
|
||
|
||
app.get("/api/users", auth, handler((_req, res) => {
|
||
const users = db.prepare("SELECT name, ip, pub_key, vpn_key, key_gen FROM users WHERE vpn_key != ''").all() as UserRow[];
|
||
const peers = getPeersData();
|
||
res.json({
|
||
users: users.map(u => ({
|
||
...u,
|
||
online: peers[u.pub_key]?.online ?? false,
|
||
lastHandshake: peers[u.pub_key]?.lastHandshake ?? 0,
|
||
})),
|
||
});
|
||
}));
|
||
|
||
app.get("/api/users/stats", auth, handler((_req, res) => {
|
||
const users = db.prepare("SELECT name, ip, pub_key, key_gen FROM users WHERE vpn_key != ''").all() as UserRow[];
|
||
const peers = getPeersData();
|
||
res.json({
|
||
users: users.map(u => ({
|
||
name: u.name,
|
||
ip: u.ip,
|
||
key_gen: u.key_gen,
|
||
online: peers[u.pub_key]?.online ?? false,
|
||
lastHandshake: peers[u.pub_key]?.lastHandshake ?? 0,
|
||
rx: peers[u.pub_key]?.rx ?? 0,
|
||
tx: peers[u.pub_key]?.tx ?? 0,
|
||
// «normal» | «background»: фоновый — пока канал занят, а устройство давно качает больше своей доли
|
||
priority: shaping.priorityOf(u.ip),
|
||
})),
|
||
});
|
||
}));
|
||
|
||
// ⚠️ Должен быть объявлен ДО «/api/users/:name», иначе тот перехватит «reissue»
|
||
// как имя пользователя.
|
||
app.post("/api/users/reissue", auth, handler((_req, res) => {
|
||
res.json(reissueAll());
|
||
}));
|
||
|
||
app.post("/api/users/:name", auth, validateName, handler((req, res) => {
|
||
const user = stmts.get.get(req.params.name);
|
||
if (!user) { res.status(404).json({ error: "Пользователь не найден" }); return; }
|
||
res.json(user);
|
||
}));
|
||
|
||
app.delete("/api/users/:name", auth, validateName, handler((req, res) => {
|
||
removeUser(req.params.name);
|
||
res.json({ success: true, name: req.params.name });
|
||
}));
|
||
|
||
app.post("/api/peers", auth, handler((req, res) => {
|
||
const { pub_key, owner } = (req.body ?? {}) as { pub_key?: string; owner?: string };
|
||
if (typeof owner !== "string" || !/^[\w/.-]{0,64}$/.test(owner)) throw new HttpError(400, "Неверный owner");
|
||
res.status(201).json(addPeer(checkPubKey(pub_key), owner));
|
||
}));
|
||
|
||
app.get("/api/peers", auth, handler((_req, res) => {
|
||
const stats = getPeersData();
|
||
res.json({
|
||
peers: stmts.peersAll.all().map(p => ({
|
||
pub_key: p.pub_key, ip: p.ip, psk_key: p.psk_key, owner: p.owner,
|
||
online: stats[p.pub_key]?.online ?? false,
|
||
lastHandshake: stats[p.pub_key]?.lastHandshake ?? 0,
|
||
rx: stats[p.pub_key]?.rx ?? 0,
|
||
tx: stats[p.pub_key]?.tx ?? 0,
|
||
priority: shaping.priorityOf(p.ip),
|
||
})),
|
||
});
|
||
}));
|
||
|
||
// Пиры, которые стоят в ядре, но неизвестны awg-ctrl (нет ни в users, ни в peers): снять их
|
||
// после сбоя `awg set … remove` некому. Только чтение — панель (core) сама решает, что делать.
|
||
app.get("/api/audit", auth, handler((_req, res) => {
|
||
const r = spawnSync("awg", ["show", CONFIG.interface, "dump"]);
|
||
if (r.status !== 0) throw new HttpError(503, "awg show не ответил");
|
||
const known = new Set<string>([
|
||
...(db.prepare("SELECT pub_key FROM users").all() as { pub_key: string }[]).map(u => u.pub_key),
|
||
...stmts.peersAll.all().map(p => p.pub_key),
|
||
]);
|
||
const now = Math.floor(Date.now() / 1000);
|
||
const ghosts = r.stdout.toString().split("\n").slice(1).map(l => l.split("\t")).filter(f => f[0] && !known.has(f[0])).map(f => {
|
||
const lastHandshake = Number(f[4]) || 0;
|
||
return { pub_key: f[0], lastHandshake, online: lastHandshake > 0 && now - lastHandshake < 180, rx: Number(f[5]) || 0, tx: Number(f[6]) || 0 };
|
||
});
|
||
res.json({ ghosts });
|
||
}));
|
||
|
||
// Снять «призраков» из ядра. Ключи присылает панель, но здесь каждый перепроверяется: пир, который
|
||
// успел появиться в users/peers, не трогаем. Строк в базе у «призраков» нет — снимается только ядро.
|
||
app.post("/api/audit/clean", auth, handler((req, res) => {
|
||
const { pub_keys } = (req.body ?? {}) as { pub_keys?: unknown };
|
||
if (!Array.isArray(pub_keys) || pub_keys.length > SYNC_MAX) throw new HttpError(400, "Неверный список ключей");
|
||
const removed: string[] = [], skipped: string[] = [];
|
||
for (const k of pub_keys.map(checkPubKey)) {
|
||
const known = stmts.peerGet.get(k) || (db.prepare("SELECT 1 FROM users WHERE pub_key = ?").get(k));
|
||
if (known || k === getServerPublicKey() || !kernelPeers()?.has(k)) { skipped.push(k); continue; }
|
||
(dropFromKernel(k) ? removed : skipped).push(k);
|
||
}
|
||
if (removed.length) logger.warn("ghost peers removed from kernel", { count: removed.length, removed });
|
||
res.json({ removed, skipped });
|
||
}));
|
||
|
||
// Должен стоять ДО PUT /api/peers/:pub — иначе тот примет «sync» за ключ.
|
||
app.put(SYNC_PATH, auth, handler((req, res) => {
|
||
const { owner, keep } = (req.body ?? {}) as { owner?: unknown; keep?: unknown };
|
||
if (typeof owner !== "string" || !PANEL_ID.test(owner)) throw new HttpError(400, "Неверный owner");
|
||
if (!Array.isArray(keep) || keep.length > SYNC_MAX) throw new HttpError(400, "Неверный список ключей");
|
||
res.json(syncOwnedPeers(owner, keep.map(checkPubKey)));
|
||
}));
|
||
|
||
app.put("/api/peers/:pub", auth, handler((req, res) => {
|
||
const { pub_key } = (req.body ?? {}) as { pub_key?: string };
|
||
res.json(replacePeer(pubKeyFromParam(req.params.pub), checkPubKey(pub_key)));
|
||
}));
|
||
|
||
app.post("/api/peers/:pub/psk", auth, handler((req, res) => {
|
||
res.json(rotatePeerPsk(pubKeyFromParam(req.params.pub)));
|
||
}));
|
||
|
||
app.delete("/api/peers/:pub", auth, handler((req, res) => {
|
||
removePeer(pubKeyFromParam(req.params.pub));
|
||
res.json({ success: true });
|
||
}));
|
||
|
||
// Общая часть клиентского конфига для подписки. Ключи obfuscation — именами .conf;
|
||
// пустые (I2–I5, весь 3.x-блок на 2.0) не выводятся, как и в самом conf.
|
||
app.get("/api/profile", auth, handler((_req, res) => {
|
||
const awg: Record<string, string> = {};
|
||
for (const [k, v] of Object.entries(CONFIG.awgParams)) if (String(v) !== "") awg[k] = String(v);
|
||
res.json({
|
||
name: CONFIG.serverName,
|
||
endpoint: `${CONFIG.serverIp}:${CONFIG.serverPort}`,
|
||
server_pub: getServerPublicKey(),
|
||
gen: CONFIG.gen,
|
||
dns: [CONFIG.dns1, CONFIG.dns2],
|
||
keepalive: CONFIG.keepalive,
|
||
mtu: CONFIG.mtu,
|
||
awg,
|
||
});
|
||
}));
|
||
|
||
app.post("/awg/restart", auth, handler((_req, res) => {
|
||
restartAwg();
|
||
res.json({ success: true });
|
||
}));
|
||
|
||
// Перевод сервера с 2.0 на 3.1 — включая перевыпуск всех vpn:// ключей.
|
||
// Ошибку отдаём текстом: панель показывает её оператору, а причины отказа
|
||
// (старый модуль, старое ядро, отказ ядра на подъёме) требуют разных действий.
|
||
app.post("/awg/upgrade", auth, handler((_req, res) => {
|
||
if (CONFIG.gen === "3.1") {
|
||
res.status(409).json({ error: "Сервер уже работает на AmneziaWG 3.1" }); return;
|
||
}
|
||
const blocker = checkGen31Support();
|
||
if (blocker) { res.status(409).json({ error: blocker }); return; }
|
||
try {
|
||
res.json(upgradeToGen31());
|
||
} catch (e) {
|
||
res.status(500).json({ error: e instanceof Error ? e.message : "Не удалось перейти на 3.1" });
|
||
}
|
||
}));
|
||
|
||
// Деление канала между устройствами. Путь под /api/ — иначе awg-agent на ноде его не пропустит
|
||
// (и без PATCH: агент отвечает на него 400).
|
||
app.get("/api/shaping", auth, handler(async (_req, res) => {
|
||
res.json(await shaping.status());
|
||
}));
|
||
|
||
app.put("/api/shaping", auth, handler(async (req, res) => {
|
||
const b = (req.body ?? {}) as Record<string, unknown>;
|
||
const mbit = (v: unknown, what: string): number => {
|
||
const n = Number(v);
|
||
if (!Number.isInteger(n) || n < 0 || n > 100_000) throw new HttpError(400, `${what}: целое число Мбит/с от 1 до 100000`);
|
||
return n;
|
||
};
|
||
if (typeof b.enabled !== "boolean" || typeof b.auto !== "boolean")
|
||
throw new HttpError(400, "enabled и auto должны быть true/false");
|
||
const downMbit = mbit(b.downMbit ?? 0, "Загрузка");
|
||
const upMbit = mbit(b.upMbit ?? 0, "Отдача");
|
||
if (b.enabled && (downMbit < 1 || upMbit < 1))
|
||
throw new HttpError(400, "Для включения укажите ширину канала в обе стороны");
|
||
try {
|
||
await shaping.update({ enabled: b.enabled, auto: b.auto, downMbit, upMbit });
|
||
} catch (e) {
|
||
// tc/nft/модуль не нашлись или ядро отказало: оператору нужна причина, а не 500.
|
||
throw new HttpError(500, e instanceof Error ? e.message : "Не удалось применить шейпинг");
|
||
}
|
||
res.json(await shaping.status());
|
||
}));
|
||
|
||
// Метрики для Prometheus. awg-ctrl отдаёт JSON, а текстовый формат собирает awg-ui: на ноде
|
||
// агент пропускает только /api/*, и один формат на ядре и нодах проще сверять. Кэш на 5 с —
|
||
// несколько скрейперов не должны гонять `awg show` чаще.
|
||
const METRICS_TTL_MS = 5_000;
|
||
let metricsCache: { at: number; data: Promise<unknown> } | null = null;
|
||
|
||
function linkCounter(name: string): number {
|
||
try { return Number(readFileSync(`/sys/class/net/${CONFIG.interface}/statistics/${name}`, "utf8")) || 0; }
|
||
catch { return 0; }
|
||
}
|
||
|
||
// Нагрузка хоста из /proc. Счётчики CPU кумулятивные (секунды по режимам, как у node_exporter): долю считает
|
||
// Prometheus через rate(), здесь мгновенного «процента» нет. Память — MemAvailable, а не MemFree: кэш ядра свободен.
|
||
const CPU_MODES = ["user", "nice", "system", "idle", "iowait", "irq", "softirq", "steal"] as const;
|
||
function readHost() {
|
||
try {
|
||
const first = readFileSync("/proc/stat", "utf8").split("\n")[0].trim().split(/\s+/).slice(1).map(Number);
|
||
const cpu: Record<string, number> = {};
|
||
CPU_MODES.forEach((m, i) => { cpu[m] = (first[i] || 0) / 100; }); // USER_HZ = 100 на всех обычных ядрах
|
||
const mem = readFileSync("/proc/meminfo", "utf8");
|
||
const kb = (k: string) => Number(mem.match(new RegExp(`^${k}:\\s+(\\d+) kB`, "m"))?.[1] ?? 0) * 1024;
|
||
return {
|
||
cpu, cores: os.cpus().length, load: os.loadavg(),
|
||
mem: { total: kb("MemTotal"), available: kb("MemAvailable") },
|
||
};
|
||
} catch { return null; }
|
||
}
|
||
|
||
async function collectMetrics() {
|
||
const st = getInterfaceStatus();
|
||
const stats = st.up ? getPeersData() : {};
|
||
const list: { kind: "user" | "device"; name: string; ip: string; online: boolean; rx: number; tx: number; priority: string }[] = [
|
||
...(db.prepare("SELECT name, ip, pub_key FROM users WHERE vpn_key != ''").all() as UserRow[]).map(u => ({
|
||
kind: "user" as const, name: u.name, ip: u.ip,
|
||
online: stats[u.pub_key]?.online ?? false, rx: stats[u.pub_key]?.rx ?? 0, tx: stats[u.pub_key]?.tx ?? 0,
|
||
priority: shaping.priorityOf(u.ip),
|
||
})),
|
||
...stmts.peersAll.all().map(p => ({
|
||
kind: "device" as const, name: "", ip: p.ip,
|
||
online: stats[p.pub_key]?.online ?? false, rx: stats[p.pub_key]?.rx ?? 0, tx: stats[p.pub_key]?.tx ?? 0,
|
||
priority: shaping.priorityOf(p.ip),
|
||
})),
|
||
];
|
||
const all = Object.values(stats);
|
||
return {
|
||
up: st.up,
|
||
gen: CONFIG.gen,
|
||
peers: { total: st.peers, online: all.filter(p => p.online).length },
|
||
// С точки зрения сервера: rx — принято от клиентов (их отдача), tx — отправлено клиентам (их загрузка).
|
||
rx_bytes: all.reduce((a, p) => a + p.rx, 0),
|
||
tx_bytes: all.reduce((a, p) => a + p.tx, 0),
|
||
link: {
|
||
rx_bytes: linkCounter("rx_bytes"), tx_bytes: linkCounter("tx_bytes"),
|
||
rx_packets: linkCounter("rx_packets"), tx_packets: linkCounter("tx_packets"),
|
||
rx_dropped: linkCounter("rx_dropped"), tx_dropped: linkCounter("tx_dropped"),
|
||
rx_errors: linkCounter("rx_errors"), tx_errors: linkCounter("tx_errors"),
|
||
},
|
||
shaping: await shaping.status(),
|
||
host: readHost(),
|
||
list,
|
||
};
|
||
}
|
||
|
||
app.get("/api/metrics", auth, handler(async (_req, res) => {
|
||
if (!metricsCache || Date.now() - metricsCache.at > METRICS_TTL_MS) {
|
||
const data = collectMetrics();
|
||
metricsCache = { at: Date.now(), data };
|
||
data.catch(() => { metricsCache = null; }); // ошибку не кэшируем
|
||
}
|
||
res.json(await metricsCache.data);
|
||
}));
|
||
|
||
// Установка и удаление встроенного мониторинга (Prometheus) по кнопке в панели. Действие одно из двух и без
|
||
// параметров: awg-ctrl запускает ту же команду, что оператор набрал бы руками (`awg-ctrl monitor install|remove`,
|
||
// root), так что код один. Панель сама пакетов не ставит и не удаляет — она только просит об этом здесь.
|
||
const MONITOR_CLI = process.env.AWG_CLI ?? "/usr/local/bin/awg-ctrl";
|
||
const MONITOR_LOG = process.env.MONITOR_LOG ?? path.resolve(process.cwd(), "..", "logs", "monitor-job.log");
|
||
type MonitorAction = "install" | "remove";
|
||
let monitorJob: { action: MonitorAction; startedAt: number; exit: number | null } | null = null;
|
||
|
||
const logTail = (): string => {
|
||
try {
|
||
const t = readFileSync(MONITOR_LOG, "utf8").slice(-4000);
|
||
// apt рисует прогресс возвратом каретки и цветами — в панели это мусор
|
||
return t.replace(/\x1b\[[0-9;]*[A-Za-z]/g, "").replace(/\r/g, "\n");
|
||
} catch { return ""; }
|
||
};
|
||
|
||
function startMonitorJob(action: MonitorAction, res: Response) {
|
||
if (monitorJob && monitorJob.exit === null) { res.status(409).json({ error: "Операция уже идёт" }); return; }
|
||
if (!existsSync(MONITOR_CLI)) throw new HttpError(501, `CLI не найден (${MONITOR_CLI}): выполните на сервере awg-ctrl monitor ${action}`);
|
||
mkdirSync(path.dirname(MONITOR_LOG), { recursive: true });
|
||
const fd = openSync(MONITOR_LOG, "w");
|
||
const job = { action, startedAt: Date.now(), exit: null as number | null };
|
||
monitorJob = job;
|
||
const done = (code: number) => { job.exit = code; try { closeSync(fd); } catch { /* уже закрыт */ } };
|
||
const child = spawn(MONITOR_CLI, ["monitor", action], { stdio: ["ignore", fd, fd] });
|
||
child.on("error", e => { logger.error("monitor: не запустился", { action, error: e.message }); done(127); });
|
||
child.on("exit", code => { logger.info("monitor: завершён", { action, code }); done(code ?? 1); });
|
||
res.status(202).json({ running: true, action });
|
||
}
|
||
|
||
app.post("/api/monitor/install", auth, handler((_req, res) => { startMonitorJob("install", res); }));
|
||
app.post("/api/monitor/remove", auth, handler((_req, res) => { startMonitorJob("remove", res); }));
|
||
|
||
app.get("/api/monitor/job", auth, handler((_req, res) => {
|
||
res.json({
|
||
action: monitorJob?.action ?? null,
|
||
running: !!monitorJob && monitorJob.exit === null,
|
||
exit: monitorJob?.exit ?? null,
|
||
log: monitorJob ? logTail() : "",
|
||
});
|
||
}));
|
||
|
||
app.get("/awg/status", auth, handler((_req, res) => {
|
||
res.json(getInterfaceStatus());
|
||
}));
|
||
|
||
app.post("/awg/start", auth, handler((_req, res) => {
|
||
res.json(startInterface());
|
||
}));
|
||
|
||
app.listen(SERVER.port, "127.0.0.1", () => {
|
||
logger.info("Server started", { port: SERVER.port, host: "127.0.0.1", serverName: CONFIG.serverName, serverIp: CONFIG.serverIp });
|
||
});
|
||
ensureInterfaceUp();
|
||
syncPeers();
|
||
// Обязательно и на старте: при загрузке интерфейс поднимает systemd (ExecStartPre),
|
||
// ни один из путей awg-quick up внутри awg-ctrl тогда не срабатывает.
|
||
void shaping.apply();
|
||
shaping.start();
|