165 lines
11 KiB
TypeScript
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 })
|