Files
MikrotikManager/backend/src/modules/mcp/wireguard-interface-delete-acceptance.ts
T

178 lines
15 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 wireguardRoutes from "../../routes/wireguard.js"
import { wireguardInterfaceDependencyPaths } from "../../services/wireguard-interface-delete.js"
import { createMcpConnection, authenticateMcpToken, setConnectionStatus } from "./store.js"
import { invokeMcpTool, approvePlan, applyPlan } from "./runtime.js"
type Rows = Record<string, Record<string, string>[]>
export async function acceptWireguardInterfaceDeletion(actor: AuthUser) {
const privateKey = Buffer.alloc(32, 31).toString("base64"), psk = Buffer.alloc(32, 32).toString("base64")
const initial: Rows = Object.fromEntries(wireguardInterfaceDependencyPaths.map(path => [path, []]))
initial["/interface/wireguard"] = [{ ".id": "*a1", name: "wg-cascade", disabled: "false", "private-key": privateKey, "listen-port": "13231", mtu: "1420", comment: "owned" }, { ".id": "*af", name: "wg-foreign", disabled: "true", "private-key": "NEVER_FOREIGN_PRIVATE" }]
initial["/interface/wireguard/peers"] = [{ ".id": "*p1", interface: "wg-cascade", "public-key": Buffer.alloc(32, 33).toString("base64"), "preshared-key": psk, "allowed-address": "192.0.2.2/32", disabled: "true" }, { ".id": "*p2", interface: "*a1", "public-key": Buffer.alloc(32, 34).toString("base64"), "allowed-address": "192.0.2.3/32", disabled: "true" }, { ".id": "*pf", interface: "wg-foreign", "public-key": "foreign", rx: "0", opaque: "NEVER_FOREIGN_OPAQUE" }]
initial["/interface"] = [{ ".id": "*a1", name: "wg-cascade", type: "wg" }, { ".id": "*af", name: "wg-foreign", type: "wg" }]
initial["/ip/address"] = [{ ".id": "*v1", address: "198.19.244.1/30", interface: "wg-cascade", disabled: "true", dynamic: "false", invalid: "true" }, { ".id": "*vf", address: "203.0.113.2/24", interface: "ether1", dynamic: "false", disabled: "false" }]
initial["/ipv6/address"] = [{ ".id": "*v2", address: "2001:db8:244::1/64", interface: "*a1", disabled: "true", dynamic: "false", invalid: "true" }, { ".id": "*ll", address: "fe80::1/64", interface: "wg-cascade", dynamic: "true" }]
initial["/ip/route"] = [{ ".id": "*dc", dynamic: "true", connect: "true", gateway: "wg-cascade", "pref-src": "198.19.244.1" }]
let rows = structuredClone(initial), mode = "normal", gets = 0, commands: string[] = [], afterDelete: (() => Promise<unknown>) | undefined
let duringRead: (() => Promise<unknown>) | undefined
const router = createServer((req, res) => {
res.setHeader("content-type", "application/json")
const path = decodeURIComponent((req.url ?? "").slice(5))
if (req.method === "GET") {
gets++
const respond = () => {
if (mode === "provider-error") { res.statusCode = 400; res.end('{"message":"NEVER_CASCADE_PROVIDER_PASSWORD"}'); return }
if (!Object.hasOwn(rows, path)) { res.statusCode = 404; res.end("{}"); return }
// Runtime traffic and DHCP lease clocks must not become configuration drift.
rows["/interface/wireguard/peers"].find(row => row[".id"] === "*pf")!.rx = String(gets)
res.end(JSON.stringify(rows[path]))
}
if (duringRead) { const hook = duringRead; duringRead = undefined; void hook().then(respond, () => { res.statusCode = 503; res.end("{}"); }); return }
respond(); return
}
const bases = ["/interface/wireguard/peers", "/interface/wireguard", "/ip/address", "/ipv6/address"]
const base = bases.find(base => path.startsWith(base + "/"))
if (!base || !["PATCH", "DELETE"].includes(req.method ?? "")) { res.statusCode = 400; res.end("{}"); return }
const id = path.slice(base.length + 1)
let body = ""
req.on("data", chunk => { body += chunk }); req.on("end", async () => {
commands.push(req.method + " " + path)
if (req.method === "PATCH") {
Object.assign(rows[base].find(row => row[".id"] === id)!, JSON.parse(body))
rows["/ipv6/address"] = rows["/ipv6/address"].filter(row => row[".id"] !== "*ll")
rows["/ip/route"] = rows["/ip/route"].filter(row => row[".id"] !== "*dc")
} else {
if (mode !== "ignored") rows[base] = rows[base].filter(row => row[".id"] !== id)
if (base === "/interface/wireguard" && mode !== "ignored") rows["/interface"] = rows["/interface"].filter(row => row[".id"] !== id)
if (mode === "collateral") rows["/ip/address"].find(row => row[".id"] === "*vf")!.comment = "foreign drift"
if (afterDelete) { const hook = afterDelete; afterDelete = undefined; await hook() }
if (mode === "lost") { req.socket.destroy(); return }
}
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 = () => { rows = structuredClone(initial); commands = []; mode = "normal"; afterDelete = undefined }
const wait = async (id: string) => {
for (let n = 0; n < 3000; n++) { 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("WireGuard cascade still live; never replay")
}
let connectionId: string | undefined
try {
await pool.query("INSERT INTO servers(id,name,host,port,use_ssl,password) VALUES(109,'wg-interface-delete','127.0.0.1',$1,false,'NEVER_CASCADE_ENDPOINT_PASSWORD')", [(router.address() as { port: number }).port])
await pool.query("INSERT INTO app_users(id,login,name) VALUES('wg-cascade-user','wg-cascade-user','Cascade fixture')")
await rest.register(wireguardRoutes, { prefix: "/api" })
const connectionInput = { name: "WireGuard cascade deletion", mode: "approval", expiresAt: new Date(Date.now() + 1800000).toISOString(), permissions: ["mm:network:write"], scope: { serverIds: [109], operationIds: ["network.wireguard.interfaces.delete", "ros.wireguard.delete", "operations.reconcile", "operations.recover"], allowGlobal: false }, limits: { callsPerMinute: 120, mutationsPerHour: 100 } }
const access = await createMcpConnection(mcpConnectionCreateSchema.parse(connectionInput), actor)
connectionId = access.connection.id
const principal = await authenticateMcpToken(access.token)
const prepare = async (native = false) => {
const result = await invokeMcpTool(principal, native ? "mm_wireguard_delete_plan" : "mm_wireguard_interface_remove_plan", native ? { serverId: 109, id: "*a1" } : { serverId: 109, interfaceId: "*a1" }) as { planId: string; state: string; changes: { mutationCost: number } }
assert.equal(result.state, "awaiting-approval")
for (const secret of [privateKey, psk, "NEVER_"]) assert.ok(!JSON.stringify(result).includes(secret))
return result
}
const hidden = gets
await assert.rejects(invokeMcpTool(principal, "mm_wireguard_interface_remove_plan", { serverId: 1, interfaceId: "*a1" }))
await assert.rejects(invokeMcpTool(principal, "mm_wireguard_interface_remove_plan", { serverId: 109, interfaceId: "../bad" }))
assert.equal(gets, hidden)
await assert.rejects(prepare(true), (error: { code?: string }) => error.code === "DEPENDENCY_CONFLICT")
assert.equal(commands.length, 0, "Native alias must not acquire cascade permission")
for (const [path, row] of [
["/interface/list/member", { interface: "wg-cascade", list: "LAN" }], ["/interface/vxlan", { interface: "wg-cascade" }], ["/ip/route", { gateway: "198.19.244.2%wg-cascade" }],
["/routing/filter/rule", { rule: 'set gw "wg-cascade";' }], ["/ip/firewall/filter", { "in-interface": "wg-cascade" }], ["/ip/dhcp-server", { interface: "wg-cascade" }],
["/routing/filter/rule", { rule: 'set gw "wg\\2dcascade";' }],
["/ip/ipsec/peer", { "local-address": "198.19.244.1" }], ["/routing/bgp/session", { dynamic: "true", "local.address": "2001:0db8:0244:0:0:0:0:1" }],
["/routing/ospf/interface-template", { networks: "198.19.244.0/30" }], ["/routing/ospf/neighbor", { interface: "wg-cascade", state: "Full" }],
] as [string, Record<string, string>][]) {
reset(); rows[path].push({ ".id": "*ref", ...row })
await assert.rejects(prepare()); assert.equal(commands.length, 0)
assert.equal((await rest.inject({ method: "DELETE", url: "/api/wireguard/interfaces/109/*a1" })).statusCode, 409)
assert.equal(commands.length, 0)
}
reset()
const bindingId = randomUUID()
await pool.query("INSERT INTO user_interface_bindings(id,user_id,server_id,interface_name,peer_public_key) VALUES($1,'wg-cascade-user',109,'*a1','')", [bindingId])
await assert.rejects(prepare()); assert.equal((await rest.inject({ method: "DELETE", url: "/api/wireguard/interfaces/109/*a1" })).statusCode, 409)
await pool.query("DELETE FROM user_interface_bindings WHERE id=$1", [bindingId])
const protectionId = randomUUID()
await pool.query("INSERT INTO mcp_protections(id,object_ref,created_by) VALUES($1,$2::jsonb,'integration')", [protectionId, JSON.stringify({ kind: "wireguard_peer", id: "*p2", serverId: 109, protection: "deny" })])
await assert.rejects(prepare()); assert.equal((await rest.inject({ method: "DELETE", url: "/api/wireguard/interfaces/109/*a1" })).statusCode, 409)
assert.equal(commands.length, 0); await pool.query("DELETE FROM mcp_protections WHERE id=$1", [protectionId])
rows["/interface/wireguard"][0].comment = "MikrotikManager traffic-flow overlay"
await assert.rejects(prepare(), /NetFlow/); reset()
rows["/ip/address"][0].dynamic = "true"
await assert.rejects(prepare()); reset()
const low = await createMcpConnection(mcpConnectionCreateSchema.parse({ ...connectionInput, name: "Insufficient cascade budget", limits: { callsPerMinute: 120, mutationsPerHour: 3 } }), actor)
await assert.rejects(invokeMcpTool(await authenticateMcpToken(low.token), "mm_wireguard_interface_remove_plan", { serverId: 109, interfaceId: "*a1" }), (error: { code?: string }) => error.code === "BUDGET_EXCEEDED")
assert.equal(commands.length, 0)
for (const fault of ["normal", "ignored", "collateral", "lost"]) {
reset()
const plan = await prepare(); assert.equal(plan.changes.mutationCost, 7); await approvePlan(plan.planId, actor, true)
mode = fault
const key = randomUUID(), operation = await applyPlan(principal, plan.planId, key)
const expected = fault === "normal" ? "applied" : fault === "lost" ? "unknown" : "partial"
assert.equal(await wait(operation.id), expected)
assert.equal(commands.length, fault === "normal" ? 6 : 2)
assert.ok(commands[0].startsWith("PATCH /interface/wireguard/"))
const count: number = commands.length
assert.equal((await applyPlan(principal, plan.planId, key)).id, operation.id); assert.equal(commands.length, count)
const reconciled = await invokeMcpTool(principal, "mm_operation_reconcile", { operationId: operation.id }) as { state: string; automaticRetry: boolean; results: { matchesDesiredState: boolean; matchesExpectedPrefixState: boolean; verifiedPrefixCommands: number | null }[] }
assert.equal(reconciled.state, expected); assert.equal(reconciled.automaticRetry, false)
assert.equal(reconciled.results[0].matchesDesiredState, fault === "normal")
assert.equal(reconciled.results[0].matchesExpectedPrefixState, fault !== "collateral")
assert.equal(reconciled.results[0].verifiedPrefixCommands, fault === "normal" ? 6 : fault === "ignored" ? 1 : fault === "lost" ? 2 : null)
assert.equal(commands.length, count)
await assert.rejects(invokeMcpTool(principal, "mm_operation_recovery_plan", { operationId: operation.id }), (error: { code?: string }) => error.code === "UNSUPPORTED_CAPABILITY")
if (fault === "normal") {
assert.deepEqual(rows["/interface/wireguard"], [initial["/interface/wireguard"][1]])
assert.deepEqual(rows["/ip/address"], [initial["/ip/address"][1]]); assert.deepEqual(rows["/ipv6/address"], [])
}
}
reset()
const paused = await prepare(); await approvePlan(paused.planId, actor, true)
afterDelete = () => setConnectionStatus(access.connection.id, "paused", actor)
const stopped = await applyPlan(principal, paused.planId, randomUUID())
assert.equal(await wait(stopped.id), "unknown"); assert.equal(commands.length, 2)
await setConnectionStatus(access.connection.id, "active", actor)
reset()
const stale = await prepare(); await approvePlan(stale.planId, actor, true)
rows["/interface/wireguard/peers"][2].opaque = "NEVER_LATE_CHANGE"
assert.equal(await wait((await applyPlan(principal, stale.planId, randomUUID())).id), "rejected"); assert.equal(commands.length, 0)
reset()
const beforePause = gets
duringRead = () => setConnectionStatus(access.connection.id, "paused", actor)
await assert.rejects(prepare()); assert.equal(gets, beforePause + 1)
await setConnectionStatus(access.connection.id, "active", actor)
reset(); mode = "provider-error"
await assert.rejects(prepare(), (error: Error) => !error.message.includes("NEVER_"))
assert.ok(!(await rest.inject({ method: "DELETE", url: "/api/wireguard/interfaces/109/*a1" })).body.includes("NEVER_"))
reset()
const restResult = await rest.inject({ method: "DELETE", url: "/api/wireguard/interfaces/109/*a1" })
assert.equal(restResult.statusCode, 200, restResult.body); assert.equal(restResult.json().verified, true); assert.equal(restResult.json().revisionRecorded, true); assert.equal(restResult.json().afterProof, undefined); assert.equal(commands.length, 6)
reset(); rows["/interface/wireguard/peers"] = rows["/interface/wireguard/peers"].filter(row => row.interface === "wg-foreign"); rows["/ip/address"] = rows["/ip/address"].filter(row => row.interface !== "wg-cascade"); rows["/ipv6/address"] = []; rows["/ip/route"] = []
const legacy = await prepare(true); await approvePlan(legacy.planId, actor, true); await pool.query("UPDATE mcp_plans SET operation_version=1 WHERE id=$1", [legacy.planId])
await assert.rejects(applyPlan(principal, legacy.planId, randomUUID()), (error: { code?: string }) => error.code === "PLAN_EXPIRED")
const empty = await prepare(true); await approvePlan(empty.planId, actor, true)
assert.equal(await wait((await applyPlan(principal, empty.planId, randomUUID())).id), "applied"); assert.equal(commands.length, 1); assert.ok(commands[0].startsWith("DELETE /interface/wireguard/"))
assert.equal((await pool.query("SELECT count(*)::int AS n FROM mcp_requests WHERE connection_id=$1 AND (result::text LIKE '%NEVER_%' OR result::text LIKE $2 OR result::text LIKE $3)", [connectionId, "%" + privateKey + "%", "%" + psk + "%"])).rows[0].n, 0)
console.log("✓ WireGuard interface cascade shares REST/MCP: explicit children and native single-object alias, pre-disable/order/budget, protocol/IP/user/NetFlow/protection guards, private prefix proofs, per-command read-back, partial/lost/revoke/no replay, revision receipt and preserved foreign configuration")
} finally {
await rest.close(); await new Promise<void>(resolve => router.close(() => resolve()))
if (connectionId) await setConnectionStatus(connectionId, "paused", actor)
await pool.query("DELETE FROM user_interface_bindings WHERE user_id='wg-cascade-user'")
await pool.query("DELETE FROM app_users WHERE id='wg-cascade-user'")
await pool.query("DELETE FROM servers WHERE id=109")
}
}