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 { MikrotikClient } from "./mikrotik.js" import { sameWireguardEndpoint, wireguardEndpointSource } from "./wireguard-source.js" import { observedBoolean } from "./ospf-observed-values.js" import { identityDisplayName } from "./ipsec-config.js" import { captureIpsecSnapshot } from "./ipsec-live.js" import { captureAndAppendRevision } from "./config-revisions.js" import { maskNetworkSecrets, networkSecretValues } from "./network-observed-read.js" import { withApplicationMutationLock, withConfigMutationLock } from "./config-mutation-lock.js" import { executeGuardedApplicationWrite } from "./config-mutation-policy.js" type Row = Record export const ipsecPeerDeletePaths = ["/ip/ipsec/peer", "/ip/ipsec/identity", "/ip/ipsec/mode-config", "/ip/pool", "/ip/ipsec/policy", "/ip/firewall/nat", "/certificate", "/ip/ipsec/profile", "/ip/ipsec/proposal", "/ip/ipsec/policy/group", "/ip/ipsec/active-peers"] as const export interface IpsecPeerDeleteState { source: string; catalogs: Record; protections: unknown[]; proof: string } const fail = (code: string, message: string, status = ["STATE_UNAVAILABLE", "MUTATION_OUTCOME_UNKNOWN", "VERIFICATION_FAILED", "HISTORY_UNAVAILABLE"].includes(code) ? 502 : code === "INVALID_INPUT" ? 400 : 409) => new McpError(code, message, status) export class IpsecPeerLinkedConflict extends McpError { constructor(public readonly identities: string[], name: string) { super("DEPENDENCY_CONFLICT", `На peer «${name}» ссылаются identity: ${identities.join(", ")}. Удаление разорвёт их.`, 409) } } const validateId = (id: string) => { if (!/^\*[a-z0-9]+$/i.test(id) || id.length > 100) throw fail("INVALID_INPUT", "Требуется точный native ID IPsec peer") } async function source(server: ServerRow, authorize: () => Promise) { await authorize() const fresh = await getServerRowById(server.id) if (!fresh || !sameWireguardEndpoint(fresh, server)) throw fail("STATE_CONFLICT", "Источник IPsec изменился") } export function ipsecPeerDeleteRows(value: unknown): Row[] { if (!Array.isArray(value) || value.length > 2000 || 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(v => typeof v !== "string"))) throw fail("STATE_UNAVAILABLE", "Неполный native-каталог IPsec") if (new Set(value.map(row => row[".id"])).size !== value.length) throw fail("STATE_UNAVAILABLE", "Повторяющийся native ID IPsec") return value as Row[] } /** Seal every opaque configuration field and list order. Exclude only explicit * runtime observations, including the documented certificate expiry countdown; * absolute validity dates, trust, CRL, references and unknown fields stay sealed. */ export function ipsecPeerDeleteValue(state: Omit) { return { source: state.source, protections: state.protections, catalogs: Object.fromEntries(Object.entries(state.catalogs).filter(([path]) => path !== "/ip/ipsec/active-peers").map(([path, rows]) => [path, rows.filter(row => !(path === "/ip/ipsec/policy" && observedBoolean(row.dynamic) === true)).map(row => Object.fromEntries(Object.entries(row).filter(([key]) => !(path === "/ip/ipsec/policy" && ["active", "ph2-count", "ph2-state"].includes(key)) && !(path === "/certificate" && key === "expires-after"))))])) } } export async function ipsecPeerDeleteSourceProof(server: ServerRow) { return (await privateFingerprinter("ipsec-peer-delete-source-v1"))(fingerprint(wireguardEndpointSource(server))) } export async function ipsecPeerDeleteProof(state: Omit) { return (await privateFingerprinter("ipsec-peer-delete-v2"))(fingerprint(ipsecPeerDeleteValue(state))) } export async function readIpsecPeerDeleteState(server: ServerRow, authorize: () => Promise = async () => {}): Promise { const catalogs: Record = {}, client = MikrotikClient.fromServer(server) let bytes = 0 for (const path of ipsecPeerDeletePaths) { await source(server, authorize) let raw: unknown try { raw = await client.get(path, 10000, undefined, 1048576) } catch { throw fail("STATE_UNAVAILABLE", "Native-каталог IPsec недоступен") } bytes += Buffer.byteLength(JSON.stringify(raw)) if (bytes > 1048576) throw fail("STATE_UNAVAILABLE", "Полный каталог IPsec превышает 1 МиБ") catalogs[path] = ipsecPeerDeleteRows(raw) } await source(server, authorize) const protections = (await pool.query("SELECT object_ref FROM mcp_protections WHERE object_ref->>'serverId'=$1 OR (object_ref->>'kind'='server' AND object_ref->>'id'=$1) ORDER BY id LIMIT 1001", [String(server.id)])).rows if (protections.length > 1000 || bytes + Buffer.byteLength(JSON.stringify(protections)) > 1048576) throw fail("STATE_UNAVAILABLE", "Превышен полный бюджет зависимостей IPsec") await source(server, authorize) const state = { source: await ipsecPeerDeleteSourceProof(server), catalogs, protections } return { ...state, proof: await ipsecPeerDeleteProof(state) } } export function ipsecPeerDeleteTarget(state: IpsecPeerDeleteState, id: string, force = false) { validateId(id) const peer = state.catalogs["/ip/ipsec/peer"].find(row => row[".id"] === id) if (!peer) throw fail("NOT_FOUND", "Peer не найден", 404) for (const flag of ["dynamic", "builtin", "default"]) if (peer[flag] !== undefined && observedBoolean(peer[flag]) !== false) throw fail("PROTECTED_OBJECT", "Системный или неподтверждённый IPsec peer нельзя удалить") const name = (peer.name ?? "").trim() const secrets = networkSecretValues(Object.values(state.catalogs).flat()) const linked = maskNetworkSecrets(state.catalogs["/ip/ipsec/identity"].filter(row => (row.peer ?? "").trim() === name).map(row => identityDisplayName(row, state.catalogs["/certificate"])), secrets) if (linked.length && !force) throw new IpsecPeerLinkedConflict(linked, maskNetworkSecrets(name, secrets)) return { peer, linked } } export function projectIpsecPeerDelete(state: IpsecPeerDeleteState, id: string) { const projected = structuredClone(state) projected.catalogs["/ip/ipsec/peer"] = projected.catalogs["/ip/ipsec/peer"].filter(row => row[".id"] !== id) return projected } /** Exact REST force semantics: one DELETE only; identities and other config are never cascaded. */ export async function deleteIpsecPeerGuarded(server: ServerRow, id: string, force = false, expectedProof?: string, authorize: () => Promise = async () => {}, options: { recordRevision?: typeof captureAndAppendRevision; receiptId?: string } = {}) { validateId(id) return withApplicationMutationLock(() => withConfigMutationLock([server.id], () => executeGuardedApplicationWrite({ kind: "ipsec_peer", id }, [server.id], async () => { const before = await readIpsecPeerDeleteState(server, authorize) if (expectedProof && before.proof !== expectedProof) throw fail("STATE_CONFLICT", "IPsec, источник или зависимости изменились после подготовки") ipsecPeerDeleteTarget(before, id, force) const desired = await ipsecPeerDeleteProof(projectIpsecPeerDelete(before, id)) await source(server, authorize) try { await MikrotikClient.fromServer(server).delete("/ip/ipsec/peer/" + encodeURIComponent(id), 10000, async () => { const fenced = await readIpsecPeerDeleteState(server, authorize) if (fenced.proof !== before.proof) throw fail("STATE_CONFLICT", "IPsec изменился перед отправкой DELETE") ipsecPeerDeleteTarget(fenced, id, force) await source(server, authorize) }) } catch (error) { if (error instanceof McpError && !["MUTATION_OUTCOME_UNKNOWN"].includes(error.code)) throw error; throw fail("MUTATION_OUTCOME_UNKNOWN", "Исход DELETE IPsec не подтверждён; повтор запрещён, требуется сверка") } let after: IpsecPeerDeleteState try { after = await readIpsecPeerDeleteState(server, authorize) } catch { throw fail("MUTATION_OUTCOME_UNKNOWN", "DELETE отправлен, но сверка IPsec недоступна; повтор запрещён") } if (after.proof !== desired) throw fail("VERIFICATION_FAILED", "Удаление peer или сохранность остальной конфигурации не подтверждены; повтор запрещён") // Reuse precisely the REST managed-only history mapping, reading our bounded verified state. const reader = { get: async (path: string) => { await source(server, authorize); if (!Object.hasOwn(after.catalogs, path)) throw fail("STATE_UNAVAILABLE", "Неизвестный каталог истории IPsec"); return structuredClone(after.catalogs[path]) } } as unknown as MikrotikClient let historyRecorded = false try { await source(server, authorize); historyRecorded = await (options.recordRevision ?? captureAndAppendRevision)({ serverId: server.id, section: "ipsec", source: "apply", capture: () => captureIpsecSnapshot(server, reader) }) !== null } catch { /* A history failure cannot justify replaying an acknowledged DELETE. */ } return { ok: true, verified: true, receiptId: options.receiptId ?? null, commandCount: 1, completedCommands: 1, peerId: id, force, afterProof: after.proof, historyRecorded, revisionRecorded: historyRecorded, state: "applied", forwardingVerified: false } }))) }