Files
MikrotikManager/backend/src/services/bandwidth-operator-peer-source-guard.test.ts
T

185 lines
16 KiB
TypeScript

/** Genuine signed original reader/window/guard. SQL session ownership and Q
* are explicit inert fixture models, NOT actual PostgreSQL/Docker enforcement. */
import assert from "node:assert/strict"
import { createHash, generateKeyPairSync, randomUUID, sign } from "node:crypto"
import { lstat, mkdir, mkdtemp, realpath, rm, writeFile } from "node:fs/promises"
import { tmpdir } from "node:os"
import { basename, dirname, join } from "node:path"
import { test } from "node:test"
import { setTimeout as delay } from "node:timers/promises"
import { bandwidthOperatorEnrollmentGrantSchema } from "./bandwidth-operator-enrollment.js"
import { canonicalBandwidthNodeValue } from "./bandwidth-node-bootstrap.js"
import { assertBandwidthOperatorPeerSourceGuard, createBandwidthOperatorExternalFencer, createBandwidthOperatorOriginalAuthorityReader,
createBandwidthOperatorWriterWindows, type BandwidthOperatorPeerSourceBinding, type BandwidthOperatorPeerSourceGuard,
type BandwidthOperatorRegistryBorrow, type BandwidthOperatorScope } from "./bandwidth-operator-writer-window.js"
const scope = (ms = 4000, signal?: AbortSignal) => ({ deadlineAt: Date.now() + ms, ...(signal ? { signal } : {}) })
test("genuine operator peer source guard binds original held window", async t => {
const root = await realpath(tmpdir()), folder = await mkdtemp(join(root, "bw-peer-source-guard-")), cleanup: Array<() => void> = []
let ordinal = 0, lifetimeGetters = 0
async function fixture(ttl = 4000, lifetimeMode: "normal" | "missing" | "hostile" | "accessor" | "proxy" | "aborted" = "normal") {
const directory = join(folder, String(++ordinal)); await mkdir(directory)
const keys = generateKeyPairSync("ed25519"), trustKeyFile = join(directory, "operator.pub"), grantFile = join(directory, "grant.json")
await writeFile(trustKeyFile, keys.publicKey.export({ type: "spki", format: "pem" }))
const rootFields = { installationId: randomUUID(), issuerKeySha256: "a".repeat(64), quiescenceProof: "b".repeat(64) }
const grant = bandwidthOperatorEnrollmentGrantSchema.parse({ format: "mmapp-bandwidth-operator-enrollment-v1", ...rootFields, grantId: randomUUID(), operatorId: "synthetic-peer-guard",
executorInventorySha256: "c".repeat(64), executorsStoppedAt: Date.now() - 2000, issuedAt: Date.now() - 1000, expiresAt: Date.now() + 60000,
peerRef: { kind: "external", enrollmentId: randomUUID() }, sourceProof: "d".repeat(64), authorityGeneration: "synthetic-original-source", routingEndpointEpoch: randomUUID(),
claims: [{ kind: "system-id", value: "SYNTHETIC-PEER-GUARD" }] })
const publish = async (value = grant) => { const payload = Buffer.from(canonicalBandwidthNodeValue(value)); await writeFile(grantFile, JSON.stringify({
format: "mmapp-bandwidth-operator-enrollment-envelope-v1", payload: payload.toString("base64url"), signature: sign(null, payload, keys.privateKey).toString("base64url") })) }
await publish()
const originals = createBandwidthOperatorOriginalAuthorityReader({ ...rootFields, trustKeyFile, grantFile,
trustKeySha256: createHash("sha256").update(keys.publicKey.export({ type: "spki", format: "der" })).digest("hex") })
let q = 0, queries = 0, heldQueries = 0, opens = 0, destroys = 0, externalCloses = 0, secrets = 0, held = false, pid = 777, qAllowed = true, physicalClosed = false, closing = false
const leaseLifetime = new AbortController()
if (lifetimeMode === "hostile") Object.defineProperties(leaseLifetime.signal, {
aborted: { get() { lifetimeGetters++; throw Error("No own getter") } },
addEventListener: { value() { lifetimeGetters++; throw Error("No own method") } },
removeEventListener: { value() { lifetimeGetters++; throw Error("No own method") } },
})
if (lifetimeMode === "aborted") leaseLifetime.abort()
let heldHook: (() => Promise<void>) | undefined, qHook: (() => Promise<void>) | undefined
let registerHook: ((borrowed: BandwidthOperatorRegistryBorrow, requested: BandwidthOperatorScope) => Promise<void>) | undefined
const caller = new AbortController(), originalScope = scope(ttl, caller.signal), authority = await originals.acquire(originalScope)
const external = createBandwidthOperatorExternalFencer({ async acquire() { return {
async assertCurrent() { q++; await qHook?.(); if (!qAllowed) throw Error("synthetic Q revoked") }, close() { externalCloses++ },
} } })
const windows = createBandwidthOperatorWriterWindows({ originals, external, source: {
async open(_requested, guard) {
opens++; await guard()
const connection = {
release() { throw Error("Owner-only physical close") }, async query(text: string) {
assert(!physicalClosed); await guard(); queries++
if (text.includes("pg_try_advisory_lock")) { held = true; return { rows: [{ acquired: true }] } }
if (text.includes("pg_locks")) { heldQueries++; await heldHook?.(); return { rows: [{ held, backend_pid: pid }] } }
if (text.includes("pg_backend_pid()")) return { rows: [{ backend_pid: pid }] }
if (["BEGIN", "COMMIT"].includes(text)) return { rows: [], command: text }
throw Error("Unexpected fixed fixture SQL")
},
}
if (lifetimeMode !== "missing") Object.defineProperty(connection, "lifetimeSignal", lifetimeMode === "accessor"
? { enumerable: true, get() { lifetimeGetters++; return leaseLifetime.signal } }
: { enumerable: true, value: lifetimeMode === "proxy" ? new Proxy(leaseLifetime.signal, { getPrototypeOf() { lifetimeGetters++; throw Error("No proxy trap") } }) : leaseLifetime.signal })
return { async binding() { await guard(); return rootFields }, async keyedProof() { secrets++; throw Error("No secret MAC permitted") },
close() { if (!closing) { closing = true; leaseLifetime.abort(); physicalClosed = true; held = false; destroys++ } }, connection }
},
}, registry: { async register(_original, borrowed, requested) { await registerHook?.(borrowed, requested); await borrowed.connection.query("BEGIN");
await borrowed.connection.query("COMMIT"); borrowed.connection.release(true); return "synthetic-registry-complete" } } })
cleanup.push(() => { windows.close(); originals.close() })
const window = await windows.open(authority, originalScope)
const binding: BandwidthOperatorPeerSourceBinding = { peerRef: grant.peerRef, sourceProof: grant.sourceProof, authorityGeneration: grant.authorityGeneration, routingEndpointEpoch: grant.routingEndpointEpoch }
return { windows, originals, authority, window, binding, grant, publish, caller,
guard: () => windows.createPeerSourceGuard(window, authority), reset() { q = queries = heldQueries = 0 },
counts: () => ({ q, queries, heldQueries, opens, destroys, externalCloses, secrets }),
loseLock() { held = false }, loseOwner() { leaseLifetime.abort() }, changePid() { pid++ }, revokeQ() { qAllowed = false }, heldHook(value: typeof heldHook) { heldHook = value },
qHook(value: typeof qHook) { qHook = value }, registerHook(value: typeof registerHook) { registerHook = value } }
}
try {
await t.test("brand rejects flags/JSON/copies; genuine read checks actual same fixture lease/PID with Q", async () => {
const f = await fixture(), guard = f.guard(); f.reset()
assertBandwidthOperatorPeerSourceGuard(guard)
assert.equal(guard.installationId, f.grant.installationId)
assert.deepEqual(Object.keys(guard).sort(), ["installationId", "verifyMetadata", "verifyRead"])
const installation = Object.getOwnPropertyDescriptor(guard, "installationId")!
assert.equal(installation.value, f.grant.installationId); assert.equal(installation.writable, false); assert.equal(installation.configurable, false); assert(!installation.get)
for (const fake of [{ verifyRead: async () => {}, verifyMetadata: async () => {} }, { ...guard }, JSON.parse(JSON.stringify(guard)), { ready: true }]) assert.throws(() => assertBandwidthOperatorPeerSourceGuard(fake))
await guard.verifyRead(f.binding, scope()); assert.equal(f.counts().heldQueries, 1); assert(f.counts().q > 0)
assert.equal(f.counts().opens, 1); assert.equal(f.counts().secrets, 0)
})
await t.test("metadata checks signed original only: zero Q/SQL/secret, never a held/Q proof", async () => {
const f = await fixture(), guard = f.guard(); f.reset(); f.revokeQ(); f.loseLock()
await guard.verifyMetadata(f.binding, scope()); assert.equal(f.counts().q + f.counts().queries + f.counts().secrets, 0)
await assert.rejects(guard.verifyRead(f.binding, scope())); assert.equal(f.counts().destroys, 1)
})
await t.test("missing/copied window or foreign original cannot mint a genuine guard", async () => {
const f = await fixture(); f.reset()
assert.throws(() => f.windows.createPeerSourceGuard({}, f.authority)); assert.throws(() => f.windows.createPeerSourceGuard({ ...f.window }, f.authority))
const foreign = await f.originals.acquire(scope())
assert.throws(() => f.windows.createPeerSourceGuard(f.window, foreign)); assert.equal(f.counts().destroys, 1); assert.equal(f.counts().queries, 0)
})
await t.test("tuple drift/proxies/accessors fail before any secret or held SQL and revoke all window guards", async () => {
for (const fault of ["peer", "proof", "generation", "epoch", "accessor", "proxy"] as const) {
const f = await fixture(), guard = f.guard(), other = f.guard(); f.reset(); let getters = 0
let binding = structuredClone(f.binding)
if (fault === "peer") binding = { ...binding, peerRef: { kind: "external", enrollmentId: randomUUID() } }
if (fault === "proof") binding = { ...binding, sourceProof: "9".repeat(64) }
if (fault === "generation") binding = { ...binding, authorityGeneration: "different" }
if (fault === "epoch") binding = { ...binding, routingEndpointEpoch: randomUUID() }
if (fault === "accessor") Object.defineProperty(binding, "sourceProof", { enumerable: true, get() { getters++; return f.binding.sourceProof } })
if (fault === "proxy") binding = new Proxy(binding, { getPrototypeOf() { getters++; throw Error("No proxy trap") } })
await assert.rejects(guard.verifyRead(binding, scope())); assert.equal(getters, 0)
assert.equal(f.counts().q + f.counts().queries + f.counts().secrets, 0); assert.equal(f.counts().destroys, 1)
assert.throws(() => assertBandwidthOperatorPeerSourceGuard(other))
}
})
await t.test("held lock/PID drift and original grant rotation during Q deny the read", async () => {
for (const fault of ["lock", "pid", "grant"] as const) {
const f = await fixture(), guard = f.guard(); f.reset()
if (fault === "lock") f.loseLock()
if (fault === "pid") f.changePid()
if (fault === "grant") { let done = false; f.qHook(async () => { if (!done) { done = true; await f.publish({ ...f.grant, grantId: randomUUID() }) } }) }
await assert.rejects(guard.verifyRead(f.binding, scope())); assert.equal(f.counts().destroys, 1); assert.equal(f.counts().secrets, 0)
if (fault !== "grant") assert.equal(f.counts().heldQueries, 1)
}
})
await t.test("physical owner abort DURING post-HELD Q revokes guard before consumer key callback", async () => {
const f = await fixture(), guard = f.guard(); f.reset(); let keyCallbacks = 0, killed = false
f.qHook(async () => { if (!killed && f.counts().heldQueries > 0) { killed = true; f.loseOwner() } })
const consumer = async () => { await guard.verifyRead(f.binding, scope()); keyCallbacks++ }
await assert.rejects(consumer()); assert(killed); assert.equal(keyCallbacks, 0); assert.equal(f.counts().heldQueries, 1)
assert.throws(() => assertBandwidthOperatorPeerSourceGuard(guard)); assert.equal(f.counts().destroys, 1)
await assert.rejects(guard.verifyMetadata(f.binding, scope()))
})
await t.test("guard requires native lifetime; legacy window without signal still registers; hostile getters never execute", async () => {
const missing = await fixture(4000, "missing"); missing.reset()
assert.throws(() => missing.guard()); assert.equal(missing.counts().destroys, 1); assert.equal(missing.counts().queries, 0)
const legacy = await fixture(4000, "missing")
assert.equal(await legacy.windows.register(legacy.window), "synthetic-registry-complete"); assert.equal(legacy.counts().destroys, 1)
for (const mode of ["accessor", "proxy", "aborted"] as const) await assert.rejects(fixture(4000, mode))
const hostile = await fixture(4000, "hostile"), guard = hostile.guard(); hostile.reset()
await guard.verifyRead(hostile.binding, scope()); hostile.loseOwner()
assert.equal(hostile.counts().destroys, 1); assert.throws(() => assertBandwidthOperatorPeerSourceGuard(guard)); assert.equal(lifetimeGetters, 0)
})
await t.test("idle physical lifetime loss revokes metadata guard without a new SQL/Q check", async () => {
const f = await fixture(), guard = f.guard(); f.reset(); f.loseOwner()
assert.equal(f.counts().destroys, 1); assert.throws(() => assertBandwidthOperatorPeerSourceGuard(guard))
await assert.rejects(guard.verifyMetadata(f.binding, scope())); assert.equal(f.counts().q + f.counts().queries, 0)
})
await t.test("metadata original revocation/close/abort/expiry cannot revive under larger fresh scope", async () => {
for (const fault of ["grant", "close", "abort", "expiry"] as const) {
const f = await fixture(fault === "expiry" ? 700 : 4000), guard = f.guard(); f.reset()
if (fault === "grant") await f.publish({ ...f.grant, grantId: randomUUID() })
if (fault === "close") f.windows.close()
if (fault === "abort") f.caller.abort()
if (fault === "expiry") await delay(750)
await assert.rejects(guard.verifyMetadata(f.binding, scope(60000, new AbortController().signal)))
assert.equal(f.counts().q + f.counts().queries, 0); assert.equal(f.counts().destroys, 1)
}
})
await t.test("guard is usable during registry phase and revoked after logical/final release", async () => {
const f = await fixture(); let retained!: BandwidthOperatorPeerSourceGuard
f.registerHook(async (_borrowed, requested) => { retained = f.guard(); await retained.verifyMetadata(f.binding, requested); await retained.verifyRead(f.binding, requested) })
await f.windows.register(f.window); assert.equal(f.counts().destroys, 1)
assert.throws(() => assertBandwidthOperatorPeerSourceGuard(retained)); await assert.rejects(retained.verifyMetadata(f.binding, scope()))
})
await t.test("requested signal mutation/cancel/short expiry or concurrent guard use destroys blocked lease; late held result cannot publish", async () => {
for (const fault of ["abort", "expiry", "busy"] as const) {
const f = await fixture(), guard = f.guard(); f.reset()
let entered!: () => void, release!: () => void
const started = new Promise<void>(resolve => { entered = resolve }), held = new Promise<void>(resolve => { release = resolve })
f.heldHook(async () => { entered(); await held })
const caller = new AbortController(), input = scope(fault === "expiry" ? 200 : 3000, caller.signal), pending = guard.verifyRead(f.binding, input); void pending.catch(() => {})
await Promise.race([started, pending.then(() => assert.fail("held probe was not reached"))]); input.deadlineAt += 60000; input.signal = new AbortController().signal
if (fault === "abort") caller.abort()
if (fault === "busy") await assert.rejects(guard.verifyMetadata(f.binding, scope()))
await assert.rejects(pending); release(); await delay(0); assert.equal(f.counts().destroys, 1); assert.equal(f.counts().heldQueries, 1); assert.equal(f.counts().secrets, 0)
}
})
} finally {
for (const close of cleanup) close()
const actual = await realpath(folder); assert.equal(dirname(actual), root); assert.match(basename(actual), /^bw-peer-source-guard-/); assert((await lstat(folder)).isDirectory())
await rm(actual, { recursive: true, force: true })
}
})