103 lines
10 KiB
TypeScript
103 lines
10 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 { createIpsecUserUpdateAdapter, ipsecUserUpdateActionSchema, ipsecUserPskPurpose } from "./ipsec-user-update-actions.js"
|
|
import { redact } from "./security.js"
|
|
|
|
const operation = "network.ipsec.users.update", 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
|
|
const request = { serverId: 1, clientId: "identity:*i1", patch: {} }
|
|
assert.equal(ipsecUserPskPurpose(1, request.clientId), "ipsec-user-psk:1:identity:*i1")
|
|
assert.equal(ipsecUserUpdateActionSchema.safeParse({ ...request, patch: { psk: "NEVER_RAW_PSK" } }).success, false)
|
|
assert.equal(ipsecUserUpdateActionSchema.safeParse({ ...request, patch: { pskSecretRef: randomUUID(), staticIp: null, disabled: false, remoteId: "", name: "new" } }).success, true)
|
|
assert.equal(ipsecUserUpdateActionSchema.safeParse({ ...request, patch: { unknown: true } }).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 = structuredClone(connection), state: IpsecPeerDeleteState, endpoint = sourceProof, reads = 0, commands = 0, histories = 0, ignored: string[] = [], failHistory = false
|
|
let secretRow: Record<string, unknown> | undefined, onRead: (() => void) | undefined, beforeCommand: (() => void) | undefined
|
|
let rows: Record<string, unknown>[] = [], latestInput: Record<string, unknown> | undefined, latestReceipt: Record<string, unknown> | undefined, receivedPatch: unknown
|
|
const sealed = new Map<string, string>()
|
|
const reset = () => {
|
|
current = structuredClone(connection); endpoint = sourceProof; ignored = []; failHistory = false; secretRow = undefined; onRead = undefined; beforeCommand = undefined; rows = []
|
|
state = { source: sourceProof, proof: beforeProof, catalogs: {}, protections: [{ object_ref: { kind: "ipsec_identity", id: "*protected" } }] }
|
|
}
|
|
reset()
|
|
const adapter = createIpsecUserUpdateAdapter({
|
|
connection: async () => current,
|
|
router: async () => ({ server: { id: 1 } as ServerRow, client: {} as never }),
|
|
sourceProof: async () => endpoint,
|
|
read: async (_server, authorize) => { await authorize?.(); reads++; onRead?.(); await authorize?.(); return structuredClone(state) },
|
|
seal: async value => { const key = `sealed:${randomUUID()}`; sealed.set(key, value); return key },
|
|
open: async value => { if (value.startsWith("psk-cipher")) return "NEVER_PLAINTEXT_PSK"; const found = sealed.get(value); if (!found) throw Error("invalid ciphertext"); return found },
|
|
query: async sql => sql.includes("mcp_secrets") ? secretRow ? [structuredClone(secretRow)] : [] : rows,
|
|
verifiedAccess: async () => {}, checkpoint: async () => {},
|
|
plan: ((_state: unknown, _server: unknown, clientId: string, patch: Record<string, unknown>) => ({ commands: Object.keys(patch).length ? [{ action: "update", path: "/ip/ipsec/identity", id: "*i1", fields: {} }] : [], companions: [{ kind: "ipsec_peer", id: "*p1" }], target: { kind: "ipsec_user", id: clientId }, ignoredFields: ignored })) as never,
|
|
update: (async (_server: unknown, clientId: string, patch: Record<string, unknown>, expected: string, authorize: () => Promise<void>, options: { receiptId: string; checkpoint: (value: unknown) => Promise<void> }) => {
|
|
assert.equal(expected, beforeProof); receivedPatch = patch
|
|
await authorize(); beforeCommand?.(); await authorize()
|
|
const count = Object.keys(patch).length ? 1 : 0; commands += count; histories++
|
|
state.proof = afterProof
|
|
const result = { ok: true, verified: true, receiptId: options.receiptId, clientId, commandCount: count, completedCommands: count, confirmedWrites: count, afterProof, historyRecorded: !failHistory, revisionRecorded: !failHistory, automaticReplay: false, forwardingVerified: false }
|
|
await options.checkpoint({ receiptId: options.receiptId, commandCount: count, completedCommands: count, afterProof }); latestReceipt = result
|
|
return result
|
|
}) as never,
|
|
})
|
|
const input = async (patch: Record<string, unknown> = {}) => {
|
|
const evidence = await adapter.prepare({ ...request, patch }, context)
|
|
assert.equal(evidence.requiresHuman, true)
|
|
assert.equal(evidence.mutationCost, Object.keys(patch).length ? 2 : 1)
|
|
assert.ok(evidence.objects.some(ref => ref.kind === "ipsec_peer" && ref.id === "*p1"))
|
|
assert.ok(evidence.objects.some(ref => ref.id === "*protected"))
|
|
assert.ok(!JSON.stringify(evidence).includes("NEVER_PLAINTEXT"))
|
|
const step = evidence.steps[0]!; assert.equal(step.kind, "service")
|
|
if (step.kind !== "service") throw Error("Expected service")
|
|
latestInput = step.input; return { input: step.input, evidence }
|
|
}
|
|
let prepared = await input()
|
|
assert.deepEqual(await adapter.service.current(prepared.input), { proof: beforeProof })
|
|
let receipt = await adapter.service.execute(prepared.input)
|
|
assert.equal(commands, 0); assert.equal(histories, 1); assert.equal(await adapter.service.verify!(prepared.input, receipt), true)
|
|
reset(); prepared = await input({ disabled: false, remoteId: "" }); receipt = await adapter.service.execute(prepared.input)
|
|
assert.deepEqual(receivedPatch, { disabled: false, remoteId: "" }); assert.equal(await adapter.service.verify!(prepared.input, receipt), true)
|
|
rows = [{ connection_id: principal.connectionId, state: "verified", intended_state: redact({ kind: "service", service: operation, input: prepared.input }), result: receipt }]
|
|
assert.equal((await adapter.service.reconcile!(prepared.input, async () => {})).matchesDesiredState, true)
|
|
for (const key of ["historyRecorded", "revisionRecorded", "verified", "completedCommands", "confirmedWrites", "receiptId", "clientId", "afterProof"]) {
|
|
const saved = structuredClone(rows[0]!)
|
|
;(rows[0]!.result as Record<string, unknown>)[key] = "tampered"
|
|
assert.equal((await adapter.service.reconcile!(prepared.input, async () => {})).matchesDesiredState, false, key)
|
|
rows = [saved]
|
|
}
|
|
rows[0]!.state = "applied"; assert.equal((await adapter.service.reconcile!(prepared.input, async () => {})).matchesDesiredState, false)
|
|
reset(); prepared = await input({ disabled: true }); failHistory = true; receipt = await adapter.service.execute(prepared.input)
|
|
assert.equal(await adapter.service.verify!(prepared.input, receipt), false, "native success without mandatory history never VERIFIED")
|
|
reset(); ignored = ["remoteId", "disabled"]; prepared = await input({ remoteId: "ignored", disabled: true }); assert.ok(prepared.evidence.warnings.some(text => text.includes("remoteId, disabled")))
|
|
|
|
reset(); const secretId = randomUUID()
|
|
const goodSecret = { purpose: ipsecUserPskPurpose(1, request.clientId), server_id: 1, created_by: connection.owner_id, ciphertext: "psk-cipher-v1" }
|
|
secretRow = { ...goodSecret }; prepared = await input({ pskSecretRef: secretId })
|
|
assert.ok(!sealed.get(String(prepared.input.bindingCiphertext))!.includes("NEVER_PLAINTEXT_PSK"), "binding stores reference metadata only")
|
|
receipt = await adapter.service.execute(prepared.input); assert.deepEqual(receivedPatch, { psk: "NEVER_PLAINTEXT_PSK" }); assert.equal(await adapter.service.verify!(prepared.input, receipt), true)
|
|
for (const mismatch of [{ created_by: "another-owner" }, { server_id: 2 }, { purpose: "ipsec-user-psk:1:other" }, { ciphertext: "psk-cipher-v2" }]) {
|
|
reset(); secretRow = { ...goodSecret }; prepared = await input({ pskSecretRef: secretId }); const before = reads
|
|
secretRow = { ...goodSecret, ...mismatch }; await assert.rejects(adapter.service.current(prepared.input)); assert.equal(reads, before, "secret drift rejects before native GET")
|
|
}
|
|
reset(); secretRow = { ...goodSecret }; prepared = await input({ pskSecretRef: secretId }); beforeCommand = () => { secretRow = undefined }; const beforeCommands = commands
|
|
await assert.rejects(adapter.service.execute(prepared.input)); assert.equal(commands, beforeCommands, "revocation before command prevents dispatch")
|
|
for (const mutate of [() => { endpoint = "d".repeat(64) }, () => { current.policy.permissions = [] }, () => { current.policy.scope.operationIds = [] }, () => { current.generation = "new-generation" }]) {
|
|
reset(); prepared = await input({ disabled: true }); const before = reads; mutate(); await assert.rejects(adapter.service.current(prepared.input)); assert.equal(reads, before)
|
|
}
|
|
reset(); prepared = await input(); await assert.rejects(adapter.service.current({ ...prepared.input, serverId: 2 })); await assert.rejects(adapter.service.current({ ...prepared.input, receiptId: randomUUID() }))
|
|
const cancelled = new AbortController(); cancelled.abort(); await assert.rejects(adapter.prepare(request, { ...context, signal: cancelled.signal }))
|
|
assert.ok(latestInput && latestReceipt)
|
|
console.log("IPsec user MCP adapter: strict secret refs, owner/purpose/server/cipher rechecks, pre-GET source/access gates, history-only patch, sealed binding, receipt reconciliation and mandatory history fail closed")
|
|
} finally { pool.query = originalQuery; pool.connect = originalConnect }
|