Files
MikrotikManager/backend/src/services/bandwidth-operator-metadata.sql.test.ts
T

165 lines
11 KiB
TypeScript

import { MIGRATION_MANIFEST } from "../db/migration-manifest.js"
/** Exclusive disposable PG + localhost license. Q is a synthetic fixture. */
import assert from "node:assert/strict"
import { generateKeyPairSync, createHash, randomUUID, sign } from "node:crypto"
import { readFile, unlink, writeFile } from "node:fs/promises"
import { resolve } from "node:path"
import { assertOwnedBandwidthSql } from "./bandwidth-admission-process.sql-helper.js"
import type { BandwidthPeerSourceSnapshot } from "./bandwidth-peer-observation.js"
async function main() {
assertOwnedBandwidthSql()
assert.equal(process.env.MMAPP_OWN_OPERATOR_PEER_METADATA, "true")
const { createOwnedExternalRegistryHarness } = await import("./bandwidth-external-node-registry.sql-helper.js")
const { createBandwidthOperatorEnrollmentPrerequisite, bandwidthOperatorEnrollmentGrantSchema } = await import("./bandwidth-operator-enrollment.js")
const { createManagedBandwidthPeerMetadataChecker } = await import("./bandwidth-peer-metadata-source.js")
const { canonicalBandwidthNodeValue: canonical } = await import("./bandwidth-node-bootstrap.js")
const { pool } = await import("../db/index.js")
const fixture = await createOwnedExternalRegistryHarness()
let coordinator: ReturnType<typeof createBandwidthOperatorEnrollmentPrerequisite> | undefined
let serverId: number | undefined
const checks: string[] = []
try {
const claims = { "system-id": "OWNED-OPERATOR-METADATA", "software-id": "OWNED-PUBLIC-METADATA" }
serverId = await fixture.managedEndpoint(claims)
const peer = Object.freeze({ kind: "server" as const, serverId })
const originalRow = (await fixture.applicationRows([serverId]))[0]
assert(originalRow)
const endpoint = {
host: String(originalRow.host), port: Number(originalRow.port), useSsl: originalRow.use_ssl as boolean,
verifySsl: originalRow.verify_ssl as boolean, username: String(originalRow.username), password: String(originalRow.password),
routingEndpointEpoch: String(originalRow.routing_endpoint_epoch),
}
const sourceProof = "d".repeat(64), authorityGeneration = "owned-operator-metadata-fixture"
const keys = generateKeyPairSync("ed25519"), now = Date.now()
let grant = bandwidthOperatorEnrollmentGrantSchema.parse({
format: "mmapp-bandwidth-operator-enrollment-v1", ...fixture.root, grantId: randomUUID(), operatorId: "owned-metadata-operator",
executorInventorySha256: "c".repeat(64), executorsStoppedAt: now - 1000, issuedAt: now, expiresAt: now + 120000,
peerRef: peer, sourceProof, authorityGeneration, routingEndpointEpoch: endpoint.routingEndpointEpoch,
claims: Object.entries(claims).map(([kind, value]) => ({ kind, value })),
})
const state = resolve(process.env.MCP_STATE_DIR!), trustKeyFile = resolve(state, "operator-metadata-trust.pem"), grantFile = resolve(state, "operator-metadata-grant.json")
const grantBytes = () => {
const bytes = Buffer.from(canonical(grant))
return JSON.stringify({ format: "mmapp-bandwidth-operator-enrollment-envelope-v1", payload: bytes.toString("base64url"), signature: sign(null, bytes, keys.privateKey).toString("base64url") })
}
await writeFile(trustKeyFile, keys.publicKey.export({ type: "spki", format: "pem" }), { flag: "wx", mode: 0o600 })
await writeFile(grantFile, grantBytes(), { flag: "wx", mode: 0o600 })
const checker = createManagedBandwidthPeerMetadataChecker()
let projections = 0, metadataChecks = 0, qChecks = 0, metadataPhase = false
const quiescence = { async verify(current: unknown) { qChecks++; assert(!metadataPhase, "metadata must not assert Q"); assert.deepEqual(current, grant) } }
coordinator = createBandwidthOperatorEnrollmentPrerequisite({
trustKeyFile, grantFile, trustKeySha256: createHash("sha256").update(keys.publicKey.export({ type: "spki", format: "der" })).digest("hex"), ...fixture.root,
}, {
async read(requested, scope): Promise<BandwidthPeerSourceSnapshot> {
projections++; assert(!metadataPhase, "metadata must not reproject credentials"); assert.deepEqual(requested, peer)
await quiescence.verify(grant); scope.signal?.throwIfAborted()
const row = (await fixture.applicationRows([serverId!]))[0]; assert(row)
return { peerRef: peer, enabled: row.enabled as boolean, sourceProof, authorityGeneration,
endpoint: { host: String(row.host), port: Number(row.port), useSsl: row.use_ssl as boolean, verifySsl: row.verify_ssl as boolean,
username: String(row.username), password: String(row.password), routingEndpointEpoch: String(row.routing_endpoint_epoch) } }
},
async assertMetadataCurrent(expected, scope) { metadataChecks++; await checker.assertMetadataCurrent(expected, scope) },
}, quiescence)
console.log("Owned operator metadata stage:", "genuine-license-acquire")
const scope = () => ({ deadlineAt: Date.now() + 4500 })
let prerequisite = await coordinator.acquire(peer, scope())
assert(fixture.nativeGets() > 0); assert(projections > 0); assert(qChecks > 0)
metadataPhase = true
const inspect = async (capability: unknown = prerequisite) => {
const before = { projections, qChecks, gets: fixture.nativeGets(), posts: fixture.nativePosts() }
try { return await coordinator!.inspectMetadata(capability, scope()) }
finally {
assert.equal(projections, before.projections); assert.equal(qChecks, before.qChecks)
assert.equal(fixture.nativeGets(), before.gets); assert.equal(fixture.nativePosts(), before.posts)
}
}
const freshOrigin = async () => {
// The real endpoint trigger advances epoch on every edit, including an
// edit restoring old values. A fresh grant is required; never bypass it.
metadataPhase = false
const row = (await fixture.applicationRows([serverId!]))[0]
grant = bandwidthOperatorEnrollmentGrantSchema.parse({ ...grant, grantId: randomUUID(), routingEndpointEpoch: String(row.routing_endpoint_epoch) })
await writeFile(grantFile, grantBytes())
prerequisite = await coordinator!.acquire(peer, scope())
metadataPhase = true
}
console.log("Owned operator metadata stage:", "current-managed-metadata")
const first = await inspect()
assert.equal(first.format, "mmapp-bandwidth-operator-enrollment-metadata-v1")
assert.deepEqual(first.metadata.evidence.peerRef, peer)
assert.deepEqual(first.metadata.evidence.claims, grant.claims)
assert(Object.isFrozen(first) && Object.isFrozen(first.metadata))
const encoded = JSON.stringify(first)
assert(!encoded.includes(endpoint.password) && !encoded.includes(endpoint.username))
assert(!("writerBarrierVerified" in first) && !("quiescenceVerified" in first))
assert.deepEqual(await inspect(), first)
assert.equal(metadataChecks, 2)
checks.push("genuine signed operator/license origin plus actual fixed SQL current endpoint predicate, public metadata only; no Q/native/credential re-projection")
console.log("Owned operator metadata stage:", "private-predicate-with-unchanged-epoch")
const wrongEndpoints = [
{ ...endpoint, password: "owned-wrong-private-predicate" },
{ ...endpoint, username: "owned-wrong-user-predicate" },
{ ...endpoint, host: "127.0.0.2" },
{ ...endpoint, port: endpoint.port === 1 ? 2 : 1 },
{ ...endpoint, useSsl: !endpoint.useSsl },
{ ...endpoint, verifySsl: !endpoint.verifySsl },
]
for (const wrong of wrongEndpoints) {
assert.equal(wrong.routingEndpointEpoch, endpoint.routingEndpointEpoch)
await assert.rejects(checker.assertMetadataCurrent({ peerRef: peer, enabled: true, sourceProof, authorityGeneration, endpoint: wrong }, scope()))
}
assert.equal(String((await fixture.applicationRows([serverId]))[0].routing_endpoint_epoch), endpoint.routingEndpointEpoch)
checks.push("actual SQL rejects wrong private password/username/host/port/TLS predicates while the real row and endpoint epoch remain unchanged; epoch alone is insufficient")
console.log("Owned operator metadata stage:", "endpoint-field-drift")
const faults = [
{ sql: "UPDATE public.servers SET password=$2 WHERE id=$1", next: "owned-changed-password-only", previous: endpoint.password },
{ sql: "UPDATE public.servers SET username=$2 WHERE id=$1", next: "owned-changed-username", previous: endpoint.username },
{ sql: "UPDATE public.servers SET host=$2 WHERE id=$1", next: "127.0.0.2", previous: endpoint.host },
{ sql: "UPDATE public.servers SET port=$2 WHERE id=$1", next: endpoint.port === 1 ? 2 : 1, previous: endpoint.port },
{ sql: "UPDATE public.servers SET use_ssl=$2 WHERE id=$1", next: !endpoint.useSsl, previous: endpoint.useSsl },
{ sql: "UPDATE public.servers SET verify_ssl=$2 WHERE id=$1", next: !endpoint.verifySsl, previous: endpoint.verifySsl },
{ sql: "UPDATE public.servers SET enabled=$2 WHERE id=$1", next: false, previous: true },
]
for (const fault of faults) {
await freshOrigin()
try {
assert.equal((await pool.query(fault.sql, [serverId, fault.next])).rowCount, 1)
assert.notEqual(String((await fixture.applicationRows([serverId]))[0].routing_endpoint_epoch), grant.routingEndpointEpoch)
await assert.rejects(inspect())
}
finally { await pool.query(fault.sql, [serverId, fault.previous]) }
await assert.rejects(inspect())
}
await freshOrigin(); await inspect()
checks.push("actual password, username, host, port, TLS, verification and enabled drift refuse; real trigger advances endpoint epoch and restored values never revive the old origin; no trigger bypass")
console.log("Owned operator metadata stage:", "grant-and-private-origin")
const beforeInvalid = metadataChecks, savedGrant = await readFile(grantFile)
try { await unlink(grantFile); await assert.rejects(inspect()) }
finally { await writeFile(grantFile, savedGrant) }
await assert.rejects(inspect(JSON.parse(JSON.stringify(prerequisite))))
assert.equal(metadataChecks, beforeInvalid)
checks.push("deleted current signed grant and serialized prerequisite refuse before metadata SQL; exact grant bytes restored")
const restored = (await fixture.applicationRows([serverId]))[0]
const { routing_endpoint_epoch: oldEpoch, ...originalFields } = originalRow
const { routing_endpoint_epoch: newEpoch, ...restoredFields } = restored
assert.deepEqual(restoredFields, originalFields); assert.notEqual(newEpoch, oldEpoch)
assert.equal(Number((await pool.query("SELECT count(*) AS n FROM public.schema_migrations")).rows[0].n), MIGRATION_MANIFEST.length)
console.log("Owned operator peer metadata accepted:", JSON.stringify({
groups: checks.length, checks, actualSql: true, genuineLocalhostLicenseAcquire: true,
coordinatorMetadataChecks: metadataChecks, unchangedEpochPredicateRejections: wrongEndpoints.length,
metadataCredentialProjections: 0, metadataQChecks: 0, metadataNativeCalls: 0,
externalMetadataAccepted: false, operatorWindowAccepted: false, productionWired: false,
}))
} finally {
coordinator?.close()
if (serverId !== undefined) await pool.query("DELETE FROM public.servers WHERE id=$1", [serverId])
await fixture.close()
}
}
void main().catch(() => { console.error("Owned operator peer metadata acceptance failed; no real CHR/Docker actions"); process.exitCode = 1 })