Files
MikrotikManager/backend/src/services/bandwidth-node-public-registry.test.ts
T

167 lines
14 KiB
TypeScript

/** Actual node wrapper, real Ed25519 bootstrap files, controlled public core
* lease. No actual PG/SQL/catalog/ownership/Q/native acceptance claim. */
import assert from "node:assert/strict"
import { generateKeyPairSync, randomUUID, sign, verify } from "node:crypto"
import { lstat, mkdtemp, readFile, 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 { createConfiguredBandwidthNodeSource } from "./bandwidth-node-source.js"
import type { createConfiguredBandwidthControlSource, BandwidthPublicNodeBootstrapMetadata } from "./bandwidth-control-source.js"
import type { BandwidthScope } from "./bandwidth-admission.js"
import { bandwidthNodeBootstrapEnvelopeSchema, bandwidthNodeBootstrapSchema, canonicalBandwidthNodeValue } from "./bandwidth-node-bootstrap.js"
test("node public registry metadata owns exactly one controlled public lease", async t => {
const root = await realpath(tmpdir()), folder = await mkdtemp(join(root, "bw-node-public-registry-")), keys = generateKeyPairSync("ed25519")
const bootstrapFile = join(folder, "bootstrap.json"), issuerKeyFile = join(folder, "missing-issuer-secret"), eventKeyFile = join(folder, "missing-event-secret")
const issuerKeySha256 = "b".repeat(64), installationId = randomUUID()
const bootstrap = bandwidthNodeBootstrapSchema.parse({ format: "mmapp-bandwidth-node-bootstrap-v2", installationId, issuerKeySha256,
quiescenceProof: "c".repeat(64), registrySchemaSourceSha256: "d".repeat(64), registryCatalogSha256: "e".repeat(64), attestationRef: "controlled public registry fixture only, not Q or native proof" })
const initialSource = { installationId, controlGeneration: randomUUID(), sourceRecordSha256: "f".repeat(64) }
let source = { ...initialSource }, backendPid = 777, catalogSha256 = "a".repeat(64), opens = 0, inspections = 0, closes = 0, forbidden = 0, getters = 0
let onOpen: ((scope: BandwidthScope) => Promise<void>) | undefined, onInspect: ((call: number) => Promise<void>) | undefined, afterInspect: ((call: number) => Promise<void>) | undefined
let resultFault: "accessor" | "nested-accessor" | "proxy" | "extra" | "wrong-bootstrap" | undefined
let leaseFault = false
const scopes: BandwidthScope[] = [], all: Array<ReturnType<typeof createConfiguredBandwidthNodeSource>> = []
const scope = (ms = 2000, signal?: AbortSignal) => ({ deadlineAt: Date.now() + ms, ...(signal ? { signal } : {}) })
const decode = (input: unknown) => {
const envelope = bandwidthNodeBootstrapEnvelopeSchema.parse(input), bytes = Buffer.from(envelope.payload, "base64url")
assert(verify(null, bytes, keys.publicKey, Buffer.from(envelope.signature, "base64url")))
const value = bandwidthNodeBootstrapSchema.parse(JSON.parse(bytes.toString("utf8"))); assert.equal(canonicalBandwidthNodeValue(value), bytes.toString("utf8")); return value
}
const core = {
async connect() { forbidden++; throw Error("No generic/strong source borrow") },
async verifyNodeBootstrap() { forbidden++; throw Error("No strong verifier") },
async inspectPublicNodeBootstrap() { forbidden++; throw Error("No second standalone public verifier/borrow") },
async openPublicRegistryMetadata(envelope: unknown, originalScope: BandwidthScope) {
opens++; scopes.push(originalScope); decode(envelope)
let closed = false
const close = () => { if (!closed) { closed = true; closes++ } }
const lease = {
async inspect(current: unknown) {
assert(!closed); const call = ++inspections; await onInspect?.(call)
const value = decode(current)
const metadata: BandwidthPublicNodeBootstrapMetadata = { format: "mmapp-bandwidth-public-node-metadata-v1", bootstrap: value, source: { ...source },
publicDatabase: { databaseName: "public_fixture", runtimeRole: "public_reader", ownerRole: "public_owner", databaseOid: 1234, catalogSha256 } }
const result: Record<string, unknown> = { format: "mmapp-bandwidth-public-registry-metadata-v1", metadata, backendPid }
if (resultFault === "accessor") Object.defineProperty(result, "metadata", { enumerable: true, get() { getters++; return metadata } })
if (resultFault === "nested-accessor") Object.defineProperty(metadata.source, "sourceRecordSha256", { enumerable: true, get() { getters++; return source.sourceRecordSha256 } })
if (resultFault === "extra") result.query = () => { forbidden++; throw Error("No query leaked") }
if (resultFault === "wrong-bootstrap") metadata.bootstrap = { ...value, quiescenceProof: "9".repeat(64) }
await afterInspect?.(call)
if (resultFault === "proxy") return new Proxy(Object.freeze(result), { getPrototypeOf() { getters++; throw Error("No proxy traps") } }) as never
return Object.freeze(result) as never
}, close,
}
await onOpen?.(originalScope)
if (leaseFault) return Object.freeze({ get inspect() { getters++; return lease.inspect }, close }) as never
return Object.freeze(lease)
},
}
const make = (expected = issuerKeySha256) => {
const value = createConfiguredBandwidthNodeSource(core as unknown as ReturnType<typeof createConfiguredBandwidthControlSource>, { bootstrapFile, issuerKeyFile, issuerKeySha256: expected })
all.push(value); return value
}
const publish = async (value = bootstrap) => {
const payload = Buffer.from(canonicalBandwidthNodeValue(value))
await writeFile(bootstrapFile, JSON.stringify({ format: "mmapp-bandwidth-node-bootstrap-envelope-v1", payload: payload.toString("base64url"), signature: sign(null, payload, keys.privateKey).toString("base64url") }))
}
const reset = async () => { source = { ...initialSource }; backendPid = 777; catalogSha256 = "a".repeat(64); opens = inspections = closes = getters = 0;
onOpen = onInspect = afterInspect = undefined; resultFault = undefined; leaseFault = false; scopes.length = 0; await publish() }
try {
await t.test("constructor inert, missing secrets succeed, repeated inspect keeps one core lease/PID and immutable public output", async () => {
const node = make(); assert.equal(opens + inspections + forbidden, 0)
await assert.rejects(readFile(bootstrapFile), { code: "ENOENT" }); await reset()
const session = await node.openPublicRegistryMetadata(scope(60000))
assert.deepEqual(Object.keys(session).sort(), ["close", "inspect"]); assert.equal(opens, 1); assert.equal(inspections, 2)
const first = await session.inspect(), second = await session.inspect()
assert.deepEqual(first, second); assert.equal(first.backendPid, 777); assert.equal(inspections, 6); assert.equal(opens, 1)
assert(Object.isFrozen(session) && Object.isFrozen(first) && Object.isFrozen(first.metadata) && Object.isFrozen(first.metadata.source))
assert(!("query" in session) && !("keyCurrent" in first) && !("quiescenceVerified" in first)); assert.equal(forbidden, 0)
session.close(); session.close(); assert.equal(closes, 1); await assert.rejects(session.inspect())
await assert.rejects(readFile(issuerKeyFile), { code: "ENOENT" }); await assert.rejects(readFile(eventKeyFile), { code: "ENOENT" })
})
await t.test("current bootstrap/source/PID/public catalog drift retires original session, no second borrow", async () => {
for (const fault of ["bootstrap", "source", "pid", "catalog"] as const) {
await reset(); const node = make(), session = await node.openPublicRegistryMetadata(scope())
if (fault === "bootstrap") await publish({ ...bootstrap, quiescenceProof: "8".repeat(64) })
if (fault === "source") source.sourceRecordSha256 = "7".repeat(64)
if (fault === "pid") backendPid++
if (fault === "catalog") catalogSha256 = "6".repeat(64)
await assert.rejects(session.inspect()); assert.equal(closes, 1); assert.equal(opens, 1); await assert.rejects(session.inspect())
}
})
await t.test("changes during either same-lease round/final file read cannot publish", async () => {
for (const fault of ["source-between", "bootstrap-last", "pid-between"] as const) {
await reset(); const node = make()
afterInspect = async call => {
if (fault === "source-between" && call === 1) source.sourceRecordSha256 = "5".repeat(64)
if (fault === "pid-between" && call === 1) backendPid++
if (fault === "bootstrap-last" && call === 2) await publish({ ...bootstrap, attestationRef: "new signed file appeared during final core SQL round" })
}
await assert.rejects(node.openPublicRegistryMetadata(scope())); assert.equal(opens, 1); assert.equal(closes, 1)
}
})
await t.test("catalog error, malformed/proxy/accessor data, wrong bootstrap/issuer close without evaluating getters", async () => {
for (const fault of ["catalog-error", "accessor", "nested-accessor", "proxy", "extra", "wrong-bootstrap", "issuer", "lease-accessor"] as const) {
await reset(); const node = make(fault === "issuer" ? "9".repeat(64) : issuerKeySha256)
if (fault === "catalog-error") onInspect = async () => { throw Error("actual controlled core catalog refusal") }
else if (fault === "lease-accessor") leaseFault = true
else if (fault !== "issuer") resultFault = fault
await assert.rejects(node.openPublicRegistryMetadata(scope())); assert.equal(opens, fault === "issuer" ? 0 : 1); assert.equal(closes, fault === "issuer" ? 0 : 1); assert.equal(getters, 0)
}
})
await t.test("abort or source.close during core open destroys a late lease before inspect/publication", async () => {
for (const cancel of ["abort", "close"] as const) {
await reset(); const node = make(), caller = new AbortController()
let entered!: () => void, release!: () => void
const started = new Promise<void>(resolve => { entered = resolve }), held = new Promise<void>(resolve => { release = resolve })
onOpen = async () => { entered(); await held }
const pending = node.openPublicRegistryMetadata(scope(2000, caller.signal)); void pending.catch(() => {})
await started; if (cancel === "abort") caller.abort(); else node.close()
await assert.rejects(pending); release(); await delay(0); assert.equal(opens, 1); assert.equal(closes, 1); assert.equal(inspections, 0)
}
})
await t.test("cancel/close/busy pending inspect retires once; late continuation performs no more core IO", async () => {
for (const cancel of ["abort", "close", "busy", "source-close"] as const) {
await reset(); const node = make(), caller = new AbortController(), session = await node.openPublicRegistryMetadata(scope(2000, caller.signal))
let entered!: () => void, release!: () => void
const started = new Promise<void>(resolve => { entered = resolve }), held = new Promise<void>(resolve => { release = resolve })
onInspect = async () => { entered(); await held }
const pending = session.inspect(); void pending.catch(() => {}); await started
if (cancel === "abort") caller.abort(); else if (cancel === "close") session.close(); else if (cancel === "source-close") node.close(); else await assert.rejects(session.inspect())
await assert.rejects(pending); release(); await delay(0); assert.equal(closes, 1); assert.equal(opens, 1); assert.equal(inspections, 3)
await assert.rejects(session.inspect())
}
})
await t.test("hostile scope/signal inputs run no traps; original signal/deadline remain pinned", async () => {
await reset(); const node = make(); let traps = 0
const trap = () => { traps++; throw Error("No caller trap") }
await assert.rejects(node.openPublicRegistryMetadata(new Proxy(scope(), { getPrototypeOf: trap, ownKeys: trap })))
await assert.rejects(node.openPublicRegistryMetadata({ get deadlineAt() { traps++; return Date.now() + 2000 } }))
assert.equal(traps, 0); assert.equal(opens, 0)
const caller = new AbortController()
Object.defineProperties(caller.signal, { aborted: { get: trap }, addEventListener: { value: trap }, removeEventListener: { value: trap } })
const input = scope(60000, caller.signal), began = Date.now(), session = await node.openPublicRegistryMetadata(input)
assert(scopes[0].deadlineAt <= began + 10000); input.deadlineAt += 60000; input.signal = new AbortController().signal
caller.abort(); await assert.rejects(session.inspect()); assert.equal(closes, 1); assert.equal(traps, 0)
})
await t.test("original monotonic expiry and backward wall do not revive a blocked open", async () => {
await reset(); const node = make(), originalNow = Date.now
let entered!: () => void, release!: () => void
const started = new Promise<void>(resolve => { entered = resolve }), held = new Promise<void>(resolve => { release = resolve })
onOpen = async () => { entered(); await held }
const input = scope(30), pending = node.openPublicRegistryMetadata(input); void pending.catch(() => {})
try { await started; input.deadlineAt = originalNow() + 60000; Date.now = () => originalNow() - 60000; await assert.rejects(pending) }
finally { Date.now = originalNow; release(); await delay(0) }
assert.equal(closes, 1); assert.equal(inspections, 0)
})
assert.equal(forbidden, 0)
} finally {
for (const node of all) node.close()
const actual = await realpath(folder); assert.equal(dirname(actual), root); assert.match(basename(actual), /^bw-node-public-registry-/); assert((await lstat(folder)).isDirectory())
await rm(actual, { recursive: true, force: true })
}
})