129 lines
12 KiB
TypeScript
129 lines
12 KiB
TypeScript
import { pool } from "../db/index.js"
|
|
import { getServerRowById, type ServerRow } from "../modules/servers/repository/servers-repository.js"
|
|
import { fingerprint, McpError, privateFingerprinter } from "../modules/mcp/security.js"
|
|
import { isRouterOsPreHeaderGetReset, MikrotikClient } from "./mikrotik.js"
|
|
import { observedBoolean } from "./ospf-observed-values.js"
|
|
import { withApplicationMutationLock, withConfigMutationLock } from "./config-mutation-lock.js"
|
|
import { captureAndAppendRevision } from "./config-revisions.js"
|
|
import { captureWireguardSnapshot } from "./wireguard-live.js"
|
|
import { executeGuardedApplicationWrite } from "./config-mutation-policy.js"
|
|
import { sameWireguardEndpoint, wireguardEndpointSource } from "./wireguard-source.js"
|
|
import { markWireguardGetFailure, markWireguardReadFailure } from "./wireguard-read-diagnostic.js"
|
|
|
|
type Row = Record<string, string>
|
|
type Binding = { id: string; interfaceName: string; peerPublicKey: string }
|
|
export interface WireguardPeerDeletionState { interfaces: Row[]; peers: Row[]; bindings: Binding[]; flow: { hostPublicKey: string; registered: boolean | null }; serverProof: string; proof: string }
|
|
const runtime = new Set(["running", "actual-mtu", "l2mtu", "rx", "tx", "last-handshake", "current-endpoint-address", "current-endpoint-port", "rx-byte", "tx-byte", "rx-packet", "tx-packet", "last-link-down-time", "last-link-up-time", "link-downs"])
|
|
const problem = (message: string, code = "STATE_CONFLICT") => new McpError(code, message, code === "INVALID_INPUT" ? 400 : ["STATE_UNAVAILABLE", "MUTATION_OUTCOME_UNKNOWN", "VERIFICATION_FAILED"].includes(code) ? 502 : 409)
|
|
async function source(server: ServerRow, beforeRead: () => Promise<unknown>) {
|
|
await beforeRead()
|
|
const fresh = await getServerRowById(server.id)
|
|
if (!fresh || !sameWireguardEndpoint(fresh, server)) throw problem("Источник WireGuard изменился")
|
|
}
|
|
|
|
function rows(value: unknown, maximum: number): Row[] {
|
|
if (!Array.isArray(value) || value.length > maximum || value.some(row => !row || typeof row !== "object" || Array.isArray(row) || typeof row[".id"] !== "string" || !/^\*[a-z0-9]+$/i.test(row[".id"]) || Object.values(row).some(item => typeof item !== "string"))) throw problem("Неполный native-каталог WireGuard")
|
|
if (new Set(value.map(row => row[".id"])).size !== value.length) throw problem("Повторяющиеся native ID WireGuard")
|
|
return value as Row[]
|
|
}
|
|
export function wireguardConfigurationRows(values: Row[]) {
|
|
return values.map(row => Object.fromEntries(Object.entries(row).filter(([key]) => !runtime.has(key)).sort(([a], [b]) => a.localeCompare(b)))).sort((a, b) => a[".id"].localeCompare(b[".id"]))
|
|
}
|
|
const stable = wireguardConfigurationRows
|
|
function proofValue(state: Omit<WireguardPeerDeletionState, "proof">) {
|
|
return { serverProof: state.serverProof, interfaces: stable(state.interfaces), peers: stable(state.peers), bindings: state.bindings, flow: state.flow }
|
|
}
|
|
export async function expectedWireguardPeerDeletionProof(state: WireguardPeerDeletionState, id: string) {
|
|
wireguardPeerDeletionTarget(state, id)
|
|
const sign = await privateFingerprinter("wireguard-peer-delete-v1")
|
|
return sign(fingerprint(proofValue({ ...state, peers: state.peers.filter(row => row[".id"] !== id) })))
|
|
}
|
|
export function wireguardPeerDeletionTarget(state: WireguardPeerDeletionState, id: string, allowBoundPeer = false) {
|
|
if (!/^\*[a-z0-9]+$/i.test(id) || id.length > 100) throw problem("Требуется стабильный native ID peer", "INVALID_INPUT")
|
|
const peer = state.peers.find(row => row[".id"] === id)
|
|
if (!peer?.interface || !peer["public-key"]?.trim()) throw problem("Peer WireGuard не найден или не подтверждена его принадлежность")
|
|
for (const flag of ["dynamic", "builtin", "default"]) if (peer[flag] !== undefined && observedBoolean(peer[flag]) !== false) throw problem("Системный или неподтверждённый peer нельзя изменять", "PROTECTED_OBJECT")
|
|
const parents = state.interfaces.filter(row => row.name === peer.interface || row[".id"] === peer.interface)
|
|
if (parents.length !== 1 || !parents[0].name) throw problem("Не подтверждён родительский интерфейс WireGuard")
|
|
const parent = parents[0]
|
|
const managed = peer.comment === "MM traffic-flow collector" || peer.name === "mm-collector" && parent.comment === "MikrotikManager traffic-flow overlay"
|
|
const hostPeer = peer["public-key"] === state.flow.hostPublicKey
|
|
if (managed || hostPeer && state.flow.registered === true) throw problem("Peer управляется NetFlow overlay; используйте отдельное изменение сервиса NetFlow", "PROTECTED_OBJECT")
|
|
if (hostPeer && state.flow.registered === null) throw problem("Не подтверждена принадлежность peer сервису NetFlow", "STATE_UNAVAILABLE")
|
|
if (!allowBoundPeer && state.bindings.some(binding => [parent.name, parent[".id"]].includes(binding.interfaceName) && (!binding.peerPublicKey.trim() || binding.peerPublicKey.trim() === peer["public-key"]))) throw problem("Peer используется привязкой пользователя; сначала измените привязку отдельным планом")
|
|
return { peer, parent }
|
|
}
|
|
|
|
export async function readWireguardPeerDeletionState(server: ServerRow, beforeRead: () => Promise<unknown> = async () => {}): Promise<WireguardPeerDeletionState> {
|
|
const sign = await privateFingerprinter("wireguard-peer-delete-v1"), serverProof = sign(fingerprint(wireguardEndpointSource(server)))
|
|
const client = MikrotikClient.fromServer(server)
|
|
let catalogueRetryUsed = false
|
|
const read = async (path: string) => {
|
|
await source(server, beforeRead)
|
|
const deadline = performance.now() + 10_000
|
|
try { return await client.get<unknown>(path, 10000, undefined, 1048576) }
|
|
catch (error) {
|
|
if (catalogueRetryUsed || !isRouterOsPreHeaderGetReset(error) || performance.now() >= deadline) {
|
|
throw markWireguardGetFailure(problem("Native-каталог WireGuard недоступен", "STATE_UNAVAILABLE"), path, 1, error)
|
|
}
|
|
}
|
|
catalogueRetryUsed = true
|
|
await source(server, beforeRead)
|
|
const remaining = Math.floor(deadline - performance.now())
|
|
if (remaining < 1) throw markWireguardReadFailure(problem("Native-каталог WireGuard недоступен", "STATE_UNAVAILABLE"), path, 2, "read-deadline")
|
|
try { return await client.get<unknown>(path, remaining, undefined, 1048576) }
|
|
catch (error) { throw markWireguardGetFailure(problem("Native-каталог WireGuard недоступен", "STATE_UNAVAILABLE"), path, 2, error) }
|
|
}
|
|
const rawInterfaces = await read("/interface/wireguard"), rawPeers = await read("/interface/wireguard/peers")
|
|
if (Buffer.byteLength(JSON.stringify([rawInterfaces, rawPeers])) > 1048576) throw problem("Каталог WireGuard превышает 1 МиБ")
|
|
const catalogue = (raw: unknown, maximum: number, path: string) => {
|
|
try { return rows(raw, maximum) }
|
|
catch (error) {
|
|
if (!(error instanceof McpError)) throw error
|
|
throw markWireguardReadFailure(error, path, undefined, Array.isArray(raw) && raw.length > maximum ? "catalogue-limit" : "invalid-catalogue")
|
|
}
|
|
}
|
|
const interfaces = catalogue(rawInterfaces, 100, "/interface/wireguard")
|
|
const peers = catalogue(rawPeers, 2000, "/interface/wireguard/peers")
|
|
await source(server, beforeRead)
|
|
const bindings = (await pool.query<Binding>('SELECT id,interface_name AS "interfaceName",peer_public_key AS "peerPublicKey" FROM user_interface_bindings WHERE server_id=$1 ORDER BY id LIMIT 1001', [server.id])).rows
|
|
if (bindings.length > 1000) throw problem("Превышен предел привязок WireGuard")
|
|
// Project only this server's membership; never transfer the global peer/key payload.
|
|
const flow = (await pool.query<{ hostPublicKey: string | null; registered: boolean | null }>(`SELECT
|
|
CASE WHEN octet_length(host_public_key)<=128 THEN host_public_key ELSE NULL END AS "hostPublicKey",
|
|
CASE WHEN jsonb_typeof(peers_json)='array' AND octet_length(peers_json::text)<=1048576
|
|
THEN jsonb_path_exists(peers_json,'$[*] ? (@.serverId == $sid || @.serverId == $sidText)',jsonb_build_object('sid',$1::int,'sidText',$1::text)) ELSE NULL END AS registered
|
|
FROM traffic_flow_settings WHERE id=1`, [server.id])).rows[0] ?? { hostPublicKey: "", registered: false }
|
|
if (flow.hostPublicKey === null) throw problem("Ключ принадлежности NetFlow не подтверждён", "STATE_UNAVAILABLE")
|
|
await source(server, beforeRead)
|
|
const flowContext = { hostPublicKey: flow.hostPublicKey, registered: flow.registered }
|
|
const proof = sign(fingerprint(proofValue({ serverProof, interfaces, peers, bindings, flow: flowContext })))
|
|
return { interfaces, peers, bindings, flow: flowContext, serverProof, proof }
|
|
}
|
|
|
|
/** One DELETE, no cascade or retry. All other opaque configuration must survive. */
|
|
export async function deleteWireguardPeer(server: ServerRow, id: string, expectedProof?: string, beforeRead: () => Promise<unknown> = async () => {}, options: { recordRevision?: boolean } = {}) {
|
|
if (!/^\*[a-z0-9]+$/i.test(id) || id.length > 100) throw problem("Требуется стабильный native ID peer", "INVALID_INPUT")
|
|
return withApplicationMutationLock(() => withConfigMutationLock([server.id], () => executeGuardedApplicationWrite({ kind: "wireguard_peer", id }, [server.id], async () => {
|
|
const before = await readWireguardPeerDeletionState(server, beforeRead)
|
|
if (expectedProof && before.proof !== expectedProof) throw problem("Peer, его источник или зависимости изменились после подготовки")
|
|
wireguardPeerDeletionTarget(before, id)
|
|
await source(server, beforeRead)
|
|
const client = MikrotikClient.fromServer(server)
|
|
try { await client.delete("/interface/wireguard/peers/" + encodeURIComponent(id)) }
|
|
catch (error) {
|
|
if (error instanceof McpError) throw error
|
|
throw problem("Исход удаления peer не подтверждён; не повторяйте запись, требуется сверка", "MUTATION_OUTCOME_UNKNOWN")
|
|
}
|
|
let after: WireguardPeerDeletionState
|
|
try { after = await readWireguardPeerDeletionState(server, beforeRead) }
|
|
catch { throw problem("Удаление отправлено, но проверка WireGuard недоступна; не повторяйте запись", "MUTATION_OUTCOME_UNKNOWN") }
|
|
const verified = after.serverProof === before.serverProof && fingerprint(stable(after.interfaces)) === fingerprint(stable(before.interfaces)) && fingerprint(stable(after.peers)) === fingerprint(stable(before.peers.filter(row => row[".id"] !== id))) && fingerprint(after.bindings) === fingerprint(before.bindings) && fingerprint(after.flow) === fingerprint(before.flow)
|
|
if (!verified) throw problem("Удаление peer или сохранение остальной конфигурации WireGuard не подтверждены; повтор запрещён", "VERIFICATION_FAILED")
|
|
let revisionRecorded = false
|
|
try { if (options.recordRevision !== false) revisionRecorded = await captureAndAppendRevision({ serverId: server.id, section: "wireguard", source: "apply", capture: () => captureWireguardSnapshot(server, () => source(server, beforeRead)) }) !== null }
|
|
catch { /* Native deletion remains verified even if history storage fails. */ }
|
|
return { ok: true, verified: true, peerId: id, afterProof: after.proof, revisionRecorded, revisionError: revisionRecorded || options.recordRevision === false ? null : "Удаление проверено; запись ревизии приложения не подтверждена", forwardingVerified: false }
|
|
})))
|
|
}
|