Files
MikrotikManager/backend/src/services/ipsec-peer-delete.ts
T

101 lines
9.7 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 { 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<string, string>
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<string, Row[]>; 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<unknown>) {
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<IpsecPeerDeleteState, "proof">) {
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<IpsecPeerDeleteState, "proof">) { return (await privateFingerprinter("ipsec-peer-delete-v2"))(fingerprint(ipsecPeerDeleteValue(state))) }
export async function readIpsecPeerDeleteState(server: ServerRow, authorize: () => Promise<unknown> = async () => {}): Promise<IpsecPeerDeleteState> {
const catalogs: Record<string, Row[]> = {}, client = MikrotikClient.fromServer(server)
let bytes = 0
for (const path of ipsecPeerDeletePaths) {
await source(server, authorize)
let raw: unknown
try { raw = await client.get<unknown>(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<unknown> = 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 }
})))
}