Files
MikrotikManager/backend/src/modules/mcp/flow-settings-actions.test.ts
T

103 lines
8.4 KiB
TypeScript

import assert from "node:assert/strict"
import { randomUUID, randomBytes, createDecipheriv, createHmac } from "node:crypto"
import { mcpConnectionPolicySchema } from "@mmapp/contracts/mcp"
import { createFlowSettingsAdapter, flowSettingsActionSchema } from "./flow-settings-actions.js"
import { fingerprint, seal, redact } from "./security.js"
import type { ConnectionRow } from "./store.js"
import type { FlowSettingsConfiguration } from "../../services/traffic-flow-settings-execution.js"
import { publicMcpChangeEvidence } from "./routing-community-public.js"
function fixture() {
const key = randomBytes(32), principal = { connectionId: randomUUID(), credentialId: randomUUID(), credentialExpiresAt: new Date(Date.now() + 600000).toISOString() }
const connection: ConnectionRow = { id: principal.connectionId, name: "fixture", owner_id: "owner", owner_permissions: ["mm:traffic:write"], generation: "generation", created_at: new Date(), updated_at: new Date(), last_used_at: null, owner_valid_until: new Date(Date.now() + 600000), owner_claims_issued_at: new Date(), policy: mcpConnectionPolicySchema.parse({ id: principal.connectionId, version: 1, status: "active", mode: "autonomous", expiresAt: principal.credentialExpiresAt, permissions: ["mm:traffic:write"], scope: { serverIds: [1, 2], operationIds: ["netflow.settings.update"], allowGlobal: true } }) }
const configuration: FlowSettingsConfiguration = { id: 1, hostPublicKey: "public-existing", hostPrivateKey: "PRIVATE-EXISTING", enabled:false, topN:200, future: "opaque", peersJson: [{ privateOpaque: "retained" }] }
let catalog = [1, 2], protections: Record<string, unknown>[] = [], writes = 0, verified: Record<string, unknown>[] = []
let beforeWrite = () => {}, afterWrite = () => {}
const proof = async (value: unknown) => createHmac("sha256", key).update(fingerprint(value)).digest("hex")
const adapter = createFlowSettingsAdapter({
proof, seal: async value => seal(value, key),
open: async value => { const data = Buffer.from(value, "base64"), c = createDecipheriv("aes-256-gcm", key, data.subarray(0, 12)); c.setAuthTag(data.subarray(12, 28)); return Buffer.concat([c.update(data.subarray(28)), c.final()]).toString() },
connection: async () => connection, verifiedAccess: async () => {},
query: async sql => sql.includes("mcp_operation_steps") ? verified : sql.includes("mcp_protections") ? protections : catalog.map(id => ({ id })),
read: async authorize => { await authorize?.(); return structuredClone(configuration) },
update: async (patch, control) => {
await control?.authorize?.(); beforeWrite(); await control?.authorize?.()
assert.deepEqual(control?.expected?.before, configuration)
assert.deepEqual(control?.expected?.command, {kind:"patch",patch})
Object.assign(configuration,patch); writes++
afterWrite(); await control?.authorize?.()
return {ok:true,receiptId:control!.receiptId!,status:"applied",configurationConfirmed:true,listener:"request-acknowledged",listenerReadinessConfirmed:false,afterProof:await proof(configuration),receiptConfirmed:true,attempts:2,retries:0,privateMaterialExported:false,automaticReplay:false}
},
})
return { adapter, connection, principal, prepare: () => adapter.prepare({settings:{topN:100}}, { connection: structuredClone(connection), principal }),
get configuration() { return configuration }, get writes() { return writes },
catalog: () => { catalog = [1] }, protect: () => { protections = [{ object_ref: { kind: "netflow-settings", id: "1", protection: "deny" }, revision: "2" }] },
before: (fn: () => void) => { beforeWrite = fn }, after: (fn: () => void) => { afterWrite = fn },
verified: (value: Record<string, unknown>) => { verified = [value] },
legacy: (request: Record<string, unknown>, version = 1) => {
const data = Buffer.from(String(request.bindingCiphertext), "base64"), cipher = createDecipheriv("aes-256-gcm", key, data.subarray(0,12))
cipher.setAuthTag(data.subarray(12,28))
const binding = JSON.parse(Buffer.concat([cipher.update(data.subarray(28)),cipher.final()]).toString())
assert.equal(binding.version,3)
binding.version=version
return {...request,bindingCiphertext:seal(JSON.stringify(binding),key)}
} }
}
const input = (evidence: Awaited<ReturnType<ReturnType<typeof fixture>["prepare"]>>) => { assert.equal(evidence.steps[0].kind, "service"); if (evidence.steps[0].kind !== "service") throw Error(); return evidence.steps[0].input }
for (const raw of [{topN:100}, {settings:{}}, {settings:{topN:100,ignored:true}}, {}, { force: true }, { serverId: 1 }, { includePrivateKey: true }, { receiptId: randomUUID() }]) assert.equal(flowSettingsActionSchema.safeParse(raw).success, false)
{
const f = fixture(), evidence = await f.prepare(), request = input(evidence)
assert.deepEqual(await f.adapter.service.current!(request), evidence.before)
assert.equal(evidence.verificationScope, "configuration")
assert.equal(evidence.requiresHuman, true); assert.equal(evidence.mutationCost, 4)
assert.deepEqual(evidence.objects.filter(ref => ref.kind === "server").map(ref => ref.serverId), [1, 2])
const visible = JSON.stringify(redact(publicMcpChangeEvidence("netflow.settings.update", evidence)))
for (const secret of ["PRIVATE-EXISTING", "privateOpaque", "beforeProof", "ownerProof", "principal"]) assert.ok(!visible.includes(secret))
const receipt = await f.adapter.service.execute(request)
assert.equal(f.writes, 1)
assert.equal(await f.adapter.service.verify!(request, receipt), true)
assert.equal(await f.adapter.service.verify!(request, { ...receipt as object, privateMaterialExported: true }), false)
assert.equal((await f.adapter.service.reconcile!(request, async () => {})).matchesDesiredState, false, "matching row without VERIFIED is insufficient")
f.verified({ connection_id: f.principal.connectionId, state: "verified", intended_state: redact({ kind: "service", service: "netflow.settings.update", input: request }), result: receipt })
assert.equal((await f.adapter.service.reconcile!(request, async () => {})).matchesDesiredState, true)
assert.ok(!JSON.stringify(receipt).includes("PRIVATE"))
assert.equal(await f.adapter.service.verify!(request, {...receipt as object, listenerReadinessConfirmed:true}),false)
assert.equal(await f.adapter.service.verify!(request, {...receipt as object, receiptConfirmed:false}),false)
assert.equal(await f.adapter.service.verify!(request, {...receipt as object, listener:"unknown",status:"partial"}),false)
assert.ok(evidence.objects.some(ref=>ref.kind==="database-table"&&ref.id==="flow_ip_meta"))
assert.ok(evidence.objects.some(ref=>ref.kind==="database-table"&&ref.id==="flow_buckets"))
}
for (const change of [
(f: ReturnType<typeof fixture>) => { f.connection.policy.status = "paused" },
(f: ReturnType<typeof fixture>) => { f.connection.policy.scope.allowGlobal = false },
(f: ReturnType<typeof fixture>) => { f.connection.policy.scope.serverIds = [1] },
(f: ReturnType<typeof fixture>) => { f.connection.owner_permissions = [] },
(f: ReturnType<typeof fixture>) => { f.connection.generation = "changed" },
(f: ReturnType<typeof fixture>) => { f.configuration.future = "drift" },
(f: ReturnType<typeof fixture>) => f.catalog(), (f: ReturnType<typeof fixture>) => f.protect(),
]) {
const f = fixture(), request = input(await f.prepare()); change(f)
await assert.rejects(f.adapter.service.execute(request)); assert.equal(f.writes, 0)
}
{
const f = fixture(), request = input(await f.prepare()); f.before(() => f.protect())
await assert.rejects(f.adapter.service.execute(request)); assert.equal(f.writes, 0)
}
{
const f = fixture(), request = input(await f.prepare()); f.after(() => { f.connection.policy.status = "paused" })
await assert.rejects(f.adapter.service.execute(request)); assert.equal(f.writes, 1)
}
{
const f = fixture(), request = input(await f.prepare()); request.receiptId = randomUUID()
await assert.rejects(f.adapter.service.execute(request)); assert.equal(f.writes, 0)
}
console.log("NetFlow settings adapter: strict full patch, human/global/catalog, encrypted source, protections/revoke, sanitized full ACK receipt and no VERIFIED adoption; injected dependencies only")
{
const f=fixture(),request=input(await f.prepare())
await assert.rejects(f.adapter.service.execute({settings:{topN:100}}))
await assert.rejects(f.adapter.service.execute(f.legacy(request)))
await assert.rejects(f.adapter.service.execute(f.legacy(request,2)))
assert.equal(f.writes,0)
}