Files
MikrotikManager/backend/src/modules/mcp/ipsec-certificate-delete-acceptance.ts
T

121 lines
16 KiB
TypeScript

import assert from "node:assert/strict"
import { randomUUID } from "node:crypto"
import { createServer } from "node:http"
import { setTimeout as delay } from "node:timers/promises"
import Fastify from "fastify"
import { serializerCompiler, validatorCompiler } from "@fastify/type-provider-zod"
import { mcpConnectionCreateSchema } from "@mmapp/contracts/mcp"
import { pool } from "../../db/index.js"
import type { AuthUser } from "../../lib/permissions.js"
import ipsecRoutes, { createIpsecRoutes } from "../../routes/ipsec.js"
import { getEnabledIpsecServerById } from "../../services/ipsec-live.js"
import { ipsecPeerDeletePaths } from "../../services/ipsec-peer-delete.js"
import { createMcpConnection, authenticateMcpToken, setConnectionStatus } from "./store.js"
import { invokeMcpTool, approvePlan, applyPlan } from "./runtime.js"
/** SQL + owned loopback HTTP fixture. No external router, certificate issuance or secret export. */
export async function acceptIpsecCertificateDeletion(actor: AuthUser) {
const serverId = 197, baseline: Record<string, Record<string, string>[]> = Object.fromEntries(ipsecPeerDeletePaths.map(path => [path, []]))
baseline["/certificate"] = [{ ".id": "*c", name: "foreign-leaf", ca: "foreign-ca", "key-usage": "tls-client", issued: "false", opaque: "NEVER_CERT_OPAQUE" }, { ".id": "*a", name: "foreign-ca", authority: "true", crl: "true" }, { ".id": "*o", name: "other", opaque: "NEVER_OTHER_OPAQUE" }]
baseline["/ip/ipsec/peer"] = [{ ".id": "*p", name: "ike", "exchange-mode": "ike2", certificate: "foreign-leaf", disabled: "true" }]
baseline["/ip/ipsec/identity"] = [{ ".id": "*i", peer: "ike", "remote-certificate": "foreign-leaf", "auth-method": "digital-signature", disabled: "true", secret: "NEVER_CERT_PSK", comment: "fixture" }]
let catalogs = structuredClone(baseline), mode = "normal", deletes = 0, reads = 0, connectionId: string | undefined
let duringRead: (() => Promise<unknown>) | undefined, afterDelete: (() => Promise<unknown>) | undefined
const router = createServer((req, res) => {
res.setHeader("content-type", "application/json"); const path = (req.url ?? "").replace(/^\/rest/, "")
if (req.method === "GET") {
reads++
if (duringRead) { const hook = duringRead; duringRead = undefined; void hook().then(() => res.end(JSON.stringify(catalogs[path] ?? [])), () => { res.statusCode = 503; res.end("{}") }); return }
if (mode === "provider-error") { res.statusCode = 400; res.end('{"message":"NEVER_CERT_PROVIDER"}'); return }
res.end(JSON.stringify(catalogs[path] ?? [])); return
}
if (req.method === "DELETE" && path === "/certificate/*c") {
deletes++
if (mode !== "ignored") catalogs["/certificate"] = catalogs["/certificate"].filter(row => row[".id"] !== "*c")
if (mode === "collateral") catalogs["/certificate"][1].opaque = "changed"
if (mode === "lost") { req.socket.destroy(); return }
if (afterDelete) { const hook = afterDelete; afterDelete = undefined; void hook().then(() => res.end("{}"), () => { res.statusCode = 503; res.end("{}") }); return }
res.end("{}"); return
}
res.statusCode = 400; res.end("{}")
})
await new Promise<void>(resolve => router.listen(0, "127.0.0.1", resolve))
const rest = Fastify(); rest.setValidatorCompiler(validatorCompiler); rest.setSerializerCompiler(serializerCompiler)
const reset = () => { mode = "normal"; catalogs = structuredClone(baseline) }
const wait = async (id: string) => { const deadline = Date.now() + 140000; while (Date.now() < deadline) { const state = (await pool.query("SELECT state FROM mcp_operations WHERE id=$1", [id])).rows[0].state; if (!["pending", "running"].includes(state)) return state; await delay(25) }; throw Error("Certificate operation remains live; never replay") }
try {
await pool.query("INSERT INTO servers(id,name,host,port,use_ssl,password) VALUES($1,'certificate-delete-proof','127.0.0.1',$2,false,'NEVER_CERT_ENDPOINT')", [serverId, (router.address() as { port: number }).port])
await rest.register(ipsecRoutes, { prefix: "/api" })
const access = await createMcpConnection(mcpConnectionCreateSchema.parse({ name: "IPsec certificate deletion", mode: "approval", expiresAt: new Date(Date.now() + 1800000).toISOString(), permissions: ["mm:network:write", "mm:network:read", "mm:certificates:write"], scope: { serverIds: [serverId], operationIds: ["network.ipsec.certificates.delete", "ros.certificate.delete", "operations.reconcile"], allowGlobal: false }, limits: { callsPerMinute: 120, mutationsPerHour: 100 } }), actor)
connectionId = access.connection.id; const principal = await authenticateMcpToken(access.token)
const prepare = async (force = true, name = "foreign-leaf") => { const plan = await invokeMcpTool(principal, "mm_ipsec_certificate_remove_plan", { serverId, name, force }) as { planId: string; state: string }; assert.equal(plan.state, "awaiting-approval"); assert.ok(!JSON.stringify(plan).includes("NEVER_")); return plan }
const reconcile = async (operationId: string) => await invokeMcpTool(principal, "mm_operation_reconcile", { operationId }) as { automaticRetry: boolean; results: { matchesDesiredState: boolean; configurationMatchesDesiredState: boolean; matchesOriginalState: boolean }[] }
const initialReads: number = reads
await assert.rejects(invokeMcpTool(principal, "mm_ipsec_certificate_remove_plan", { serverId: 1, name: "foreign-leaf" }))
await assert.rejects(invokeMcpTool(principal, "mm_ipsec_certificate_remove_plan", { serverId, name: "" })); assert.equal(reads, initialReads)
const aliasOnly = await createMcpConnection(mcpConnectionCreateSchema.parse({ name: "Certificate alias without business grant", mode: "approval", expiresAt: new Date(Date.now() + 1800000).toISOString(), permissions: ["mm:network:write", "mm:network:read", "mm:certificates:write"], scope: { serverIds: [serverId], operationIds: ["ros.certificate.delete"], allowGlobal: false }, limits: { callsPerMinute: 120, mutationsPerHour: 100 } }), actor)
try { const aliasPrincipal = await authenticateMcpToken(aliasOnly.token), priorReads: number = reads; await assert.rejects(invokeMcpTool(aliasPrincipal, "mm_certificate_delete_plan", { serverId, id: "*c" })); assert.equal(reads, priorReads) } finally { await setConnectionStatus(aliasOnly.connection.id, "paused", actor) }
const native = async (id = "*c") => await invokeMcpTool(principal, "mm_certificate_delete_plan", { serverId, id }) as { planId: string; state: string }
await assert.rejects(native(), /используется/); await assert.rejects(native("*a"), /всю цепочку/)
await assert.rejects(prepare(false), /используется/)
catalogs["/ip/ipsec/identity"][0].comment="NEVER_CERT_PSK"
await assert.rejects(prepare(false),error=>error instanceof Error&&!error.message.includes("NEVER_CERT_PSK"))
const masked=await rest.inject({method:"DELETE",url:`/api/ipsec/certs/${serverId}`,payload:{name:"foreign-leaf"}});assert.equal(masked.statusCode,409);assert.ok(!masked.body.includes("NEVER_CERT_PSK"))
catalogs["/certificate"][0].name="NEVER_CERT_PSK"
await assert.rejects(native(),error=>error instanceof Error&&!error.message.includes("NEVER_CERT_PSK"))
reset()
const blocked = await rest.inject({ method: "DELETE", url: `/api/ipsec/certs/${serverId}`, payload: { name: "foreign-leaf" } }); assert.equal(blocked.statusCode, 409); assert.equal(blocked.json().usedBy.length, 2); assert.equal(deletes, 0)
for (const force of [false, true]) { await assert.rejects(prepare(force, "foreign-ca"), /всю цепочку/); assert.equal((await rest.inject({ method: "DELETE", url: `/api/ipsec/certs/${serverId}?force=${force}`, payload: { name: "foreign-ca" } })).statusCode, 409) }
for (const key of ["issued", "revoked"]) { reset(); catalogs["/certificate"][0][key] = "true"; await assert.rejects(prepare(), /CRL/); assert.equal((await rest.inject({ method: "DELETE", url: `/api/ipsec/certs/${serverId}?force=true`, payload: { name: "foreign-leaf" } })).statusCode, 409) }
reset();catalogs["/certificate"][1].crl="yes";catalogs["/certificate"][0].issued="yes"
await assert.rejects(prepare(),/CRL/);assert.equal((await rest.inject({method:"DELETE",url:`/api/ipsec/certs/${serverId}?force=true`,payload:{name:"foreign-leaf"}})).statusCode,409)
reset(); catalogs["/certificate"].push({ ".id": "*d", name: "foreign-ca", crl: "false" }); await assert.rejects(prepare(), /CA-издателя/); await assert.rejects(native(), /CA-издателя/); assert.equal((await rest.inject({ method: "DELETE", url: `/api/ipsec/certs/${serverId}?force=true`, payload: { name: "foreign-leaf" } })).statusCode, 409)
reset(); catalogs["/ip/ipsec/peer"] = []; catalogs["/ip/ipsec/identity"] = []
const nativePlan = await native(); assert.equal(nativePlan.state, "awaiting-approval"); await approvePlan(nativePlan.planId, actor, true); const beforeNative: number = deletes, nativeOp = await applyPlan(principal, nativePlan.planId, randomUUID()); assert.equal(await wait(nativeOp.id), "applied"); assert.equal(deletes, beforeNative + 1); assert.deepEqual(catalogs["/certificate"], baseline["/certificate"].slice(1))
reset(); await assert.rejects(prepare(true, "missing"), /не найден/)
for (const fault of ["normal", "ignored", "collateral", "lost"]) {
reset(); const plan = await prepare(); await approvePlan(plan.planId, actor, true); mode = fault
const before: number = deletes, key = randomUUID(), operation = await applyPlan(principal, plan.planId, key)
assert.equal(await wait(operation.id), fault === "normal" ? "applied" : fault === "lost" ? "unknown" : "partial"); assert.equal(deletes, before + 1)
assert.equal((await applyPlan(principal, plan.planId, key)).id, operation.id)
const checked = await reconcile(operation.id); assert.equal(checked.automaticRetry, false); assert.equal(checked.results[0].matchesDesiredState, fault === "normal"); assert.equal(checked.results[0].configurationMatchesDesiredState, fault === "normal" || fault === "lost"); assert.equal(checked.results[0].matchesOriginalState, fault === "ignored"); assert.equal(deletes, before + 1)
if (fault === "normal") {
assert.deepEqual(catalogs["/ip/ipsec/peer"], baseline["/ip/ipsec/peer"]); assert.deepEqual(catalogs["/ip/ipsec/identity"], baseline["/ip/ipsec/identity"]); assert.deepEqual(catalogs["/certificate"], baseline["/certificate"].slice(1))
const saved = (await pool.query("SELECT step_index,intended_state,result FROM mcp_operation_steps WHERE operation_id=$1", [operation.id])).rows[0]
for (const change of ["history", "native", "intended"]) {
const intended = structuredClone(saved.intended_state), receipt = structuredClone(saved.result)
if (change === "history") receipt.historyRecorded = false
if (change === "native") receipt.certificateId = "*o"
if (change === "intended") intended.input.force = false
await pool.query("UPDATE mcp_operation_steps SET intended_state=$2::jsonb,result=$3::jsonb WHERE operation_id=$1 AND step_index=$4", [operation.id, JSON.stringify(intended), JSON.stringify(receipt), saved.step_index])
const tampered = await reconcile(operation.id); assert.equal(tampered.results[0].configurationMatchesDesiredState, true); assert.equal(tampered.results[0].matchesDesiredState, false)
await pool.query("UPDATE mcp_operation_steps SET intended_state=$2::jsonb,result=$3::jsonb WHERE operation_id=$1 AND step_index=$4", [operation.id, JSON.stringify(saved.intended_state), JSON.stringify(saved.result), saved.step_index])
}
}
}
reset(); const stale = await prepare(); await approvePlan(stale.planId, actor, true); catalogs["/certificate"][2].opaque = "NEVER_DRIFT"; const beforeDrift: number = deletes; assert.equal(await wait((await applyPlan(principal, stale.planId, randomUUID())).id), "rejected"); assert.equal(deletes, beforeDrift)
reset(); const aba = await prepare(); await approvePlan(aba.planId, actor, true); await pool.query("UPDATE servers SET verify_ssl=NOT verify_ssl WHERE id=$1", [serverId]); await pool.query("UPDATE servers SET verify_ssl=NOT verify_ssl WHERE id=$1", [serverId]); assert.equal(await wait((await applyPlan(principal, aba.planId, randomUUID())).id), "rejected"); assert.equal(deletes, beforeDrift)
reset(); const protection = randomUUID(); await pool.query("INSERT INTO mcp_protections(id,object_ref,created_by) VALUES($1,$2::jsonb,'integration')", [protection, JSON.stringify({ kind: "certificate", id: "*c", serverId, protection: "deny" })]); await assert.rejects(prepare()); assert.equal((await rest.inject({ method: "DELETE", url: `/api/ipsec/certs/${serverId}?force=true`, payload: { name: "foreign-leaf" } })).statusCode, 409); await pool.query("DELETE FROM mcp_protections WHERE id=$1", [protection])
reset(); const revoke = await prepare(); await approvePlan(revoke.planId, actor, true); afterDelete = () => setConnectionStatus(access.connection.id, "paused", actor); const uncertain = await applyPlan(principal, revoke.planId, randomUUID()); assert.equal(await wait(uncertain.id), "unknown"); await setConnectionStatus(access.connection.id, "active", actor)
const beforeRead: number = reads
await assert.rejects(reconcile(uncertain.id)); assert.equal(reads,beforeRead,"Old receipt is rejected before native reads after policy ABA")
reset(); const freshPlan=await prepare(); await approvePlan(freshPlan.planId,actor,true)
const freshOperation=await applyPlan(principal,freshPlan.planId,randomUUID()); assert.equal(await wait(freshOperation.id),"applied")
const beforeReconcile: number = deletes, freshReads: number = reads
duringRead = () => setConnectionStatus(access.connection.id,"paused",actor)
await assert.rejects(reconcile(freshOperation.id)); assert.equal(reads,freshReads+1); assert.equal(deletes,beforeReconcile)
await setConnectionStatus(access.connection.id,"active",actor)
reset(); const success = await rest.inject({ method: "DELETE", url: `/api/ipsec/certs/${serverId}?force=true`, payload: { name: "foreign-leaf" } }); assert.equal(success.statusCode, 200); assert.equal(success.json().ok, true)
reset(); catalogs["/ip/ipsec/peer"] = []; catalogs["/ip/ipsec/identity"] = []; assert.equal((await rest.inject({ method: "DELETE", url: `/api/ipsec/certs/${serverId}`, payload: { name: "foreign-leaf" } })).statusCode, 200)
reset(); const history = Fastify(); history.setValidatorCompiler(validatorCompiler); history.setSerializerCompiler(serializerCompiler)
try { await history.register(createIpsecRoutes({ findServer: getEnabledIpsecServerById, recordRevision: async () => null }), { prefix: "/api" }); const failed = await history.inject({ method: "DELETE", url: `/api/ipsec/certs/${serverId}?force=true`, payload: { name: "foreign-leaf" } }); assert.equal(failed.statusCode, 502); assert.equal(failed.json().state, "applied"); assert.equal(failed.json().historyRecorded, false) } finally { await history.close() }
reset(); mode = "provider-error"; await assert.rejects(prepare(), (error: Error) => !error.message.includes("NEVER_"))
assert.ok(!JSON.stringify((await pool.query("SELECT result FROM mcp_requests WHERE connection_id=$1", [connectionId])).rows).includes("NEVER_"))
console.log("✓ Single certificate DELETE shared REST/MCP: any foreign cert, force references only, CA/CRL guards, opaque/source protections, native checkpoint/VERIFIED/history, lost unknown/no replay, revoke, ABA and privacy")
} finally {
if (connectionId) await setConnectionStatus(connectionId, "paused", actor)
await pool.query("DELETE FROM mcp_protections WHERE object_ref->>'serverId'=$1", [String(serverId)]); await pool.query("DELETE FROM servers WHERE id=$1", [serverId])
await rest.close(); router.closeAllConnections(); await new Promise<void>((resolve, reject) => router.close(error => error ? reject(error) : resolve()))
}
}