114 lines
11 KiB
TypeScript
114 lines
11 KiB
TypeScript
import assert from "node:assert/strict"
|
|
import { createServer } from "node:http"
|
|
import { once } from "node:events"
|
|
import { randomUUID } from "node:crypto"
|
|
import { setTimeout as delay } from "node:timers/promises"
|
|
import { createBandwidthPeerObservationReader, BandwidthPeerObservationError, type BandwidthPeerSourceSnapshot } from "./bandwidth-peer-observation.js"
|
|
import { parseBandwidthPeerRef, bandwidthPeerRefKey, BandwidthPeerReferenceError, type BandwidthPeerRef } from "./bandwidth-peer-reference.js"
|
|
|
|
const scope = (ms = 4000) => ({ deadlineAt: Date.now() + ms })
|
|
const deferred = () => { let resolve!: () => void; const promise = new Promise<void>(done => { resolve = done }); return { promise, resolve } }
|
|
const denied = (code?: BandwidthPeerObservationError["code"]) => (error: unknown) => error instanceof BandwidthPeerObservationError && (!code || error.code === code)
|
|
const cases: string[] = [], requests: { method?: string; path?: string; authenticated: boolean }[] = []
|
|
const external = Object.freeze({ kind: "external" as const, enrollmentId: randomUUID() }), managed = Object.freeze({ kind: "server" as const, serverId: 71 })
|
|
const username = "PEER_TEST_ONLY_USER", password = "PEER_TEST_ONLY_PASSWORD", auth = "Basic " + Buffer.from(username + ":" + password).toString("base64")
|
|
let payload: unknown = { "system-id": "SYS-PEER", "software-id": "SOFT-PEER" }, status = 200, hold = false
|
|
let onRequest: (() => void) | undefined, onClosed: (() => void) | undefined
|
|
const router = createServer((req, res) => {
|
|
requests.push({ method: req.method, path: req.url, authenticated: req.headers.authorization === auth })
|
|
res.once("close", () => { if (!res.writableEnded) onClosed?.() }); onRequest?.()
|
|
res.writeHead(status, { "content-type": "application/json", ...(status === 302 ? { location: "/never-follow" } : {}) })
|
|
if (hold) res.flushHeaders(); else res.end(JSON.stringify(payload))
|
|
})
|
|
router.listen(0, "127.0.0.1"); await once(router, "listening")
|
|
const address = router.address(); assert(address && typeof address !== "string")
|
|
const initial: BandwidthPeerSourceSnapshot = { peerRef: external, enabled: true, sourceProof: "a".repeat(64), authorityGeneration: "owned-peer-grant",
|
|
endpoint: { host: "127.0.0.1", port: address.port, useSsl: false, verifySsl: true, username, password, routingEndpointEpoch: randomUUID() } }
|
|
let current = structuredClone(initial), reads = 0, readHook: (() => Promise<void> | void) | undefined
|
|
const readers: ReturnType<typeof createBandwidthPeerObservationReader>[] = []
|
|
const make = () => {
|
|
const source = { async read() { reads++; await readHook?.(); return current } }
|
|
const reader = createBandwidthPeerObservationReader(source); readers.push(reader); return { reader, source }
|
|
}
|
|
const reset = (peerRef: BandwidthPeerRef = external) => { current = { ...structuredClone(initial), peerRef }; payload = { "system-id": "SYS-PEER", "software-id": "SOFT-PEER" }; status = 200; hold = false; readHook = undefined; onRequest = undefined; onClosed = undefined }
|
|
const { pool, closePool } = await import("../db/index.js")
|
|
const originalQuery = pool.query, originalConnect = pool.connect
|
|
let databaseCalls = 0
|
|
pool.query = (() => { databaseCalls++; throw Error("Peer fixture cannot query application DB") }) as typeof pool.query
|
|
pool.connect = (() => { databaseCalls++; throw Error("Peer fixture cannot borrow application pool") }) as typeof pool.connect
|
|
try {
|
|
const { reader } = make(); assert.equal(reads, 0); assert.equal(requests.length, 0)
|
|
let evaluated = 0
|
|
const hostile = { kind: "external", get enrollmentId() { evaluated++; return external.enrollmentId } }
|
|
for (const invalid of [hostile, null, [], { ...external, serverId: 1 }, { kind: "server", serverId: 0 }, { kind: "server", serverId: Number.MAX_SAFE_INTEGER + 1 }, { kind: "external", enrollmentId: external.enrollmentId.toUpperCase() }, Object.create(external)]) {
|
|
assert.throws(() => parseBandwidthPeerRef(invalid), BandwidthPeerReferenceError)
|
|
await assert.rejects(reader.observe(invalid as BandwidthPeerRef, scope()))
|
|
}
|
|
assert.equal(evaluated, 0); assert.equal(reads, 0); assert.equal(requests.length, 0)
|
|
assert.notEqual(bandwidthPeerRefKey(managed), bandwidthPeerRefKey(external))
|
|
cases.push("tagged managed/external references are distinct; hostile getter, inherited, mixed, unsafe and noncanonical refs refuse before source or transport")
|
|
|
|
const token = await reader.observe(external, scope()), evidence = await reader.inspect(token, scope())
|
|
assert.equal(evidence.version, 2); assert.deepEqual(evidence.peerRef, external); assert.equal(Object.hasOwn(evidence, "serverId"), false)
|
|
assert.deepEqual(evidence.claims, [{ kind: "system-id", value: "SYS-PEER" }, { kind: "software-id", value: "SOFT-PEER" }])
|
|
assert.equal(evidence.physicalUniquenessVerified, false); assert.equal(evidence.cloneResistanceVerified, false)
|
|
assert.equal(requests.length, 1); assert(!JSON.stringify(evidence).includes(password)); assert(!JSON.stringify(evidence).includes(username))
|
|
reset(managed); const managedToken = await reader.observe(managed, scope()), managedEvidence = await reader.inspect(managedToken, scope())
|
|
assert.deepEqual(managedEvidence.claims, evidence.claims); assert.deepEqual(managedEvidence.peerRef, managed)
|
|
cases.push("real authenticated fixed license GET for external and managed refs preserves equal typed claims without inventing an application ID, canonical node, wire proof or physical uniqueness")
|
|
|
|
const beforeFake = reads
|
|
for (const fake of [{ ...token }, JSON.parse(JSON.stringify(token)), evidence, { kind: "routeros-license-observation" }]) await assert.rejects(reader.inspect(fake, scope()), denied("NOT_GENUINE"))
|
|
await assert.rejects(make().reader.inspect(token, scope()), denied("NOT_GENUINE"))
|
|
assert.equal(reads, beforeFake); assert(Object.isFrozen(evidence.peerRef)); assert(Object.isFrozen(evidence.claims[0]))
|
|
cases.push("copied/evidence/v1-looking and foreign-reader tokens never acquire provenance or perform source reads; exported metadata frozen and credentials absent")
|
|
|
|
reset(); const externalToken = await reader.observe(external, scope()), countBeforeClient = requests.length
|
|
await assert.rejects(reader.strictClient(externalToken, scope()), denied("INVALID_INPUT")); assert.equal(requests.length, countBeforeClient)
|
|
reset(managed); const sourceToken = await reader.observe(managed, scope()), client = await reader.strictClient(sourceToken, scope())
|
|
await assert.rejects(client.post("/tool/bandwidth-test", { address: "192.0.2.9", duration: "3s" })); assert.equal(requests.length, countBeforeClient + 1)
|
|
cases.push("external destination identity does not issue source execution authority; genuine managed source client requires strict native permit before any POST")
|
|
|
|
for (const change of [() => { current.endpoint.password = "CHANGED" }, () => { current.endpoint.routingEndpointEpoch = randomUUID() }, () => { current.peerRef = managed }, () => { current.sourceProof = "b".repeat(64) }, () => { current.enabled = false }]) {
|
|
reset(); onRequest = change; await assert.rejects(reader.observe(external, scope()), denied())
|
|
}
|
|
reset(); const prior = requests.length, baseReads = reads
|
|
readHook = () => { if (reads === baseReads + 2) current.endpoint.password = "CHANGED_BEFORE_SEND" }
|
|
await assert.rejects(reader.observe(external, scope()), denied("SOURCE_CHANGED")); assert.equal(requests.length, prior)
|
|
reset(); readHook = () => { throw Error("PRIVATE_SOURCE_DENIED") }
|
|
const sourceError = await reader.observe(external, scope()).then(() => assert.fail("Expected denied source"), error => error as Error)
|
|
assert(!sourceError.message.includes("PRIVATE_SOURCE_DENIED")); assert.equal(requests.length, prior)
|
|
cases.push("credential/epoch/ref/proof/enabled drift during HTTP prevents publication; pre-send drift and revoked source make zero requests and never reflect private errors")
|
|
|
|
for (const invalid of [[], [{ "system-id": "A" }, { "system-id": "B" }], {}, { "system-id": null, "software-id": "VALID" }, { "software-id": " A" }, { "system-id": "x".repeat(20000) }]) {
|
|
reset(); payload = invalid; await assert.rejects(reader.observe(external, scope()), denied())
|
|
}
|
|
for (const badStatus of [302, 401, 500]) { reset(); status = badStatus; payload = { message: password }; const before: number = requests.length; const error = await reader.observe(external, scope()).then(() => assert.fail(), error => error as Error); assert(!error.message.includes(password)); assert.equal(requests.length, before + 1) }
|
|
reset(); payload = [{ "system-id": "SAME", "software-id": "SAME" }]
|
|
const equal = await reader.inspect(await reader.observe(external, scope()), scope()); assert.deepEqual(equal.claims.map(claim => claim.kind), ["system-id", "software-id"])
|
|
cases.push("typed claim kinds survive equal values; invalid/ambiguous/oversized responses and auth/errors/redirects refuse without a fallback identity, reflected credentials or redirect follow")
|
|
|
|
reset(); const pending = deferred(), started = deferred(), closed = deferred(); hold = true
|
|
onRequest = started.resolve; onClosed = closed.resolve
|
|
const controller = new AbortController(), cancelled = assert.rejects(reader.observe(external, { deadlineAt: Date.now() + 1000, signal: controller.signal }), denied("CANCELLED"))
|
|
await Promise.race([started.promise, delay(2000).then(() => assert.fail("Native request did not start"))]); controller.abort(); await cancelled
|
|
await Promise.race([closed.promise, delay(2000).then(() => assert.fail("Cancelled socket remained open"))])
|
|
reset(); const preStall = requests.length; readHook = () => pending.promise
|
|
await assert.rejects(reader.observe(external, scope(30)), denied("CANCELLED")); pending.resolve(); await delay(30); assert.equal(requests.length, preStall)
|
|
cases.push("real HTTP cancellation closes owned socket; stalled source expiry cannot dispatch a late GET")
|
|
|
|
reset(); const expiry = await reader.observe(external, scope(80)), expiryReads = reads
|
|
await delay(100); await assert.rejects(reader.inspect(expiry, scope()), denied("CANCELLED")); assert.equal(reads, expiryReads)
|
|
const abort = new AbortController(), inherited = await reader.observe(external, { deadlineAt: Date.now() + 4000, signal: abort.signal }); abort.abort()
|
|
await assert.rejects(reader.inspect(inherited, scope()), denied("CANCELLED"))
|
|
reset(); const closing = make().reader; closing.close(); await assert.rejects(closing.observe(external, scope()), denied("CLOSED")); await assert.rejects(closing.inspect(token, scope()), denied("CLOSED"))
|
|
cases.push("original observation expiry/abort cannot be renewed by a fresh scope; closed readers never adopt old tokens")
|
|
|
|
assert.equal(databaseCalls, 0); assert(requests.every(req => req.method === "GET" && req.path === "/rest/system/license" && req.authenticated))
|
|
console.log("Bandwidth peer native observation:", JSON.stringify({ cases: cases.length, checks: cases, actualLocalhostGets: requests.length, defaultDatabaseCalls: databaseCalls, actualPeerKinds: ["server", "external"], canonicalNodesCreated: 0, wirePeerMappingVerified: false, productionWired: false, realChrCalls: 0 }))
|
|
} finally {
|
|
for (const reader of readers) reader.close()
|
|
pool.query = originalQuery; pool.connect = originalConnect
|
|
router.closeAllConnections(); await new Promise<void>(resolve => router.close(() => resolve())); await closePool()
|
|
}
|