Проверено пробами на стенде RouterOS 7.24.5: /certificate не принимает comment, sign и export-certificate адресуются только по .id и не принимают name и days-valid, подпись меняет authority и digest-algorithm, peer с address 0.0.0.0/0 возвращается без address, id файлов имеют вид **<base62>. Сертификаты продукта опознаются по имени и цепочке подписи, версии операций повышены (init 5, user_create 3, экспорт 2). Стабы приёмки отказывают как RouterOS 7.24. Генеральная репетиция на CHR: init 13 и PSK-клиент 2 команды сошлись с проекцией продукта, туннель, ping 10/10, рост SA, сверка 66/66. Co-Authored-By: Claude Opus 5.5 <[email protected]>
161 lines
19 KiB
TypeScript
161 lines
19 KiB
TypeScript
import assert from "node:assert/strict"
|
|
import { randomUUID, createDecipheriv } from "node:crypto"
|
|
import { pool } from "../db/index.js"
|
|
import { fingerprint, seal, McpError } from "../modules/mcp/security.js"
|
|
import type { ServerRow } from "../modules/servers/repository/servers-repository.js"
|
|
import type { AuthUser } from "../lib/permissions.js"
|
|
import { ipsecPeerDeletePaths } from "./ipsec-peer-delete.js"
|
|
import { ipsecUserUpdateValue } from "./ipsec-user-update.js"
|
|
import { ipsecManagedComment, ipsecUserComment } from "./ipsec-config.js"
|
|
import { createIpsecExistingCertificateExportFoundation, exportIpsecExistingCertificateGuarded, IpsecExistingCertificateExportExecutionError, type IpsecExistingCertificateExportDependencies } from "./ipsec-existing-certificate-export.js"
|
|
import { IPSEC_EXISTING_CERTIFICATE_EXPORT_ACTIVATED, ipsecExistingCertificateExportRequestSchema, ipsecExistingCertificateExportSecretPurpose, planIpsecExistingCertificateExport, normalizeIpsecExistingExportPassphrase, projectIpsecExistingCertificateExport, type IpsecExistingCertificateExportAuthority, type IpsecExistingCertificateExportState } from "./ipsec-existing-certificate-export-model.js"
|
|
import { createIpsecExistingCertificateExportArtifact, humanIpsecExistingCertificateExportMetadata, readHumanIpsecExistingCertificateExportArtifact, verifyIpsecExistingCertificateExportArtifact, ipsecExistingCertificateExportArtifactReceipt, ipsecExistingCertificateExportArtifactScopeSchema } from "./ipsec-existing-certificate-export-artifact.js"
|
|
|
|
type Row = Record<string, string>
|
|
const source = "a".repeat(64), reference = "b".repeat(64), server = { id: 1, host: "router.example.test" } as ServerRow
|
|
const base = (): IpsecExistingCertificateExportState => ({ source, proof: "unused", protections: [], catalogs: {
|
|
...Object.fromEntries([...ipsecPeerDeletePaths, "/file"].map(path => [path, []])),
|
|
"/ip/ipsec/peer": [{ ".id": "*p", name: "ike", "exchange-mode": "ike2", certificate: "ipsec-server", comment: ipsecManagedComment() }],
|
|
"/ip/ipsec/identity": [{ ".id": "*i", peer: "ike", "auth-method": "digital-signature", certificate: "ipsec-server", "remote-certificate": "client-cert", "mode-config": "ipsec-vpn", comment: ipsecUserComment("Alice") }],
|
|
"/ip/ipsec/mode-config": [{ ".id": "*m", name: "ipsec-vpn", "static-dns": "192.0.2.53" }],
|
|
"/certificate": [{ ".id": "*a", name: "ca", "key-usage": "key-cert-sign,crl-sign", authority: "true", "private-key": "true", opaque: "NEVER_CA" }, { ".id": "*s", name: "ipsec-server", "common-name": "vpn.example.test", ca: "ca", "key-usage": "tls-server", opaque: "NEVER_SERVER" }, { ".id": "*c", name: "client-cert", "common-name": "Alice", ca: "ca", "key-usage": "tls-client", "private-key": "true", opaque: "NEVER_CLIENT" }, { ".id": "*o", name: "foreign-other", "common-name": "Other", opaque: "NEVER_OTHER" }],
|
|
"/file": [{ ".id": "*f", name: "foreign.p12", size: "5", opaque: "NEVER_FOREIGN_FILE" }],
|
|
} })
|
|
const proof = async (state: IpsecExistingCertificateExportState) => fingerprint(ipsecUserUpdateValue(state))
|
|
const request = ipsecExistingCertificateExportRequestSchema.parse({ serverId: 1, selector: { kind: "client", clientId: "identity:*i" }, privateKeyExport: true, passphrase: { kind: "reference", secretRef: randomUUID() } })
|
|
const receiptId = randomUUID(), clientPlan = planIpsecExistingCertificateExport(base(), server, request, receiptId)
|
|
assert.equal(clientPlan.certificateId, "*c"); assert.equal(clientPlan.role, "client"); assert.equal(clientPlan.userName, "Alice"); assert.equal(clientPlan.serverEndpoint, "vpn.example.test"); assert.equal(clientPlan.dns, "192.0.2.53")
|
|
for (const name of ["client-cert", "ipsec-server", "foreign-other", "ca"]) {
|
|
const plan = planIpsecExistingCertificateExport(base(), server, { ...request, selector: { kind: "certificate", name }, caPrivateKeyExport: name === "ca" }, receiptId)
|
|
assert.equal(plan.certificateName, name); assert.equal(plan.commandCount, 2)
|
|
}
|
|
assert.throws(() => planIpsecExistingCertificateExport(base(), server, { ...request, selector: { kind: "certificate", name: "ca" } }, receiptId), (error: unknown) => error instanceof McpError && error.code === "APPROVAL_REQUIRED")
|
|
assert.throws(() => planIpsecExistingCertificateExport(base(), server, { ...request, selector: { kind: "client", clientId: "cert:*c" } }, receiptId))
|
|
const psk = base(); psk.catalogs["/ip/ipsec/identity"][0]["auth-method"] = "pre-shared-key"; assert.throws(() => planIpsecExistingCertificateExport(psk, server, request, receiptId))
|
|
const unmanaged = base(); unmanaged.catalogs["/ip/ipsec/identity"][0].comment = "foreign"; assert.throws(() => planIpsecExistingCertificateExport(unmanaged, server, request, receiptId))
|
|
for (const key of ["passphraseValue", "psk", "privateKey", "unknown"]) assert.equal(ipsecExistingCertificateExportRequestSchema.safeParse({ ...request, [key]: "NEVER_RAW" }).success, false)
|
|
assert.equal(ipsecExistingCertificateExportRequestSchema.safeParse({ ...request, privateKeyExport: false }).success, false)
|
|
assert.notEqual(ipsecExistingCertificateExportSecretPurpose(1, request.selector), ipsecExistingCertificateExportSecretPurpose(2, request.selector))
|
|
assert.notEqual(ipsecExistingCertificateExportSecretPurpose(1, request.selector), ipsecExistingCertificateExportSecretPurpose(1, { kind: "certificate", name: "client-cert" }))
|
|
let generated = 0
|
|
const generate = () => { generated++; return "NEVER_GENERATED_PASSPHRASE" }
|
|
assert.equal(normalizeIpsecExistingExportPassphrase(" NEVER_PASSPHRASE ", generate), "NEVER_PASSPHRASE")
|
|
assert.equal(normalizeIpsecExistingExportPassphrase(" ", generate), "NEVER_GENERATED_PASSPHRASE")
|
|
assert.equal(normalizeIpsecExistingExportPassphrase(" 123456 ", generate), "NEVER_GENERATED_PASSPHRASE"); assert.equal(generated, 2)
|
|
assert.throws(() => normalizeIpsecExistingExportPassphrase("short", generate))
|
|
const after = base(); after.catalogs["/file"].push({ ".id": "*new", name: clientPlan.filename, size: "7", type: "file", "opaque-default": "NEVER_NEW_FILE" })
|
|
assert.equal(projectIpsecExistingCertificateExport(base(), clientPlan.filename, after).file.id, "*new")
|
|
for (const mutate of [(state: IpsecExistingCertificateExportState) => { state.catalogs["/file"].at(-1)!.size = "61439" }, (state: IpsecExistingCertificateExportState) => { state.catalogs["/file"].at(-1)![".id"] = "*f" }, (state: IpsecExistingCertificateExportState) => { state.catalogs["/file"].at(-1)!.name = "wrong.p12" }]) { const changed = structuredClone(after); mutate(changed); assert.throws(() => projectIpsecExistingCertificateExport(base(), clientPlan.filename, changed)) }
|
|
|
|
const oldQuery = pool.query, oldConnect = pool.connect
|
|
pool.query = (() => { throw Error("Real SQL forbidden") }) as never; pool.connect = (() => { throw Error("Real SQL forbidden") }) as never
|
|
try {
|
|
let state = base(), mode = "normal", sourceCurrent = source, referenceCurrent = reference, revoked = false, generatedCount = 0, downloaded: Buffer | undefined, clockNow = 1000
|
|
let delayNextRead = false, releaseDelayedFence: (() => void) | undefined
|
|
let releaseDownload: (() => void) | undefined, downloadStarted: (() => void) | undefined
|
|
const claims = new Set<string>(), commands: Array<{ method: string; path: string }> = [], checkpoints: unknown[] = [], artifacts = new Map<string, string>(), key = Buffer.alloc(32, 7)
|
|
const fakeBytes = "NEVER_SYNTHETIC_PRIVATE_PKCS12"
|
|
const authority: IpsecExistingCertificateExportAuthority = { principal: { connectionId: randomUUID(), credentialId: randomUUID(), credentialExpiresAt: new Date(Date.now() + 600000).toISOString() }, ownerId: "fixture-owner", ownerProof: "c".repeat(64), policyProof: "d".repeat(64), generation: "fixture-generation", request, receiptId, certificateId: "*c", certificateName: "client-cert", role: "client", sourceProof: source, expectedProof: await proof(state), referenceProof: reference, requestProof: fingerprint(request), inputProof: "e".repeat(64), proofRevision: 1 }
|
|
const access = async (current: IpsecExistingCertificateExportAuthority) => { assert.equal(current.ownerId, authority.ownerId); if (revoked) throw new McpError("PERMISSION_DENIED", "synthetic revoked", 403) }
|
|
const deps: IpsecExistingCertificateExportDependencies = {
|
|
server: async () => server, sourceProof: async () => sourceCurrent, access,
|
|
material: async (_authority, authorize) => { await authorize(); return { passphrase: mode === "whitespace" ? " " : " NEVER_PASSPHRASE ", referenceProof: referenceCurrent } },
|
|
read: async (_server, authorize) => { if (delayNextRead) { delayNextRead = false; await new Promise<void>(resolve => { releaseDelayedFence = resolve }) }; if (mode === "deadlineRead") clockNow += 1000; await authorize(); const result = structuredClone(state); result.proof = await proof(result); await authorize(); return result }, proof,
|
|
boundary: async (_authority, work) => work(),
|
|
claim: async current => { if (claims.has(current.receiptId)) throw new McpError("STATE_CONFLICT", "Receipt already claimed", 409); claims.add(current.receiptId); if (mode === "lateSource") sourceCurrent = "f".repeat(64) },
|
|
checkpoint: async (_authority, value) => { checkpoints.push(structuredClone(value)); if (mode === "deadlineAfterAck") clockNow += 1000; if (mode === "checkpointFailure") throw Error("synthetic checkpoint failure") },
|
|
generatePassphrase: () => { generatedCount++; return "NEVER_GENERATED_PASSPHRASE" },
|
|
clock: () => clockNow,
|
|
publish: async (_authority, bundle, afterProof, authorize) => { if (mode === "deadlinePublish") clockNow += 1000; await authorize(); assert.equal(afterProof, authority.expectedProof); const id = randomUUID(); artifacts.set(id, seal(JSON.stringify(bundle), key)); return { artifactId: id, downloadPath: `/api/mcp/artifacts/${id}`, humanDownloadOnly: true, ipsecContentReturned: false } },
|
|
client: () => ({
|
|
post: async (path: string, fields: Row, _timeout: unknown, _signal: unknown, beforeDispatch: () => Promise<unknown>) => {
|
|
if (mode === "missingPostFence") return {}
|
|
if (mode === "parallelPostFence") { delayNextRead = true; await Promise.all([beforeDispatch().then(() => { commands.push({ method: "POST", path }) }), beforeDispatch()]); return {} }
|
|
await beforeDispatch(); if (mode === "duplicatePostFence") await beforeDispatch(); commands.push({ method: "POST", path }); assert.equal(path, "/certificate/export-certificate"); assert.equal(fields.type, "pkcs12"); assert.equal("name" in fields, false, "RouterOS 7.24 refuses name on export-certificate"); assert.equal(fields[".id"], "*c"); assert.equal(fields["file-name"], clientPlan.exportPrefix)
|
|
if (mode !== "ignored") state.catalogs["/file"].push({ ".id": "*new", name: `${fields["file-name"]}.p12`, size: String(Buffer.byteLength(fakeBytes)), type: "file", opaque: "NEVER_NEW_FILE" })
|
|
if (mode === "collateral") state.catalogs["/certificate"][0].opaque = "NEVER_CHANGED_CA"
|
|
if (mode === "revoked") revoked = true
|
|
if (mode === "secretRevoked") referenceCurrent = "f".repeat(64)
|
|
if (mode === "lost") throw Error("synthetic lost export ACK")
|
|
return {}
|
|
},
|
|
downloadOwnedFile: async (file: { id: string; name: string; size: number }, control: { authorize: () => Promise<unknown> }) => {
|
|
assert.deepEqual(file, { id: "*new", name: clientPlan.filename, size: Buffer.byteLength(fakeBytes) })
|
|
await control.authorize()
|
|
if (mode === "downloadFailure") throw Error("synthetic download failed")
|
|
downloaded = Buffer.from(mode === "shortDownload" ? fakeBytes.slice(1) : fakeBytes)
|
|
await control.authorize()
|
|
if (mode === "postDownloadRevoke") revoked = true
|
|
if (mode === "lateDownload") await new Promise<void>(resolve => { releaseDownload = resolve; downloadStarted!() })
|
|
return downloaded
|
|
},
|
|
delete: async (path: string, _timeout: unknown, beforeDispatch: () => Promise<unknown>) => { if (mode === "missingDeleteFence") return; if (mode === "parallelDeleteFence") { delayNextRead = true; await Promise.all([beforeDispatch().then(() => { commands.push({ method: "DELETE", path }) }), beforeDispatch()]); return }; await beforeDispatch(); if (mode === "duplicateDeleteFence") await beforeDispatch(); commands.push({ method: "DELETE", path }); assert.equal(path, "/file/*new"); state.catalogs["/file"] = state.catalogs["/file"].filter(row => row[".id"] !== "*new"); if (mode === "cleanupLost") throw Error("synthetic lost cleanup ACK") },
|
|
}) as never,
|
|
}
|
|
const run = createIpsecExistingCertificateExportFoundation(deps)
|
|
const reset = () => { state = base(); mode = "normal"; sourceCurrent = source; referenceCurrent = reference; revoked = false; claims.clear(); commands.length = 0; checkpoints.length = 0; downloaded = undefined; generatedCount = 0; artifacts.clear(); clockNow = 1000; delayNextRead = false; releaseDelayedFence = undefined }
|
|
for (const whitespace of [false, true]) {
|
|
reset(); if (whitespace) mode = "whitespace"
|
|
const receipt = await run(authority)
|
|
assert.equal(receipt.verified, true); assert.equal(receipt.commandCount, 2); assert.equal(receipt.completedCommands, 2); assert.equal(commands.length, 2); assert.deepEqual(state, base()); assert.equal(downloaded!.every(byte => byte === 0), true)
|
|
assert(!JSON.stringify(receipt).includes("NEVER_")); assert(!JSON.stringify(checkpoints).includes("NEVER_")); assert(!JSON.stringify([...artifacts.values()]).includes("NEVER_"))
|
|
const encrypted = Buffer.from(artifacts.get(receipt.artifactId)!, "base64"), decipher = createDecipheriv("aes-256-gcm", key, encrypted.subarray(0, 12)); decipher.setAuthTag(encrypted.subarray(12, 28)); const bundle = JSON.parse(Buffer.concat([decipher.update(encrypted.subarray(28)), decipher.final()]).toString())
|
|
assert.equal(Buffer.from(bundle.contentB64, "base64").toString(), fakeBytes); assert.equal(bundle.passphrase, whitespace ? "NEVER_GENERATED_PASSPHRASE" : "NEVER_PASSPHRASE"); assert.equal(generatedCount, whitespace ? 1 : 0)
|
|
await assert.rejects(run(authority)); assert.equal(commands.length, 2)
|
|
}
|
|
for (const fault of ["lost", "ignored", "collateral", "revoked", "secretRevoked", "downloadFailure", "checkpointFailure", "cleanupLost", "lateSource"]) {
|
|
reset(); mode = fault
|
|
await assert.rejects(run(authority), error => error instanceof McpError)
|
|
assert.equal(commands.length, fault === "lateSource" ? 0 : fault === "cleanupLost" ? 2 : 1, fault); assert.equal(artifacts.size, 0)
|
|
const count: number = commands.length; await assert.rejects(run(authority)); assert.equal(commands.length, count, `${fault}: no replay/fallback/inverse`)
|
|
if (fault === "cleanupLost") assert.equal(downloaded!.every(byte => byte === 0), true)
|
|
}
|
|
for (const fault of ["shortDownload", "postDownloadRevoke"]) {
|
|
reset(); mode = fault
|
|
await assert.rejects(run(authority), error => error instanceof McpError && error.code === "MUTATION_OUTCOME_UNKNOWN")
|
|
assert.equal(downloaded!.every(byte => byte === 0), true, `${fault}: downloaded bytes must be cleared before cleanup begins`)
|
|
assert.equal(commands.length, 1); assert.equal(artifacts.size, 0)
|
|
}
|
|
reset(); mode = "lateDownload"
|
|
const downloading = new Promise<void>(resolve => { downloadStarted = resolve })
|
|
const cancelDownload = new AbortController()
|
|
const lateRun = run(authority, { signal: cancelDownload.signal })
|
|
await downloading
|
|
cancelDownload.abort()
|
|
await assert.rejects(lateRun, error => error instanceof McpError && error.code === "MUTATION_OUTCOME_UNKNOWN")
|
|
releaseDownload!()
|
|
await new Promise<void>(resolve => setImmediate(resolve))
|
|
assert.equal(downloaded!.every(byte => byte === 0), true, "buffer arriving after outer finally is also cleared")
|
|
assert.equal(commands.length, 1); assert.equal(artifacts.size, 0)
|
|
for (const fault of ["missingPostFence", "duplicatePostFence", "missingDeleteFence", "duplicateDeleteFence"]) {
|
|
reset(); mode = fault; await assert.rejects(run(authority), error => error instanceof McpError && error.code === "VERIFICATION_FAILED")
|
|
assert.equal(commands.length, fault.endsWith("PostFence") ? 0 : 1); assert.equal(artifacts.size, 0)
|
|
const count: number = commands.length; await assert.rejects(run(authority)); assert.equal(commands.length, count)
|
|
}
|
|
for (const fault of ["parallelPostFence", "parallelDeleteFence"]) {
|
|
reset(); mode = fault; await assert.rejects(run(authority), error => error instanceof McpError && error.code === "VERIFICATION_FAILED")
|
|
assert.equal(commands.length, fault === "parallelPostFence" ? 0 : 1); assert.equal(typeof releaseDelayedFence, "function")
|
|
releaseDelayedFence!(); await new Promise<void>(resolve => setImmediate(resolve))
|
|
assert.equal(commands.length, fault === "parallelPostFence" ? 0 : 1, "first callback must not send after parallel duplicate already failed"); assert.equal(artifacts.size, 0)
|
|
}
|
|
for (const fault of ["deadlineRead", "deadlineAfterAck", "deadlinePublish"]) {
|
|
reset(); mode = fault; await assert.rejects(run(authority, { timeoutMs: 100 }), error => error instanceof McpError && error.code === (fault === "deadlineRead" ? "READ_CANCELLED" : "MUTATION_OUTCOME_UNKNOWN"))
|
|
assert.equal(commands.length, fault === "deadlineRead" ? 0 : fault === "deadlineAfterAck" ? 1 : 2); assert.equal(artifacts.size, 0)
|
|
}
|
|
reset(); const aborted = new AbortController(); aborted.abort(); await assert.rejects(run(authority, { signal: aborted.signal })); assert.equal(commands.length, 0)
|
|
reset(); state.catalogs["/file"].push({ ".id": "*old", name: clientPlan.filename, size: "9" }); await assert.rejects(run({ ...authority, expectedProof: await proof(state) })); assert.equal(commands.length, 0)
|
|
reset(); await assert.rejects(exportIpsecExistingCertificateGuarded(authority, deps.publish), error => error instanceof McpError && error.code === "PERMISSION_DENIED"); assert.equal(commands.length, 0)
|
|
const receipt = ipsecExistingCertificateExportArtifactReceipt({ id: randomUUID() }, { bytes: 100, sha256: "a".repeat(64) }); assert.equal(receipt.humanDownloadOnly, true); assert.equal(receipt.ipsecContentReturned, false)
|
|
const scope = { version: 1, kind: "ipsec-existing-certificate-bundle", authority, afterProof: authority.expectedProof, bytes: 100, sha256: "a".repeat(64), encryptedSha256: "b".repeat(64), proof: "c".repeat(64) }
|
|
assert.equal(ipsecExistingCertificateExportArtifactScopeSchema.safeParse(scope).success, true); assert.equal(ipsecExistingCertificateExportArtifactScopeSchema.safeParse({ ...scope, kind: "ipsec-user-bundle" }).success, false)
|
|
await assert.rejects(createIpsecExistingCertificateExportArtifact(authority, { user: "synthetic", filename: "synthetic.p12", contentB64: "synthetic", mime: "application/x-pkcs12" }, authority.expectedProof, async () => {}))
|
|
await assert.rejects(verifyIpsecExistingCertificateExportArtifact(randomUUID(), authority, authority.expectedProof))
|
|
await assert.rejects(humanIpsecExistingCertificateExportMetadata(randomUUID(), {} as AuthUser))
|
|
await assert.rejects(readHumanIpsecExistingCertificateExportArtifact(randomUUID(), {} as AuthUser))
|
|
assert.equal(IPSEC_EXISTING_CERTIFICATE_EXPORT_ACTIVATED, true)
|
|
assert.equal(IpsecExistingCertificateExportExecutionError.prototype instanceof McpError, true)
|
|
console.log("Synthetic existing-IPsec export foundations: both REST selectors/all certificate roles incl explicit CA, exact receipt-owned file/read/cleanup, one attempt, passphrase references/generation, opaque conservation, source/owner/secret revoke, no replay/fallback/inverses, encrypted synthetic human bundle; real SQL/network/PKI forbidden")
|
|
} finally { pool.query = oldQuery; pool.connect = oldConnect }
|
|
|
|
|