150 lines
13 KiB
TypeScript
150 lines
13 KiB
TypeScript
/** Read-only v2 participant verification on the caller's EXISTING core fence.
|
|
* No lease acquisition, registration, native transport or runtime activation. */
|
|
import { createHash, createHmac } from "node:crypto"
|
|
import { performance } from "node:perf_hooks"
|
|
import { z } from "zod"
|
|
import { readBandwidthControlFile, type BandwidthControlDispatchFence } from "./bandwidth-control-source.js"
|
|
import { canonicalBandwidthNodeValue } from "./bandwidth-node-bootstrap.js"
|
|
import { bandwidthNodeBindingSchema, type BandwidthNodeBinding } from "./bandwidth-node-fence.js"
|
|
import { parseBandwidthPeerRef, bandwidthPeerRefKey, type BandwidthPeerRef } from "./bandwidth-peer-reference.js"
|
|
import type { BandwidthNodeSourceConfig } from "./bandwidth-node-source.js"
|
|
import type { BandwidthPeerObservationEvidence } from "./bandwidth-peer-observation.js"
|
|
import type { BandwidthScope } from "./bandwidth-admission.js"
|
|
|
|
export interface BandwidthPeerRegistryReceipt {
|
|
readonly peerRef: BandwidthPeerRef; readonly canonicalNodeId: string; readonly incarnation: string
|
|
readonly status: "active" | "tombstoned" | "quarantined"; readonly outcome: "new" | "existing"
|
|
}
|
|
export interface BandwidthResolvedPeerFence {
|
|
readonly binding: Readonly<BandwidthNodeBinding>
|
|
readonly participants: readonly { evidence: Readonly<BandwidthPeerObservationEvidence>; receipt: Readonly<BandwidthPeerRegistryReceipt> }[]
|
|
}
|
|
export class BandwidthPeerFenceError extends Error {
|
|
readonly code = "BANDWIDTH_PEER_FENCE_REFUSED"
|
|
constructor() { super("Актуальная постоянная привязка bandwidth peers не подтверждена") }
|
|
}
|
|
function fail(): never { throw new BandwidthPeerFenceError() }
|
|
const hash = z.string().regex(/^[a-f0-9]{64}$/), uuid = z.string().uuid()
|
|
const peer = z.unknown().transform(value => parseBandwidthPeerRef(value))
|
|
const claim = z.object({ kind: z.enum(["system-id", "software-id"]), value: z.string().min(1).refine(value => Buffer.byteLength(value) <= 256 && value.trim() === value && !/[\u0000-\u001f\u007f]/.test(value)) }).strict()
|
|
const evidenceSchema = z.object({ version: z.literal(2), peerRef: peer, sourceProof: hash, authorityGeneration: z.string().min(1).max(200),
|
|
routingEndpointEpoch: uuid, observedAt: z.number().int().nonnegative().safe(), expiresAt: z.number().int().positive().safe(),
|
|
claims: z.array(claim).min(1).max(2).refine(value => value.length === 1 || value[0].kind === "system-id" && value[1].kind === "software-id"),
|
|
physicalUniquenessVerified: z.literal(false), cloneResistanceVerified: z.literal(false) }).strict()
|
|
const receiptSchema = z.object({ peerRef: peer, canonicalNodeId: uuid, incarnation: uuid, status: z.literal("active"), outcome: z.enum(["new", "existing"]) }).strict()
|
|
const expectedSchema = z.object({ binding: bandwidthNodeBindingSchema, participants: z.array(z.object({ evidence: evidenceSchema, receipt: receiptSchema }).strict()).length(2) }).strict()
|
|
const digest = (value: Buffer | string) => createHash("sha256").update(value).digest("hex")
|
|
/** Never run caller accessors/serializers while capturing a fence expectation. */
|
|
function capture(value: unknown): unknown {
|
|
const seen = new Set<object>()
|
|
const walk = (item: unknown, depth: number): unknown => {
|
|
if (depth > 32) fail()
|
|
if (item === null || typeof item === "string" || typeof item === "boolean" || typeof item === "number" && Number.isSafeInteger(item)) return item
|
|
if (!item || typeof item !== "object" || seen.has(item)) fail()
|
|
seen.add(item)
|
|
try {
|
|
const descriptors = Object.getOwnPropertyDescriptors(item)
|
|
if (Object.values(descriptors).some(field => !("value" in field))) fail()
|
|
if (Array.isArray(item)) {
|
|
if (Reflect.ownKeys(item).length !== item.length + 1) fail()
|
|
return Array.from({ length: item.length }, (_, index) => { const entry = descriptors[String(index)]; if (!entry?.enumerable) fail(); return walk(entry.value, depth + 1) })
|
|
}
|
|
if (Object.getPrototypeOf(item) !== Object.prototype || Reflect.ownKeys(item).length !== Object.keys(descriptors).length || Object.values(descriptors).some(field => !field.enumerable)) fail()
|
|
return Object.fromEntries(Object.entries(descriptors).map(([key, entry]) => [key, walk(entry.value, depth + 1)]))
|
|
} finally { seen.delete(item) }
|
|
}
|
|
const result = walk(value, 0)
|
|
if (Buffer.byteLength(JSON.stringify(result)) > 1048576) fail()
|
|
return result
|
|
}
|
|
|
|
export async function assertResolvedBandwidthPeersOnFence(config: Readonly<BandwidthNodeSourceConfig>, sessions: Set<() => void>, closed: () => boolean,
|
|
fence: BandwidthControlDispatchFence, input: BandwidthResolvedPeerFence, original: BandwidthScope): Promise<void> {
|
|
let expected: z.infer<typeof expectedSchema>
|
|
try { expected = expectedSchema.parse(capture(input)) } catch { return fail() }
|
|
if (!original || Object.getPrototypeOf(original) !== Object.prototype || Reflect.ownKeys(original).length !== Object.keys(original).length
|
|
|| Object.keys(original).some(key => !["deadlineAt", "signal"].includes(key)) || Object.values(Object.getOwnPropertyDescriptors(original)).some(field => !("value" in field) || !field.enumerable)
|
|
|| !Number.isSafeInteger(original.deadlineAt) || original.signal !== undefined && !(original.signal instanceof AbortSignal)) fail()
|
|
const source = expected.participants[0], remote = expected.participants[1]
|
|
if (source.evidence.peerRef.kind !== "server" || source.receipt.canonicalNodeId === remote.receipt.canonicalNodeId
|
|
|| bandwidthPeerRefKey(source.evidence.peerRef) === bandwidthPeerRefKey(remote.evidence.peerRef)) fail()
|
|
for (const participant of expected.participants) {
|
|
if (bandwidthPeerRefKey(participant.evidence.peerRef) !== bandwidthPeerRefKey(participant.receipt.peerRef)
|
|
|| participant.evidence.observedAt > Date.now() || participant.evidence.observedAt >= participant.evidence.expiresAt) fail()
|
|
}
|
|
const entered = Date.now(), enteredMono = performance.now()
|
|
const scope = Object.freeze({ deadlineAt: Math.min(original.deadlineAt, ...expected.participants.map(participant => participant.evidence.expiresAt)), signal: original.signal })
|
|
const end = enteredMono + Math.max(0, Math.min(10000, scope.deadlineAt - entered))
|
|
let active = true, rejectStopped!: (error: Error) => void
|
|
const keys = new Set<Buffer>(), wipe = (key: Buffer) => { key.fill(0); keys.delete(key) }
|
|
const live = () => { if (!active || closed() || scope.signal?.aborted || Date.now() >= scope.deadlineAt || performance.now() >= end) fail() }
|
|
const stopped = new Promise<never>((_resolve, reject) => { rejectStopped = reject })
|
|
const stop = () => { active = false; for (const key of keys) key.fill(0); keys.clear(); rejectStopped(new BandwidthPeerFenceError()) }
|
|
const timer = setTimeout(stop, Math.max(1, Math.min(scope.deadlineAt - Date.now(), end - performance.now())))
|
|
sessions.add(stop); scope.signal?.addEventListener("abort", stop, { once: true })
|
|
const root = { installationId: expected.binding.installationId, issuerKeySha256: expected.binding.issuerKeySha256, quiescenceProof: expected.binding.quiescenceProof }
|
|
async function material() {
|
|
live()
|
|
const bytes = await readBandwidthControlFile(config.bootstrapFile, 32768, live)
|
|
const verified = await fence.verifyNodeBootstrap(JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes))); live()
|
|
if (verified.bootstrap.format !== "mmapp-bandwidth-node-bootstrap-v2") fail()
|
|
const actual = { installationId: verified.bootstrap.installationId, issuerKeySha256: verified.bootstrap.issuerKeySha256, quiescenceProof: verified.bootstrap.quiescenceProof,
|
|
bootstrapSha256: digest(canonicalBandwidthNodeValue(verified.bootstrap)), controlGeneration: verified.source.controlGeneration, sourceRecordSha256: verified.source.sourceRecordSha256 }
|
|
if (canonicalBandwidthNodeValue(actual) !== canonicalBandwidthNodeValue(expected.binding) || config.issuerKeySha256 !== actual.issuerKeySha256) fail()
|
|
let key: Buffer | undefined
|
|
try {
|
|
key = await readBandwidthControlFile(config.issuerKeyFile, 32, live); keys.add(key); live()
|
|
if (key.length !== 32 || digest(key) !== config.issuerKeySha256) fail()
|
|
return { verified, key }
|
|
} catch (error) { if (key) wipe(key); throw error }
|
|
}
|
|
const sql = { query: async (text: string, values?: unknown[]) => { live(); const result = await fence.query(text, values); live(); return result } }
|
|
try {
|
|
await Promise.race([Promise.resolve().then(async () => {
|
|
// Fixed registry writers take the exclusive key. The caller's existing
|
|
// journal transaction must retain this shared lock through dispatch;
|
|
// an isolated implicit SELECT does not establish a native-send barrier.
|
|
const lock = (await sql.query("SELECT pg_catalog.pg_try_advisory_xact_lock_shared(8723116) AS locked")).rows
|
|
if (lock.length !== 1 || lock[0].locked !== true) fail()
|
|
const before = await material()
|
|
try {
|
|
const value = before.verified, role = { databaseName: value.source.databaseName, runtimeRole: value.source.runtimeRole, ownerRole: value.source.ownerRole }
|
|
const { assertBandwidthPeerIdentity } = await import("./bandwidth-peer-identity.js")
|
|
live(); await assertBandwidthPeerIdentity(sql, { ...role, ...root, registryCatalogSha256: value.bootstrap.registryCatalogSha256 }, live)
|
|
const pending = []
|
|
for (const participant of expected.participants) {
|
|
const ref = participant.receipt.peerRef, managed = ref.kind === "server", id = managed ? ref.serverId : ref.enrollmentId
|
|
// Both SQL branches are fixed. Identifiers never come from the peer.
|
|
const rows = (await sql.query(managed
|
|
? "SELECT a.server_id,a.incarnation::pg_catalog.text,a.node_id::pg_catalog.text,a.status,a.record_mac,n.claim_proof,n.enrollment_mac FROM mmapp_control.bandwidth_node_aliases a JOIN mmapp_control.bandwidth_nodes n ON n.node_id=a.node_id WHERE a.server_id=$1"
|
|
: "SELECT a.enrollment_id::pg_catalog.text,a.incarnation::pg_catalog.text,a.node_id::pg_catalog.text,a.status,a.record_mac,n.claim_proof,n.enrollment_mac FROM mmapp_control.bandwidth_external_node_aliases a JOIN mmapp_control.bandwidth_nodes n ON n.node_id=a.node_id WHERE a.enrollment_id=$1", [id])).rows
|
|
if (rows.length !== 1) fail()
|
|
const row = rows[0], receipt = participant.receipt
|
|
if ((managed ? Number(row.server_id) !== id : row.enrollment_id !== id) || row.incarnation !== receipt.incarnation || row.node_id !== receipt.canonicalNodeId || row.status !== "active" || !hash.safeParse(row.claim_proof).success) fail()
|
|
const events = (await sql.query(managed
|
|
? "SELECT event_id::pg_catalog.text,incarnation::pg_catalog.text,node_id::pg_catalog.text,kind,old_status,new_status,authority_proof,event_mac FROM mmapp_control.bandwidth_node_events WHERE server_id=$1 ORDER BY kind LIMIT 3"
|
|
: "SELECT event_id::pg_catalog.text,incarnation::pg_catalog.text,node_id::pg_catalog.text,kind,old_status,new_status,authority_proof,event_mac FROM mmapp_control.bandwidth_external_node_events WHERE enrollment_id=$1 ORDER BY kind LIMIT 3", [id])).rows
|
|
if (events.length !== 1) fail()
|
|
const event = events[0]
|
|
if (!uuid.safeParse(event.event_id).success || event.incarnation !== receipt.incarnation || event.node_id !== receipt.canonicalNodeId || event.kind !== "enroll" || event.old_status !== null || event.new_status !== "active" || !hash.safeParse(event.authority_proof).success) fail()
|
|
pending.push({ participant, row, event })
|
|
}
|
|
const after = await material()
|
|
try {
|
|
const proof = (purpose: string, value: unknown) => createHmac("sha256", after.key).update("mmapp-bandwidth-node-" + purpose + "-v1:" + canonicalBandwidthNodeValue(value)).digest("hex")
|
|
for (const { participant, row, event } of pending) {
|
|
const receipt = participant.receipt, ref = receipt.peerRef
|
|
const subject = ref.kind === "server" ? { serverId: ref.serverId } : { enrollmentId: ref.enrollmentId }
|
|
if (row.claim_proof !== proof("claim", participant.evidence.claims)
|
|
|| row.enrollment_mac !== proof("node", { ...root, nodeId: receipt.canonicalNodeId, claimProof: row.claim_proof })
|
|
|| row.record_mac !== proof(ref.kind === "server" ? "alias" : "external-alias", { ...root, ...subject, incarnation: receipt.incarnation, nodeId: receipt.canonicalNodeId, status: "active" })
|
|
|| event.event_mac !== proof(ref.kind === "server" ? "event" : "external-event", { ...root, ...subject, eventId: event.event_id, incarnation: receipt.incarnation, nodeId: receipt.canonicalNodeId, kind: "enroll", oldStatus: null, newStatus: "active", authorityProof: event.authority_proof })) fail()
|
|
}
|
|
live()
|
|
} finally { wipe(after.key) }
|
|
} finally { wipe(before.key) }
|
|
}), stopped])
|
|
} catch { throw new BandwidthPeerFenceError() }
|
|
finally { active = false; clearTimeout(timer); scope.signal?.removeEventListener("abort", stop); sessions.delete(stop); for (const key of keys) key.fill(0); keys.clear() }
|
|
}
|