Files
MikrotikManager/backend/src/services/bandwidth-peer-identity.ts
T

92 lines
7.3 KiB
TypeScript

/** One bounded MVCC snapshot of the full v2 registry identity. No new lease,
* supplied SQL, readiness assertion, cache, retry or native authority. The same
* pure role/catalog validators and signed catalog digest serve all observers. */
import { z } from "zod"
import { BANDWIDTH_NODE_REGISTRY_ROLE_SQL, captureBandwidthNodeRegistryRoleExpected, validateBandwidthNodeRegistryRuntimeRoleRows } from "./bandwidth-node-registry-role.js"
import { BANDWIDTH_EXTERNAL_NODE_REGISTRY_ROLE_SQL, validateBandwidthExternalNodeRegistryRuntimeRoleRows } from "./bandwidth-external-node-registry-role.js"
import { BANDWIDTH_PEER_MANAGED_REGISTRY_CATALOG_SQL, BANDWIDTH_PEER_REGISTRY_INCOMING_SQL, validateBandwidthPeerRegistryCatalogRows } from "./bandwidth-node-registry-catalog.js"
import { BANDWIDTH_EXTERNAL_NODE_REGISTRY_CATALOG_SQL } from "./bandwidth-external-node-registry-catalog.js"
export interface BandwidthPeerIdentitySql { query(text:string,values?:unknown[]):Promise<{rows:Record<string,unknown>[]}> }
const hash=z.string().regex(/^[a-f0-9]{64}$/)
const expectedSchema=z.object({databaseName:z.string(),runtimeRole:z.string(),ownerRole:z.string(),installationId:z.string().uuid(),issuerKeySha256:hash,quiescenceProof:hash,registryCatalogSha256:hash}).strict()
export type BandwidthPeerIdentityExpected=z.infer<typeof expectedSchema>
export class BandwidthPeerIdentityRefused extends Error {
readonly code="BANDWIDTH_PEER_IDENTITY_REFUSED"
constructor(){super("Bandwidth peer registry identity refused")}
}
function fail():never{throw new BandwidthPeerIdentityRefused()}
const plain=(v:unknown):v is Record<string,unknown>=>!!v&&typeof v==="object"&&Object.getPrototypeOf(v)===Object.prototype
const fields=["databaseName","runtimeRole","ownerRole","installationId","issuerKeySha256","quiescenceProof","registryCatalogSha256"] as const
/** Original scalar expectations are copied before the first asynchronous SQL;
* caller getters, serializers, symbols and later mutations cannot select pins. */
function capture(expected:BandwidthPeerIdentityExpected):Readonly<BandwidthPeerIdentityExpected>{
if(!plain(expected)||Reflect.ownKeys(expected).length!==fields.length)fail()
const descriptors=Object.getOwnPropertyDescriptors(expected)
if(Object.keys(descriptors).sort().join(",")!==[...fields].sort().join(",")||Object.values(descriptors).some(field=>!("value"in field)||!field.enumerable))fail()
let parsed:BandwidthPeerIdentityExpected
try{parsed=expectedSchema.parse(Object.fromEntries(fields.map(name=>[name,descriptors[name].value])));captureBandwidthNodeRegistryRoleExpected({databaseName:parsed.databaseName,runtimeRole:parsed.runtimeRole,ownerRole:parsed.ownerRole})}catch{return fail()}
return Object.freeze(parsed)
}
type Kind="managed-role"|"external-role"|"managed-catalog"|"external-catalog"|"incoming"|"authority"
const limits:Record<Kind,number>={"managed-role":1,"external-role":1,"managed-catalog":234,"external-catalog":230,incoming:2,authority:1}
/** Every nested query is a fixed existing observer statement; CTE evaluation
* shares ONE PostgreSQL command snapshot, including inbound FK identities and
* the immutable authority. Null overflow rows deliberately fail validation. */
export const BANDWIDTH_PEER_IDENTITY_SQL=`/* bandwidth-peer:identity */ WITH
managed_role AS MATERIALIZED (${BANDWIDTH_NODE_REGISTRY_ROLE_SQL}),
external_role AS MATERIALIZED (${BANDWIDTH_EXTERNAL_NODE_REGISTRY_ROLE_SQL}),
managed_catalog AS MATERIALIZED (${BANDWIDTH_PEER_MANAGED_REGISTRY_CATALOG_SQL}),
external_catalog AS MATERIALIZED (${BANDWIDTH_EXTERNAL_NODE_REGISTRY_CATALOG_SQL}),
incoming AS MATERIALIZED (${BANDWIDTH_PEER_REGISTRY_INCOMING_SQL}),
authority AS MATERIALIZED (
SELECT installation_id::pg_catalog.text,issuer_key_sha256,quiescence_proof,status
FROM mmapp_control.bandwidth_node_authority WHERE id=1 LIMIT 2),
bundled AS (
SELECT 'managed-role'::pg_catalog.text AS kind,pg_catalog.to_jsonb(r)::pg_catalog.text AS raw_json FROM managed_role r
UNION ALL SELECT 'external-role',pg_catalog.to_jsonb(r)::pg_catalog.text FROM external_role r
UNION ALL SELECT 'managed-catalog',pg_catalog.to_jsonb(r)::pg_catalog.text FROM managed_catalog r
UNION ALL SELECT 'external-catalog',pg_catalog.to_jsonb(r)::pg_catalog.text FROM external_catalog r
UNION ALL SELECT 'incoming',pg_catalog.to_jsonb(r)::pg_catalog.text FROM incoming r
UNION ALL SELECT 'authority',pg_catalog.to_jsonb(r)::pg_catalog.text FROM authority r),
metered AS (
SELECT kind,raw_json,pg_catalog.row_number() OVER(ORDER BY kind COLLATE "C",raw_json COLLATE "C") AS row_order,
pg_catalog.count(*) OVER() AS row_count,pg_catalog.sum(pg_catalog.octet_length(raw_json)) OVER() AS total_bytes
FROM bundled)
SELECT kind,row_order::pg_catalog.text AS row_order,
CASE WHEN row_count<=469 AND total_bytes<=6291456 AND pg_catalog.octet_length(raw_json)<=131200 THEN raw_json END AS raw_json
FROM metered ORDER BY metered.row_order LIMIT 470`
/** Pure counterpart for captured rows. Component validators retain their own
* tighter structural/byte bounds and the original exact signed digest. */
export function validateBandwidthPeerIdentityRows(rows:unknown,expected:BandwidthPeerIdentityExpected):void{
const captured=capture(expected)
if(!Array.isArray(rows)||rows.length>469)fail()
const found:Record<Kind,Record<string,unknown>[]>={"managed-role":[],"external-role":[],"managed-catalog":[],"external-catalog":[],incoming:[],authority:[]}
const ordinals=new Set<number>();let bytes=0
for(const row of rows){
if(!plain(row)||Object.keys(row).sort().join(",")!=="kind,raw_json,row_order"||typeof row.kind!=="string"||!Object.hasOwn(found,row.kind)||typeof row.raw_json!=="string"||typeof row.row_order!=="string"||!/^[1-9][0-9]{0,2}$/.test(row.row_order))fail()
const ordinal=Number(row.row_order);if(ordinal>rows.length||ordinals.has(ordinal))fail();ordinals.add(ordinal)
const size=Buffer.byteLength(row.raw_json);bytes+=size;if(size>131200||bytes>6291456)fail()
let value:unknown;try{value=JSON.parse(row.raw_json)}catch{return fail()};if(!plain(value))fail()
const kind=row.kind as Kind;found[kind].push(value);if(found[kind].length>limits[kind])fail()
}
try{
const role={databaseName:captured.databaseName,runtimeRole:captured.runtimeRole,ownerRole:captured.ownerRole}
validateBandwidthNodeRegistryRuntimeRoleRows(found["managed-role"],role)
validateBandwidthExternalNodeRegistryRuntimeRoleRows(found["external-role"],role)
if(validateBandwidthPeerRegistryCatalogRows(found["managed-catalog"],found["external-catalog"],found.incoming)!==captured.registryCatalogSha256)fail()
if(found.authority.length!==1)fail()
const authority=found.authority[0]
if(Object.keys(authority).sort().join(",")!=="installation_id,issuer_key_sha256,quiescence_proof,status"||authority.installation_id!==captured.installationId||authority.issuer_key_sha256!==captured.issuerKeySha256||authority.quiescence_proof!==captured.quiescenceProof||authority.status!=="active")fail()
}catch{return fail()}
}
export async function assertBandwidthPeerIdentity(sql:BandwidthPeerIdentitySql,expected:BandwidthPeerIdentityExpected,live:()=>void):Promise<void>{
const captured=capture(expected)
live();let result:{rows:Record<string,unknown>[]}
try{result=await sql.query(BANDWIDTH_PEER_IDENTITY_SQL,[captured.databaseName,captured.runtimeRole,captured.ownerRole])}catch{live();return fail()}
live();validateBandwidthPeerIdentityRows(result?.rows,captured);live()
}