167 lines
14 KiB
TypeScript
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 })
|
|
}
|
|
})
|