Files
MikrotikManager/backend/src/services/router-configuration-writer-context.test.ts
T

273 lines
21 KiB
TypeScript

/** Genuine MCP private provenance/current-state/key checks; explicitly mocked
* guard kernel and SQL transport. No DB, sockets or all-writer coverage claim. */
import assert from "node:assert/strict"
import { AsyncLocalStorage } from "node:async_hooks"
import { randomUUID } from "node:crypto"
import { lstat, mkdir, mkdtemp, readFile, realpath, rm, unlink, writeFile } from "node:fs/promises"
import { basename, dirname, join, resolve } from "node:path"
import { tmpdir } from "node:os"
import { mock, test } from "node:test"
import { setTimeout as delay } from "node:timers/promises"
import { performance } from "node:perf_hooks"
import { pool, closePool } from "../db/index.js"
import { withVerifiedConfigurationChange, type VerifiedMcpServiceMetadata } from "./config-mutation-policy.js"
import { redact } from "../modules/mcp/security.js"
import type { RouterGuardDependencies, RouterGuardWriteBinding } from "./router-configuration-guard.js"
import type { TrustedRouterWriterOriginProvider, TrustedRouterWriterOriginSnapshot } from "./router-configuration-writer-context.js"
class Refused extends Error {}
class Unknown extends Error {}
const events: Array<{ event: string; pid: number; binding?: RouterGuardWriteBinding }> = []
let nextPid = 0, factoryCalls = 0, childGate: Promise<void> | undefined
const observedLifetimes: Array<{ deadlineAt: number; actorExpiresAt: number; commandDeadlineAt: number; monotonicEnd: number }> = []
const kernelFrame = new AsyncLocalStorage<{ pid: number; receipts: number }>()
mock.module("./router-configuration-guard.js", { namedExports: { RouterGuardRefused: Refused, RouterGuardUnknown: Unknown,
createConfiguredRouterGuard: (_config: unknown, deps: RouterGuardDependencies) => {
factoryCalls++
const authorize = async (binding: RouterGuardWriteBinding, scope: { deadlineAt: number }) => {
await deps.authorize(binding, scope); const authority = await deps.readOriginalWriterAuthority(binding, scope)
observedLifetimes.push({ deadlineAt: scope.deadlineAt, ...authority })
}
return {
async runCompound<T>(binding: RouterGuardWriteBinding, scope: { deadlineAt: number }, work: () => Promise<T>) {
await authorize(binding, scope)
const parent = kernelFrame.getStore(), frame = parent ?? { pid: ++nextPid, receipts: 0 }
events.push({ event: parent ? "nested-intent" : "intent", pid: frame.pid, binding })
try {
const value = await kernelFrame.run(frame, work); await authorize(binding, scope)
events.push({ event: parent ? "nested-complete" : frame.receipts ? "terminal" : "no-send", pid: frame.pid }); return value
} catch (error) { events.push({ event: "pending", pid: frame.pid }); throw error }
},
async runApplication<T>(binding: RouterGuardWriteBinding, scope: { deadlineAt: number }, work: (client: { query(text: string): Promise<unknown> }) => Promise<T>) {
await authorize(binding, scope); const frame = kernelFrame.getStore(); assert(frame)
events.push({ event: "physical-app", pid: frame.pid, binding }); await childGate
const value = await work({ async query(text) { assert.equal(text, "INSERT owned"); return { rows: [], command: "INSERT" } } })
await authorize(binding, scope); frame.receipts++; return value
},
async runNative(binding: RouterGuardWriteBinding, scope: { deadlineAt: number }) {
await authorize(binding, scope); const frame = kernelFrame.getStore(); assert(frame)
events.push({ event: "physical-native", pid: frame.pid, binding }); frame.receipts++; return { physicalMock: true }
}, async close() {},
}
},
} })
test("explicit outer writer with genuine MCP origin and mocked guard/SQL", async t => {
const directory = await mkdtemp(join(tmpdir(), "router-writer-context-")), oldState = process.env.MCP_STATE_DIR
process.env.MCP_STATE_DIR = directory
const keyFile = join(directory, "encryption-key"), generationFile = join(directory, "access-generation")
const originalQuery = pool.query, originalConnect = pool.connect
let row: Record<string, unknown> | undefined, queryHook: (() => Promise<void>) | undefined, lowerHeld = false
pool.query = (async () => { await queryHook?.(); return { rows: row ? [structuredClone(row)] : [] } }) as never
pool.connect = (() => { throw Error("No physical DB in context unit") }) as never
const { createConfiguredRouterConfigurationWriter } = await import("./router-configuration-writer-context.js")
type Writer = ReturnType<typeof createConfiguredRouterConfigurationWriter>
const all: Writer[] = [], scope = () => ({ deadlineAt: Date.now() + 10000 })
const config = { databaseUrl: "not-read-by-mocked-kernel", applicationDatabaseUrl: "not-read-by-mocked-kernel", sourceFile: "fixture", trustKeyFile: "fixture", trustKeySha256: "f".repeat(64), eventKeyFile: "fixture" }
const make = (external?: TrustedRouterWriterOriginProvider) => { const writer = createConfiguredRouterConfigurationWriter(config, { applicationPool: pool, rest: external, scheduler: external,
nativeTransport: async () => { throw Error("No native in context unit") }, assertNoLowerLockContext() { assert.equal(lowerHeld, false) } }); all.push(writer); return writer }
async function fixture() {
process.env.MCP_STATE_DIR = directory
childGate = undefined; queryHook = undefined; events.length = 0; observedLifetimes.length = 0; lowerHeld = false
await writeFile(keyFile, Buffer.alloc(32, 17)); await writeFile(generationFile, Buffer.alloc(32, 23))
const expiry = Date.now() + 20000, connectionId = randomUUID(), input = { serverId: 71, reviewedValue: "sealed-only" }
const metadata: VerifiedMcpServiceMetadata = { operationId: randomUUID(), planId: randomUUID(), operationName: "owned.writer", serviceName: "owned.write", stepIndex: 0, phase: "forward", operationVersion: 1, policyVersion: 1,
generation: "original-generation", originalExpiresAt: expiry, sealedEvidenceProof: "e".repeat(64), sealedPayloadProof: "f".repeat(64), originalTemporaryGrantProof: "a".repeat(64), originalTemporaryGrantExpiresAt: null,
principal: { connectionId, credentialId: randomUUID(), credentialExpiresAt: new Date(expiry + 1000).toISOString() }, serviceInput: input }
let authorized = true, authorizations = 0
const context = { actorId: "owned-original-owner", connectionId, approved: false, serverIds: [71], objects: [{ kind: "server" as const, serverId: 71, id: "71" }], serverWide: true, serviceExecution: metadata,
authorize: async () => { authorizations++; if (!authorized) throw Error("original authority revoked") } }
row = { operation_state: "running", plan_state: "executing", step_state: "intent", server_id: null, operation_id: metadata.operationName, operation_version: 1, policy_version: 1, generation: metadata.generation,
owner_id: context.actorId, approved_by: null, expires_at: new Date(expiry), evidence_proof: metadata.sealedEvidenceProof, payload_proof: metadata.sealedPayloadProof, intended_state: redact({ kind: "service", service: metadata.serviceName, input }) }
return { context, input, revoke() { authorized = false }, authorizations: () => authorizations }
}
const write = (client: { query: (text: string) => Promise<unknown> }) => client.query("INSERT owned")
try {
await t.test("no origin callback/JSON/fake guard can manufacture a live MCP writer", async () => {
await fixture(); const writer = make(), before = factoryCalls
await assert.rejects(writer.captureMcp(scope()))
await assert.rejects(writer.captureRest(scope())); await assert.rejects(writer.captureScheduler(scope()))
await assert.rejects(writer.run({ verified: true }, scope(), async () => ({ acknowledged: true })))
assert.equal(events.length, 0); assert.equal(factoryCalls, before)
})
await t.test("capture occurs before lower locks; binding derives from sealed current metadata", async () => {
const f = await fixture(), writer = make()
await withVerifiedConfigurationChange(f.context, async () => {
const token = await writer.captureMcp(scope())
await writer.run(token, scope(), async facade => { lowerHeld = true; try { await facade.application(write) } finally { lowerHeld = false } })
})
assert.deepEqual(events.map(event => event.event), ["intent", "physical-app", "terminal"])
const command = events[0].binding!.command as { serviceInput: unknown }
assert.deepEqual(command.serviceInput, f.input); assert.match(events[0].binding!.actorProof, /^[a-f0-9]{64}$/)
})
await t.test("zero-activity legacy callback JSON leaves pending instead of minting no-send", async () => {
const f = await fixture(), writer = make()
await withVerifiedConfigurationChange(f.context, async () => { const token = await writer.captureMcp(scope()); await assert.rejects(writer.run(token, scope(), async () => ({ actualAck: true })), Unknown) })
assert.deepEqual(events.map(event => event.event), ["intent", "pending"])
})
await t.test("foreign/serialized/copy origins, replay and retired facade refuse", async () => {
const f = await fixture(), writer = make(), foreign = make()
await withVerifiedConfigurationChange(f.context, async () => {
const token = await writer.captureMcp(scope())
for (const other of [JSON.parse(JSON.stringify(token)), { ...token }]) await assert.rejects(writer.run(other, scope(), async () => {}))
await assert.rejects(foreign.run(token, scope(), async () => {}))
let saved!: { application: (work: typeof write) => Promise<unknown> }
await writer.run(token, scope(), async facade => { saved = facade; await facade.application(write) })
await assert.rejects(writer.run(token, scope(), async () => {})); await assert.rejects(saved.application(write))
})
})
await t.test("nested writer borrows same kernel cohort and cannot dispatch outside original server IDs", async () => {
const f = await fixture(), writer = make()
await withVerifiedConfigurationChange(f.context, async () => {
const token = await writer.captureMcp(scope())
await writer.run(token, scope(), async () => { await writer.run(token, scope(), async facade => { await facade.application(write) }) })
})
assert.equal(new Set(events.map(event => event.pid)).size, 1); assert.equal(events.filter(event => event.event === "terminal").length, 1)
const second = await fixture()
await withVerifiedConfigurationChange(second.context, async () => {
const token = await writer.captureMcp(scope())
await assert.rejects(writer.run(token, scope(), async facade => { await facade.native({ kind: "native", managedServerId: 72, endpoint: { host: "127.0.0.1", port: 80, username: "fixture", password: "fixture", useSsl: false, verifySsl: true }, command: {}, method: "PATCH", requestPath: "/rest/ip/address/*1" }).catch(() => {}) }), Unknown)
})
assert.equal(events.some(event => event.event === "physical-native"), false)
})
await t.test("revoked genuine actor/current SQL state or changed existing key/generation refuse", async () => {
for (const fault of ["actor", "row", "key", "generation", "deleted-key"] as const) {
const f = await fixture(), writer = make()
await withVerifiedConfigurationChange(f.context, async () => {
const token = await writer.captureMcp(scope())
await assert.rejects(writer.run(token, scope(), async facade => {
await facade.application(write)
if (fault === "actor") f.revoke()
else if (fault === "row") row!.step_state = "acknowledged"
else if (fault === "deleted-key") await unlink(keyFile)
else await writeFile(fault === "key" ? keyFile : generationFile, Buffer.alloc(32, 99))
}))
})
assert.equal(events.at(-1)!.event, "pending"); assert.equal(events.some(event => event.event === "terminal"), false)
if (fault === "deleted-key") await assert.rejects(readFile(keyFile))
}
})
await t.test("lower-lock capture, pre-abort and original scope expiry refuse before intent", async () => {
const f = await fixture(), writer = make()
await withVerifiedConfigurationChange(f.context, async () => {
lowerHeld = true; await assert.rejects(writer.captureMcp(scope())); lowerHeld = false
const controller = new AbortController(); controller.abort()
await assert.rejects(writer.captureMcp({ ...scope(), signal: controller.signal }))
await assert.rejects(writer.captureMcp({ deadlineAt: Date.now() - 1 }))
})
assert.equal(events.length, 0)
})
await t.test("missing existing key or generation refuses before generic authorizer without bootstrap", async () => {
for (const missing of [keyFile, generationFile]) {
const f = await fixture(), writer = make()
await unlink(missing)
await withVerifiedConfigurationChange(f.context, async () => {
const before = f.authorizations()
await assert.rejects(writer.captureMcp(scope()))
assert.equal(f.authorizations(), before)
await assert.rejects(readFile(missing), { code: "ENOENT" })
})
assert.equal(events.length, 0)
}
})
await t.test("same-byte state-directory clone cannot revive captured origin before intent", async () => {
const f = await fixture(), writer = make(), clone = join(directory, "same-byte-clone")
await mkdir(clone)
await writeFile(join(clone, "encryption-key"), await readFile(keyFile))
await writeFile(join(clone, "access-generation"), await readFile(generationFile))
try {
await withVerifiedConfigurationChange(f.context, async () => {
const token = await writer.captureMcp(scope()), before = f.authorizations()
process.env.MCP_STATE_DIR = clone
await assert.rejects(writer.run(token, scope(), async facade => { await facade.application(write) }))
assert.equal(f.authorizations(), before)
})
assert.equal(events.length, 0)
} finally { process.env.MCP_STATE_DIR = directory }
})
await t.test("deleted captured material refuses current checks before generic authorizer can bootstrap", async () => {
for (const missing of [keyFile, generationFile]) {
const f = await fixture(), writer = make()
await withVerifiedConfigurationChange(f.context, async () => {
const token = await writer.captureMcp(scope()), before = f.authorizations()
await unlink(missing)
await assert.rejects(writer.run(token, scope(), async facade => { await facade.application(write) }))
assert.equal(f.authorizations(), before)
await assert.rejects(readFile(missing), { code: "ENOENT" })
})
assert.equal(events.length, 0)
}
})
await t.test("genuine MCP first caller abort cannot be replaced by a new run signal or extended scope", async () => {
const f = await fixture(), writer = make(), caller = new AbortController()
await withVerifiedConfigurationChange(f.context, async () => {
const first = { deadlineAt: Date.now() + 5000, signal: caller.signal }, token = await writer.captureMcp(first)
first.deadlineAt = Date.now() + 60000; first.signal = new AbortController().signal; caller.abort()
await assert.rejects(writer.run(token, { deadlineAt: Date.now() + 60000, signal: new AbortController().signal }, async facade => { await facade.application(write) }))
})
assert.equal(events.length, 0)
})
await t.test("genuine MCP original short capture monotonic end survives wall rollback before run", async () => {
const f = await fixture(), writer = make(), originalNow = Date.now
await withVerifiedConfigurationChange(f.context, async () => {
const token = await writer.captureMcp({ deadlineAt: Date.now() + 100 })
await delay(110)
try {
Date.now = () => originalNow() - 60000
await assert.rejects(writer.run(token, { deadlineAt: originalNow() + 60000 }, async facade => { await facade.application(write) }))
} finally { Date.now = originalNow }
})
assert.equal(events.length, 0)
})
await t.test("adapter pins first external scope even if synthetic opaque provider ignores all requested lifetimes", async () => {
// Explicit opaque TEST provider, not genuine REST/scheduler provenance.
// Its deliberate scope blindness proves the adapter's independent bound.
for (const kind of ["rest", "scheduler"] as const) {
await fixture(); const issued = new WeakSet<object>(), now = Date.now(), end = performance.now() + 60000
const original: TrustedRouterWriterOriginSnapshot = { binding: { kind: "compound", endpoint: { owned: kind }, command: { owned: "scope-fixture" }, actorProof: "a".repeat(64) },
authority: { actorProof: "a".repeat(64), actorExpiresAt: now + 60000, commandDeadlineAt: now + 60000, monotonicEnd: end }, serverIds: [71] }
const provider: TrustedRouterWriterOriginProvider = { async capture() { const value = Object.freeze(Object.create(null)) as object; issued.add(value); return value },
async inspect(value) { assert(value && typeof value === "object" && issued.has(value)); return original } }
const writer = make(provider), first = { deadlineAt: Date.now() + 5000, signal: new AbortController().signal }
const token = kind === "rest" ? await writer.captureRest(first) : await writer.captureScheduler(first)
await writer.run(token, { deadlineAt: Date.now() + 60000 }, async facade => { await facade.application(write) })
assert(observedLifetimes.length > 0)
for (const lifetime of observedLifetimes) {
assert(lifetime.deadlineAt <= first.deadlineAt); assert(lifetime.actorExpiresAt <= first.deadlineAt)
assert(lifetime.commandDeadlineAt <= first.deadlineAt); assert(lifetime.monotonicEnd < end)
}
events.length = 0
const caller = new AbortController(), doomed = kind === "rest" ? await writer.captureRest({ deadlineAt: Date.now() + 5000, signal: caller.signal }) : await writer.captureScheduler({ deadlineAt: Date.now() + 5000, signal: caller.signal })
caller.abort(); await assert.rejects(writer.run(doomed, { deadlineAt: Date.now() + 60000, signal: new AbortController().signal }, async facade => { await facade.application(write) }))
assert.equal(events.length, 0)
}
})
await t.test("aborted or expired capture cannot inspect/enroll a late synthetic opaque origin", async () => {
for (const mode of ["abort", "expiry"] as const) {
await fixture(); let enter!: () => void, release!: () => void, inspections = 0
const started = new Promise<void>(resolve => { enter = resolve }), held = new Promise<void>(resolve => { release = resolve })
const provider: TrustedRouterWriterOriginProvider = { async capture() { enter(); await held; return Object.freeze(Object.create(null)) }, async inspect() { inspections++; assert.fail("late capture inspected") } }
const writer = make(provider), caller = new AbortController(), pending = writer.captureRest({ deadlineAt: Date.now() + (mode === "expiry" ? 30 : 5000), signal: caller.signal })
await started; if (mode === "abort") caller.abort(); else await delay(40)
release(); await assert.rejects(pending); assert.equal(inspections, 0); assert.equal(events.length, 0)
}
})
await t.test("unawaited child cannot finish outer writer; late continuation cannot mint a terminal", async () => {
const f = await fixture(), writer = make(); let release!: () => void
childGate = new Promise<void>(done => { release = done })
await withVerifiedConfigurationChange(f.context, async () => {
const token = await writer.captureMcp(scope()); let child: Promise<unknown> | undefined
await assert.rejects(writer.run(token, scope(), async facade => { child = facade.application(write); void child.catch(() => {}) }), Unknown)
release(); await assert.rejects(child!)
})
assert.equal(events.some(event => event.event === "terminal"), false)
})
} finally {
childGate = undefined; await Promise.all(all.map(writer => writer.close())); pool.query = originalQuery; pool.connect = originalConnect; await closePool()
if (oldState === undefined) delete process.env.MCP_STATE_DIR; else process.env.MCP_STATE_DIR = oldState
const actual = resolve(await realpath(directory)), root = resolve(await realpath(tmpdir())), stat = await lstat(directory)
assert(stat.isDirectory() && !stat.isSymbolicLink()); assert.equal(dirname(actual), root); assert.match(basename(actual), /^router-writer-context-[A-Za-z0-9]+$/)
await rm(actual, { recursive: true, force: true })
}
})