Files
MikrotikManager/backend/src/services/bandwidth-node-registry-batch.test.ts
T

158 lines
20 KiB
TypeScript

import assert from "node:assert/strict"
import { test } from "node:test"
import { createHmac, randomUUID } from "node:crypto"
import { bandwidthRegistryEnrollmentSql, bandwidthRegistrySnapshotSql, parseBandwidthRegistrySnapshot, bandwidthRegistrySnapshotProofs, type BandwidthRegistryEnrollmentBatch, type BandwidthRegistryKind } from "./bandwidth-node-registry-batch.js"
import { createBandwidthNodeRegistry } from "./bandwidth-node-registry.js"
import { createBandwidthExternalNodeRegistry, BandwidthExternalNodeRegistryUnknown } from "./bandwidth-external-node-registry.js"
import type { BandwidthNodeProofInput } from "./bandwidth-node-source.js"
type Row=Record<string,unknown>
const canonical=(v:unknown):string=>Array.isArray(v)?"["+v.map(canonical).join(",")+"]":v&&typeof v==="object"?"{"+Object.entries(v).sort(([a],[b])=>a<b?-1:a>b?1:0).map(([k,v])=>JSON.stringify(k)+":"+canonical(v)).join(",")+"}":JSON.stringify(v)
const mac=(purpose:string,value:unknown)=>createHmac("sha256","inert-batch-candidate-fixture-key").update("mmapp-bandwidth-node-"+purpose+"-v1:"+canonical(value)).digest("hex")
const root={installationId:randomUUID(),issuerKeySha256:"a".repeat(64),quiescenceProof:"b".repeat(64)}
const scope=()=>({deadlineAt:Date.now()+2000})
const material=(kind:BandwidthRegistryKind="managed"):BandwidthRegistryEnrollmentBatch=>({kind,subject:kind==="managed"?71:randomUUID(),insertNode:true,nodeId:randomUUID(),claimProof:"a".repeat(64),nodeMac:"b".repeat(64),incarnation:randomUUID(),aliasMac:"c".repeat(64),eventId:randomUUID(),authorityProof:"d".repeat(64),eventMac:"e".repeat(64)})
function fixture(atomic=false){
const nodes:Row[]=[],aliases:Row[]=[],events:Row[]=[],queries:string[]=[],releases:boolean[]=[],proofs:Array<{purpose:string;value:Row|unknown[];mac:string}>=[],occupancy={status:"unknown",owner:"original-attempt"},tokens=new WeakMap<object,{kind:BandwidthRegistryKind;id:number|string;claims:Array<{kind:"system-id"|"software-id";value:string}>;expiresAt:number}>()
let revoked=false,dropDoCommand=false,loseCommit=false,afterBatch=false,finalAuthority=false,finalInspections=0,revokeBeforeCommit=false
let proofHook:((purpose:string)=>void)|undefined,queryHook:((sql:string)=>void)|undefined
let batchCalls=0,batchHook:(()=>Promise<void>)|undefined,batchFault:"short"|"long"|"malformed"|undefined
const expiry=Date.now()+60000
const authorize=async()=>{if(revoked)throw Error("original grant revoked");return{...root,authorityProof:"d".repeat(64),authorityGeneration:"fixture-original-grant",expiresAt:expiry}}
const inspect=(kind:BandwidthRegistryKind)=>async(token:unknown)=>{const source=token&&typeof token==="object"?tokens.get(token):undefined;assert(source&&source.kind===kind)
if(revokeBeforeCommit&&finalAuthority&&++finalInspections===3)revoked=true
return{version:kind==="managed"?1:2,...(kind==="managed"?{serverId:Number(source.id)}:{peerRef:{kind:"external",enrollmentId:String(source.id)}}),sourceProof:"e".repeat(64),authorityGeneration:"fixture-source",routingEndpointEpoch:root.installationId,observedAt:1,expiresAt:source.expiresAt,claims:source.claims,physicalUniquenessVerified:false,cloneResistanceVerified:false} as never
}
const connect=async()=>{const saved=structuredClone({nodes,aliases,events});let committed=false
const restore=()=>{for(const [target,before]of[[nodes,saved.nodes],[aliases,saved.aliases],[events,saved.events]])target.splice(0,target.length,...before)}
return{release(unsafe?:boolean){releases.push(unsafe===true);if(!committed)restore()},async query(sql:string,values:unknown[]=[]){
queries.push(sql);const result=(rows:Row[]=[],command?:string)=>({rows:structuredClone(rows),command})
if(sql==="BEGIN")return result([],"BEGIN")
if(sql==="ROLLBACK"){restore();return result([],"ROLLBACK")}
if(sql==="COMMIT"){committed=true;if(loseCommit)throw Error("fixture loss AFTER actual simulated commit");return result([],"COMMIT")}
if(sql.includes("set_config")||sql.includes("pg_advisory_xact_lock"))return result([],"SELECT")
if(sql.startsWith("SELECT installation_id")){if(afterBatch)finalAuthority=true;queryHook?.(sql);return result([{installation_id:root.installationId,issuer_key_sha256:root.issuerKeySha256,quiescence_proof:root.quiescenceProof,status:"active"}],"SELECT")}
const external=sql.includes("bandwidth_external_node_aliases"),kind=external?"external":"managed",id=String(values[0])
if(sql.startsWith("WITH aliases AS MATERIALIZED")){
const found=aliases.filter(a=>a.kind===kind&&a.subject===id),current=nodes.filter(n=>found.some(a=>a.node_id===n.node_id)),chain=events.filter(e=>e.alias_kind===kind&&e.subject===id).map(({alias_kind:_k,subject:_id,...event})=>event)
return result([{aliases:found.map(({kind:_k,...a})=>a),nodes:current,events:chain,claim_nodes:values[1]===null?[]:nodes.filter(n=>n.claim_proof===values[1])}],"SELECT")
}
if(sql.startsWith("DO $mmapp_bandwidth_register$")){
const latest=(purpose:string)=>{const proof=[...proofs].reverse().find(p=>p.purpose===purpose);assert(proof);return proof}
const n=latest("node"),a=latest(external?"external-alias":"alias"),e=latest(external?"external-event":"event"),nm=n.value as Row,am=a.value as Row,em=e.value as Row,subject=String(external?am.enrollmentId:am.serverId)
// Inert model only. It checks that the exact signed values are present in
// the candidate's fixed DO text; actual PL/pgSQL visibility needs owned PG.
for(const value of [nm.nodeId,nm.claimProof,n.mac,am.incarnation,a.mac,em.eventId,e.mac])assert(sql.includes(String(value)))
if(sql.includes("IF true THEN")){assert(!nodes.some(node=>node.claim_proof===nm.claimProof));nodes.push({node_id:nm.nodeId,claim_proof:nm.claimProof,enrollment_mac:n.mac})}
else assert(nodes.some(node=>node.node_id===nm.nodeId&&node.claim_proof===nm.claimProof&&node.enrollment_mac===n.mac))
assert(!aliases.some(alias=>alias.kind===kind&&alias.subject===subject));aliases.push({kind,subject,incarnation:am.incarnation,node_id:am.nodeId,status:"active",record_mac:a.mac})
events.push({alias_kind:kind,subject,event_id:em.eventId,incarnation:em.incarnation,node_id:em.nodeId,kind:"enroll",old_status:null,new_status:"active",authority_proof:em.authorityProof,event_mac:e.mac});afterBatch=true;queryHook?.(sql);return result([],dropDoCommand?undefined:"DO")
}
if(sql.startsWith("UPDATE")&&sql.includes("_aliases SET")){const row=aliases.find(a=>a.kind===kind&&a.subject===id&&a.status==="active"&&a.record_mac===values[3]);assert(row);row.status=values[1];row.record_mac=values[2];return result([{[external?"enrollment_id":"server_id"]:external?id:Number(id)}],"UPDATE")}
if(sql.startsWith("INSERT")&&sql.includes("_events(")){const external=sql.includes("bandwidth_external_node_events"),kind=external?"external":"managed";events.push({alias_kind:kind,subject:String(values[1]),event_id:values[0],incarnation:values[2],node_id:values[3],kind:values[4],old_status:values[5],new_status:values[6],authority_proof:values[7],event_mac:values[8]});return result([{event_id:values[0]}],"INSERT")}
throw Error("unexpected inert candidate SQL")
}}
}
const keyedProof=async(purpose:string,value:unknown)=>{const digest=mac(purpose,value);proofs.push({purpose,value:structuredClone(value) as Row,mac:digest});proofHook?.(purpose);return digest}
const batch=atomic?{keyedProofs:async(inputs:readonly BandwidthNodeProofInput[])=>{
batchCalls++;assert(Object.isFrozen(inputs));assert(inputs.every(Object.isFrozen))
await batchHook?.()
const values=inputs.map(({purpose,value})=>{const digest=mac(purpose,value);proofs.push({purpose,value:structuredClone(value) as Row,mac:digest});return digest})
// No await between pure MACs; the hook models source revocation before return.
inputs.forEach(({purpose})=>proofHook?.(purpose))
if(batchFault==="short")return values.slice(1)
if(batchFault==="long")return [...values,"a".repeat(64)]
if(batchFault==="malformed")return values.map((value,index)=>index===1?"bad":value)
return Object.freeze(values)
}}:{}
const managed=createBandwidthNodeRegistry({now:Date.now,connect,authorize,inspect:inspect("managed"),keyedProof,...batch}),external=createBandwidthExternalNodeRegistry({now:Date.now,connect,authorize,inspect:inspect("external"),keyedProof,...batch})
const observe=(kind:BandwidthRegistryKind,id:number|string,claims:Array<{kind:"system-id"|"software-id";value:string}>=[{kind:"system-id",value:"SAME-NODE"}])=>{const token={};tokens.set(token,{kind,id,claims,expiresAt:expiry});return token}
return{managed,external,observe,nodes,aliases,events,queries,releases,proofs,occupancy,dropDo:()=>{dropDoCommand=true},loseCommit:()=>{loseCommit=true},revoke:()=>{revoked=true},proofHook:(hook:typeof proofHook)=>{proofHook=hook},queryHook:(hook:typeof queryHook)=>{queryHook=hook},revokeBeforeCommit:()=>{revokeBeforeCommit=true},batchCalls:()=>batchCalls,batchHook:(hook:typeof batchHook)=>{batchHook=hook},batchFault:(fault:typeof batchFault)=>{batchFault=fault}}
}
test("fixed managed/external DO is invoker-only sequential SPI with STRICT returning and exact expected IDs",()=>{
for(const kind of ["managed","external"] as const)for(const insertNode of [true,false]){const p={...material(kind),insertNode},sql=bandwidthRegistryEnrollmentSql(p)
assert(sql.startsWith("DO $mmapp_bandwidth_register$"));assert(sql.includes(`IF ${insertNode} THEN`));assert.equal((sql.match(/INSERT INTO/g)||[]).length,3);assert.equal((sql.match(/RETURNING .*INTO STRICT/g)||[]).length,3);assert(sql.includes("SELECT node_id,claim_proof,enrollment_mac INTO STRICT"));assert(sql.indexOf("INSERT INTO mmapp_control.bandwidth_nodes")<sql.indexOf(kind==="managed"?"INSERT INTO mmapp_control.bandwidth_node_aliases":"INSERT INTO mmapp_control.bandwidth_external_node_aliases"));assert(!/\b(?:EXECUTE|SECURITY DEFINER|CREATE|ALTER|DROP|TRUNCATE|ON CONFLICT)\b/.test(sql));assert(!sql.includes("bandwidth_node_occupancy"));assert(sql.includes("got_event IS DISTINCT FROM"));assert(sql.includes("got_subject IS DISTINCT FROM"));assert(sql.includes("got_node_mac IS DISTINCT FROM"))
}
const max={...material(),subject:Number.MAX_SAFE_INTEGER};assert(bandwidthRegistryEnrollmentSql(max).includes("9007199254740991::pg_catalog.int8"))
})
test("no unvalidated text, identifier, accessor, coercion, unsafe number or foreign variant enters DO literals",()=>{
for(const field of ["nodeId","incarnation","eventId","claimProof","nodeMac","aliasMac","authorityProof","eventMac"]){const p=material();(p as unknown as Row)[field]="'; DROP TABLE x; --";assert.throws(()=>bandwidthRegistryEnrollmentSql(p))}
for(const value of [0,-1,1.5,Number.MAX_SAFE_INTEGER+1,NaN,Infinity,"71",randomUUID()])assert.throws(()=>bandwidthRegistryEnrollmentSql({...material(),subject:value as number}))
assert.throws(()=>bandwidthRegistryEnrollmentSql({...material("external"),subject:71}));assert.throws(()=>bandwidthRegistryEnrollmentSql({...material(),insertNode:"true" as unknown as boolean}));assert.throws(()=>bandwidthRegistryEnrollmentSql({...material(),extra:true} as BandwidthRegistryEnrollmentBatch))
let reads=0;const p=material();Object.defineProperty(p,"nodeMac",{enumerable:true,get(){reads++;return"a".repeat(64)}});assert.throws(()=>bandwidthRegistryEnrollmentSql(p));assert.equal(reads,0)
})
test("snapshot SQL variants remain fixed and bind IDs/hash; pure parser refuses missing/duplicate/current-node/event inconsistencies",()=>{
for(const kind of ["managed","external"] as const)for(const lock of [true,false]){const sql=bandwidthRegistrySnapshotSql(kind,lock);assert(sql.includes("WITH aliases AS MATERIALIZED"));assert(sql.includes("claim_proof=$2::pg_catalog.text"));assert.equal(sql.includes("FOR UPDATE"),lock);assert(!/\b(?:INSERT|DELETE|CREATE|ALTER|TRUNCATE)\b/.test(sql));assert(!sql.includes("bandwidth_node_occupancy"))}
assert.throws(()=>bandwidthRegistrySnapshotSql("injected" as BandwidthRegistryKind,true));assert.throws(()=>bandwidthRegistrySnapshotSql("managed",1 as unknown as boolean))
const p=material(),empty={aliases:[],nodes:[],events:[],claim_nodes:[]};assert(Object.isFrozen(parseBandwidthRegistrySnapshot([empty],"managed",71,p.claimProof)))
const node={node_id:p.nodeId,claim_proof:p.claimProof,enrollment_mac:p.nodeMac},snapshot=parseBandwidthRegistrySnapshot([{aliases:[{subject:"71",incarnation:p.incarnation,node_id:p.nodeId,status:"active",record_mac:p.aliasMac}],nodes:[node],events:[{event_id:p.eventId,incarnation:p.incarnation,node_id:p.nodeId,kind:"enroll",old_status:null,new_status:"active",authority_proof:p.authorityProof,event_mac:p.eventMac}],claim_nodes:[node]}],"managed",71,p.claimProof)
const descriptors=bandwidthRegistrySnapshotProofs("managed",snapshot,root);assert.deepEqual(descriptors.map(value=>value.purpose),["alias","node","event"]);assert(Object.isFrozen(descriptors));assert(descriptors.every(value=>Object.isFrozen(value)&&Object.isFrozen(value.value)))
for(const data of [[],[empty,empty],[{...empty,nodes:[{node_id:p.nodeId,claim_proof:p.claimProof,enrollment_mac:p.nodeMac}]}],[{...empty,events:[{}]}],[{...empty,claim_nodes:[{node_id:p.nodeId,claim_proof:"f".repeat(64),enrollment_mac:p.nodeMac}]}]])assert.throws(()=>parseBandwidthRegistrySnapshot(data,"managed",71,p.claimProof))
})
test("candidate managed/external register uses one snapshot SELECT and one DO; same typed claim issuer preserves node and unknown",async()=>{
const f=fixture(),managed=await f.managed.register(f.observe("managed",71),scope()),externalId=randomUUID(),external=await f.external.register(f.observe("external",externalId),scope())
assert.equal(managed.canonicalNodeId,external.canonicalNodeId);assert.notEqual(managed.incarnation,external.incarnation);assert.equal(f.nodes.length,1);assert.equal(f.aliases.length,2);assert.equal(f.events.length,2)
assert.equal(f.queries.filter(q=>q.startsWith("WITH aliases AS MATERIALIZED")).length,2);assert.equal(f.queries.filter(q=>q.startsWith("DO $mmapp_bandwidth_register$")).length,2);assert.equal(f.queries.length,18);assert.deepEqual(f.occupancy,{status:"unknown",owner:"original-attempt"});assert(!f.queries.some(q=>q.includes("bandwidth_node_occupancy")))
})
test("existing alias, resolve and retirement reuse one pure snapshot proof path; terminal alias never re-enrolls or changes canonical identity",async()=>{
const f=fixture(),id=randomUUID(),token=f.observe("external",id),first=await f.external.register(token,scope())
assert.equal((await f.external.register(token,scope())).outcome,"existing");assert.equal((await f.external.resolve(token,scope())).canonicalNodeId,first.canonicalNodeId)
assert.equal((await f.external.retire(id,"tombstone",scope())).status,"tombstoned");assert.equal((await f.external.retire(id,"tombstone",scope())).outcome,"existing")
await assert.rejects(f.external.register(token,scope()));await assert.rejects(f.external.resolve(token,scope()));await assert.rejects(f.external.retire(id,"quarantine",scope()))
const replacement=await f.external.register(f.observe("external",randomUUID()),scope());assert.equal(replacement.canonicalNodeId,first.canonicalNodeId);assert.notEqual(replacement.incarnation,first.incarnation);assert.equal(f.nodes.length,1)
})
test("snapshot node/alias/event MAC or full typed claim drift refuses without replacement node/event",async()=>{
for(const fault of ["node","alias","event","typed-claim"]){const f=fixture(),token=f.observe("managed",71);await f.managed.register(token,scope());if(fault==="node")f.nodes[0].enrollment_mac="f".repeat(64);if(fault==="alias")f.aliases[0].record_mac="f".repeat(64);if(fault==="event")f.events[0].event_mac="f".repeat(64)
await assert.rejects(f.managed.register(fault==="typed-claim"?f.observe("managed",71,[{kind:"software-id",value:"SAME-NODE"}]):token,scope()));assert.equal(f.nodes.length,1);assert.equal(f.events.length,1)
}
})
test("rows-only DO completion cannot acknowledge the batch; outer transaction rolls back and does not COMMIT",async()=>{
const f=fixture();f.dropDo();await assert.rejects(f.external.register(f.observe("external",randomUUID()),scope()));assert.equal(f.nodes.length,0);assert.equal(f.aliases.length,0);assert.equal(f.events.length,0);assert(!f.queries.includes("COMMIT"));assert(f.queries.includes("ROLLBACK"))
})
test("original grant revocation during event signing or after actual batch dispatch prevents COMMIT and preserves preexisting unknown",async()=>{
for(const boundary of ["event-proof","after-do"]){const f=fixture();if(boundary==="event-proof")f.proofHook(purpose=>{if(purpose==="external-event")f.revoke()});else f.queryHook(sql=>{if(sql.startsWith("DO $mmapp_bandwidth_register$"))f.revoke()})
await assert.rejects(f.external.register(f.observe("external",randomUUID()),scope()));assert(!f.queries.includes("COMMIT"));assert.equal(f.nodes.length,0);assert.equal(f.events.length,0);assert.equal(f.queries.filter(q=>q.startsWith("DO $mmapp_bandwidth_register$")).length,boundary==="after-do"?1:0);assert.deepEqual(f.occupancy,{status:"unknown",owner:"original-attempt"})
}
})
test("the original final pre-COMMIT inspection/authority boundary remains effective after DO, with no weakened late-grant fault",async()=>{
const f=fixture();f.revokeBeforeCommit();await assert.rejects(f.managed.register(f.observe("managed",71),scope()));assert.equal(f.queries.filter(q=>q.startsWith("DO $mmapp_bandwidth_register$")).length,1);assert(!f.queries.includes("COMMIT"));assert.deepEqual(f.releases,[true]);assert.equal(f.nodes.length,0);assert.equal(f.aliases.length,0)
})
test("existing external lost COMMIT ACK remains unknown/no replay even though node+alias+event writes are batched",async()=>{
const f=fixture();f.loseCommit();await assert.rejects(f.external.register(f.observe("external",randomUUID()),scope()),error=>error instanceof BandwidthExternalNodeRegistryUnknown&&error.automaticReplay===false);assert.equal(f.nodes.length,1);assert.equal(f.aliases.length,1);assert.equal(f.events.length,1);assert.equal(f.queries.filter(q=>q==="COMMIT").length,1);assert(!f.queries.includes("ROLLBACK"))
})
test("trusted atomic signer preserves scalar domains and exact enrollment data for both participant kinds",async()=>{
for(const kind of ["managed","external"] as const){
const f=fixture(true),id=kind==="managed"?71:randomUUID(),token=f.observe(kind,id)
const receipt=await (kind==="managed"?f.managed:f.external).register(token,scope())
assert.equal(receipt.status,"active");assert.equal(f.batchCalls(),1);assert.equal(f.proofs.length,4)
assert.equal(f.proofs[0].purpose,"claim")
assert.equal(f.queries.filter(q=>q.startsWith("DO $mmapp_bandwidth_register$")).length,1)
assert.equal(f.nodes.length,1);assert.equal(f.events.length,1)
assert.deepEqual(f.occupancy,{status:"unknown",owner:"original-attempt"})
}
})
test("atomic signer result corruption and original authority loss refuse before enrollment DO",async()=>{
for(const kind of ["managed","external"] as const)for(const fault of ["short","long","malformed","revoke"] as const){
const f=fixture(true),id=kind==="managed"?71:randomUUID()
if(fault==="revoke")f.proofHook(purpose=>{if(purpose.endsWith("event"))f.revoke()});else f.batchFault(fault)
await assert.rejects((kind==="managed"?f.managed:f.external).register(f.observe(kind,id),scope()))
assert.equal(f.batchCalls(),1);assert.equal(f.nodes.length,0);assert.equal(f.events.length,0)
assert(!f.queries.some(q=>q.startsWith("DO $mmapp_bandwidth_register$")||q==="COMMIT"))
}
})
test("aborted pending atomic signing destroys its lease; late MACs cannot resume a write",async()=>{
const f=fixture(true),controller=new AbortController()
let release!:()=>void,entered!:()=>void
const waiting=new Promise<void>(done=>{entered=done}),held=new Promise<void>(done=>{release=done})
f.batchHook(async()=>{entered();await held})
const pending=f.external.register(f.observe("external",randomUUID()),{deadlineAt:Date.now()+2000,signal:controller.signal})
await waiting;controller.abort();await assert.rejects(pending)
release();await new Promise(done=>setTimeout(done,10))
assert.deepEqual(f.releases,[true]);assert.equal(f.nodes.length,0)
assert(!f.queries.some(q=>q.startsWith("DO $mmapp_bandwidth_register$")||q==="COMMIT"))
})