105 lines
11 KiB
TypeScript
105 lines
11 KiB
TypeScript
import assert from "node:assert/strict"
|
|
import { randomUUID } from "node:crypto"
|
|
import { pool } from "../../db/index.js"
|
|
import type { ActionContext } from "./action-types.js"
|
|
import type { ConnectionRow } from "./store.js"
|
|
import type { ServerRow } from "../servers/repository/servers-repository.js"
|
|
import type { IpsecPeerDeleteState } from "../../services/ipsec-peer-delete.js"
|
|
import type { IpsecServerDeleteCommand } from "../../services/ipsec-server-delete-model.js"
|
|
import { createIpsecServerDeleteAdapter, ipsecServerDeleteActionSchema } from "./ipsec-server-delete-actions.js"
|
|
import { fingerprint, redact } from "./security.js"
|
|
|
|
const operation = "network.ipsec.server.delete", sourceProof = "a".repeat(64), beforeProof = "b".repeat(64), afterProof = "c".repeat(64)
|
|
const principal = { connectionId: randomUUID(), credentialId: randomUUID(), credentialExpiresAt: new Date(Date.now() + 600000).toISOString() }
|
|
const connection = { id: principal.connectionId, owner_id: "fixture-owner", owner_permissions: ["mm:network:write"], generation: "fixture-generation", owner_valid_until: new Date(Date.now() + 600000), policy: { mode: "autonomous", status: "active", expiresAt: principal.credentialExpiresAt, permissions: ["mm:network:write"], scope: { serverIds: [1], operationIds: [operation], allowGlobal: false } } } as ConnectionRow
|
|
const context = { principal, connection } as ActionContext
|
|
assert.deepEqual(ipsecServerDeleteActionSchema.parse({ serverId: 1 }), { serverId: 1, removeCertificates: true })
|
|
for (const raw of [{ serverId: 1, removeCertificates: "true" }, { serverId: 1, psk: "NEVER_SECRET" }, { serverId: 0 }, { serverId: 1, force: true }]) assert.equal(ipsecServerDeleteActionSchema.safeParse(raw).success, false)
|
|
|
|
const originalQuery = pool.query, originalConnect = pool.connect
|
|
const forbidden = () => { throw Error("Unexpected real SQL/native/network access") }
|
|
pool.query = forbidden as typeof pool.query; pool.connect = forbidden as typeof pool.connect
|
|
try {
|
|
let current: ConnectionRow, state: IpsecPeerDeleteState, endpoint = sourceProof, reads = 0, deletes = 0, histories = 0, historyFails = false, noCommands = false, lateAuthority: (() => void) | undefined
|
|
let storedRows: Record<string, unknown>[] = [], unexpectedManifest = false
|
|
const sealed = new Map<string, string>()
|
|
const reset = () => {
|
|
current = structuredClone(connection); endpoint = sourceProof; historyFails = false; noCommands = false; lateAuthority = undefined; unexpectedManifest = false; storedRows = []
|
|
state = { source: sourceProof, proof: beforeProof, catalogs: {}, protections: [{ object_ref: { kind: "ipsec_identity", id: "*protected" } }] }
|
|
}
|
|
reset()
|
|
const commands = (removeCertificates: boolean): IpsecServerDeleteCommand[] => noCommands ? [] : removeCertificates ? [{ path: "/certificate", id: "*ca", cascadeIds: ["*child"] }] : [{ path: "/ip/ipsec/identity", id: "*i1" }]
|
|
const objects = (removeCertificates: boolean) => noCommands ? [] : removeCertificates ? [{ kind: "certificate", id: "*ca" }, { kind: "certificate", id: "*child" }] : [{ kind: "ipsec_identity", id: "*i1" }]
|
|
const adapter = createIpsecServerDeleteAdapter({
|
|
connection: async () => current,
|
|
router: async () => ({ server: { id: 1 } as ServerRow, client: {} as never }),
|
|
sourceProof: async () => endpoint,
|
|
read: async (_server, authorize) => { await authorize?.(); reads++; await authorize?.(); return structuredClone(state) },
|
|
seal: async value => { const key = `sealed:${randomUUID()}`; sealed.set(key, value); return key },
|
|
open: async value => { const found = sealed.get(value); if (!found) throw Error("invalid ciphertext"); return found },
|
|
manifestProof: async value => fingerprint({ privateTestKey: "fixed-pure-fixture", value }),
|
|
query: async () => storedRows, verifiedAccess: async () => {}, checkpoint: async () => {},
|
|
plan: (_state, removeCertificates = true) => ({ commands: unexpectedManifest ? [{ path: "/certificate", id: "*different" }] : commands(removeCertificates), objects: objects(removeCertificates), companions: objects(removeCertificates), removeCertificates }),
|
|
stages: async (before, manifest) => [before.proof, ...manifest.map(() => afterProof)],
|
|
remove: (async (_server: unknown, removeCertificates: boolean, expected: string, authorize: () => Promise<void>, options: { receiptId: string; checkpoint: (value: unknown) => Promise<void> }) => {
|
|
assert.equal(expected, beforeProof); await authorize(); lateAuthority?.(); await authorize()
|
|
const manifest = commands(removeCertificates), affectedObjects = manifest.reduce((sum, cmd) => sum + 1 + (cmd.cascadeIds?.length ?? 0), 0)
|
|
deletes += manifest.length; histories++; state.proof = manifest.length ? afterProof : beforeProof
|
|
const value = { ok: true, verified: true, receiptId: options.receiptId, removeCertificates, commandCount: manifest.length, completedCommands: manifest.length, confirmedWrites: manifest.length, affectedObjects, afterProof: state.proof, historyRecorded: !historyFails, revisionRecorded: !historyFails, automaticReplay: false, forwardingVerified: false }
|
|
await options.checkpoint({ receiptId: options.receiptId, commandCount: manifest.length, completedCommands: manifest.length, afterProof: state.proof }); return value
|
|
}) as never,
|
|
})
|
|
const prepare = async (removeCertificates = true) => {
|
|
const evidence = await adapter.prepare({ serverId: 1, removeCertificates }, context)
|
|
assert.equal(evidence.requiresHuman, true)
|
|
assert.equal(evidence.mutationCost, noCommands ? 1 : removeCertificates ? 3 : 2)
|
|
assert.ok(evidence.objects.some(ref => ref.id === "*protected"))
|
|
if (!noCommands && removeCertificates) assert.ok(evidence.objects.some(ref => ref.id === "*child"), "CA cascade child explicitly protected")
|
|
const step = evidence.steps[0]!; if (step.kind !== "service") throw Error("Expected service")
|
|
assert.deepEqual(Object.keys(step.input).sort(), ["bindingCiphertext", "receiptId", "serverId"])
|
|
assert.equal(JSON.parse(sealed.get(String(step.input.bindingCiphertext))!).proofRevision,2,"New plans require the v2 dependency proof")
|
|
return { evidence, input: step.input }
|
|
}
|
|
let plan = await prepare()
|
|
assert.ok(plan.evidence.warnings.some(value => value.includes("*ca: *child")))
|
|
assert.ok(plan.evidence.warnings.some(value => value.includes("Profiles и proposals сохраняются")))
|
|
assert.deepEqual(await adapter.service.current(plan.input), { proof: beforeProof })
|
|
let receipt = await adapter.service.execute(plan.input)
|
|
assert.equal(deletes, 1); assert.equal(histories, 1); assert.equal(await adapter.service.verify!(plan.input, receipt), true)
|
|
storedRows = [{ connection_id: principal.connectionId, state: "verified", intended_state: redact({ kind: "service", service: operation, input: plan.input }), result: receipt }]
|
|
assert.equal((await adapter.service.reconcile!(plan.input, async () => {})).matchesDesiredState, true)
|
|
for (const field of ["ok", "verified", "receiptId", "removeCertificates", "commandCount", "completedCommands", "confirmedWrites", "affectedObjects", "historyRecorded", "revisionRecorded", "afterProof", "forwardingVerified", "automaticReplay"]) {
|
|
const saved = structuredClone(storedRows[0]!)
|
|
;(storedRows[0]!.result as Record<string, unknown>)[field] = "tampered"
|
|
assert.equal((await adapter.service.reconcile!(plan.input, async () => {})).matchesDesiredState, false, field)
|
|
storedRows = [saved]
|
|
}
|
|
storedRows[0]!.state = "applied"; assert.equal((await adapter.service.reconcile!(plan.input, async () => {})).matchesDesiredState, false)
|
|
reset(); plan = await prepare(false); receipt = await adapter.service.execute(plan.input); assert.equal(await adapter.service.verify!(plan.input, receipt), true)
|
|
reset(); noCommands = true; plan = await prepare(); const beforeEmpty = deletes; receipt = await adapter.service.execute(plan.input)
|
|
assert.equal(deletes, beforeEmpty); assert.equal(await adapter.service.verify!(plan.input, receipt), true, "empty manifest still requires history")
|
|
reset(); plan = await prepare(); historyFails = true; receipt = await adapter.service.execute(plan.input); assert.equal(await adapter.service.verify!(plan.input, receipt), false)
|
|
for (const mutate of [() => { endpoint = "d".repeat(64) }, () => { current.policy.permissions = [] }, () => { current.policy.scope.operationIds = [] }, () => { current.policy.scope.serverIds = [] }, () => { current.generation = "rotated-generation" }]) {
|
|
reset(); plan = await prepare(); const before = reads; mutate(); await assert.rejects(adapter.service.current(plan.input)); assert.equal(reads, before, "authority/source drift rejects before native GET")
|
|
}
|
|
reset(); plan = await prepare(); unexpectedManifest = true; const beforeManifest = deletes; await assert.rejects(adapter.service.execute(plan.input)); assert.equal(deletes, beforeManifest)
|
|
reset(); plan = await prepare(); lateAuthority = () => { current.policy.permissions = [] }; const beforeLate = deletes; await assert.rejects(adapter.service.execute(plan.input)); assert.equal(deletes, beforeLate)
|
|
reset(); plan = await prepare(); const cipher = String(plan.input.bindingCiphertext), binding = JSON.parse(sealed.get(cipher)!)
|
|
for (const mutate of [
|
|
(value: Record<string, unknown>) => { value.proofRevision = 1 },
|
|
(value: Record<string, unknown>) => { value.affectedObjects = 1 },
|
|
(value: Record<string, unknown>) => { value.commandCount = 2 },
|
|
(value: Record<string, unknown>) => { value.stageProofs = [beforeProof] },
|
|
(value: Record<string, unknown>) => { value.manifestProof = "f".repeat(64) },
|
|
]) {
|
|
const changed = structuredClone(binding); mutate(changed); sealed.set(cipher, JSON.stringify(changed)); const before = reads
|
|
await assert.rejects(adapter.service.current(plan.input)); assert.equal(reads, before)
|
|
}
|
|
sealed.set(cipher, JSON.stringify(binding))
|
|
await assert.rejects(adapter.service.current({ ...plan.input, serverId: 2 })); await assert.rejects(adapter.service.current({ ...plan.input, receiptId: randomUUID() }))
|
|
const cancelled = new AbortController(); cancelled.abort(); await assert.rejects(adapter.prepare({ serverId: 1 }, { ...context, signal: cancelled.signal }))
|
|
reset(); plan = await prepare(); let checks = 0
|
|
await adapter.service.reconcile!(plan.input, async () => { checks++; if (checks === 2) throw Error("external authorization revoked") }).then(() => assert.fail("external revocation must fail"), () => {})
|
|
console.log("IPsec server MCP adapter: exact sealed HMAC manifest/stages, CA cascade budget/protections, human-only removal, source/access-before-GET, history-only empty manifest, mandatory-history receipts and verified-only reconciliation")
|
|
} finally { pool.query = originalQuery; pool.connect = originalConnect }
|