Files
MikrotikManager/backend/src/services/bandwidth-node-key-effect.test.ts
T

147 lines
14 KiB
TypeScript

/** Real local file and crypto effects. Wrapped fs observers inject races;
* neither Q/PG nor a full operating window is claimed by these unit tests. */
import assert from "node:assert/strict"
import * as fs from "node:fs"
import {mkdtemp,writeFile,rm,rename,mkdir,symlink} from "node:fs/promises"
import {createHash,createHmac,randomUUID} from "node:crypto"
import {tmpdir} from "node:os"
import path from "node:path"
import {mock,test} from "node:test"
import {performance} from "node:perf_hooks"
import {canonicalBandwidthNodeValue,type BandwidthNodeBootstrap} from "./bandwidth-node-bootstrap.js"
import type {BandwidthNodeProofInput} from "./bandwidth-node-proof-input.js"
test("fixed synchronous local key effect",async t=>{
let hook:((phase:string)=>void)|undefined,reads=0,opens=0,closes=0,syntheticLink=false,shortRead=false,closeFault=false
const buffers:Buffer[]=[]
mock.module("node:fs",{namedExports:{...fs,
lstatSync:(...args:Parameters<typeof fs.lstatSync>)=>{const value=fs.lstatSync(...args);return value&&syntheticLink&&String(args[0]).endsWith("issuer")?Object.assign(Object.create(value),{isSymbolicLink:()=>true}):value},
openSync:(...args:Parameters<typeof fs.openSync>)=>{opens++;const result=fs.openSync(...args);hook?.("open");return result},
readSync:(fd:number,buffer:Buffer,offset:number,length:number,position:number)=>{
reads++;buffers.push(buffer);hook?.("before-read")
const result=fs.readSync(fd,buffer,offset,shortRead?Math.min(7,length):length,position);hook?.("after-read");return result
},
closeSync:(fd:number)=>{closes++;fs.closeSync(fd);hook?.("close");if(closeFault)throw Error("synthetic close failure")},
}})
const {createBandwidthNodeKeyEffect,BandwidthNodeKeyEffectRefused}=await import("./bandwidth-node-key-effect.js")
async function fixture(v2=true){
const base=await mkdtemp(path.join(tmpdir(),"mm-fixed-key-")),directory=path.join(base,"keys")
await mkdir(directory);const keyFile=path.join(directory,"issuer"),key=Buffer.alloc(32,81)
await writeFile(keyFile,key)
const bootstrap:BandwidthNodeBootstrap={format:v2?"mmapp-bandwidth-node-bootstrap-v2":"mmapp-bandwidth-node-bootstrap-v1",installationId:randomUUID(),issuerKeySha256:createHash("sha256").update(key).digest("hex"),quiescenceProof:"b".repeat(64),registrySchemaSourceSha256:"c".repeat(64),registryCatalogSha256:"d".repeat(64),attestationRef:"Explicit synthetic bootstrap for local key unit acceptance"}
const actor=new AbortController(),owner=new AbortController(),deadlineAt=Date.now()+5000
const config={keyFile,bootstrap,deadlineAt,signal:actor.signal,ownerSignal:owner.signal}
const inputs:BandwidthNodeProofInput[]=[{purpose:"claim",value:[{kind:"system-id",value:"synthetic-router"}]}]
const expected=(items:readonly BandwidthNodeProofInput[])=>items.map(({purpose,value})=>createHmac("sha256",key).update("mmapp-bandwidth-node-"+purpose+"-v1:"+canonicalBandwidthNodeValue(value)).digest("hex"))
const start=buffers.length
return {base,directory,keyFile,key,bootstrap,actor,owner,config,inputs,expected,
create:()=>createBandwidthNodeKeyEffect(config),
async dispose(){hook=undefined;syntheticLink=false;shortRead=false;closeFault=false;for(const buffer of buffers.slice(start))assert(buffer.every(byte=>byte===0),"all actual scratch keys wiped");await rm(base,{recursive:true,force:true})},
}
}
await t.test("construction is inert; claim and both node versions preserve domains",async()=>{
for(const v2 of [false,true]){const f=await fixture(v2);try{
const before={reads,opens,closes},effect=f.create();assert.deepEqual({reads,opens,closes},before)
const root={installationId:f.bootstrap.installationId,issuerKeySha256:f.bootstrap.issuerKeySha256,quiescenceProof:f.bootstrap.quiescenceProof},nodeId=randomUUID(),incarnation=randomUUID()
const subject=v2?{enrollmentId:randomUUID()}:{serverId:71}
const items:BandwidthNodeProofInput[]=[{purpose:"node",value:{...root,nodeId,claimProof:"e".repeat(64)}},{purpose:v2?"external-alias":"alias",value:{...root,...subject,nodeId,incarnation,status:"active"}},{purpose:v2?"external-event":"event",value:{...root,...subject,nodeId,incarnation,eventId:randomUUID(),kind:"enroll",oldStatus:null,newStatus:"active",authorityProof:"f".repeat(64)}}]
assert.deepEqual(effect.calculate(f.inputs),f.expected(f.inputs));const result=effect.calculate(items)
assert.deepEqual(result,f.expected(items));assert(Object.isFrozen(result));assert.equal(reads-before.reads,2);assert.equal(opens-before.opens,2);assert.equal(closes-before.closes,2)
assert.equal(typeof (result as unknown as {then?:unknown}).then,"undefined","no asynchronous result or key handle")
}finally{await f.dispose()}}
})
for(const fault of ["wrong-hash","short","long","missing","directory"]){await t.test(`invalid key ${fault} refuses and poisons effect`,async()=>{
const f=await fixture();try{const effect=f.create()
if(fault==="missing")await rm(f.keyFile)
else if(fault==="directory"){await rm(f.keyFile);await mkdir(f.keyFile)}
else await writeFile(f.keyFile,Buffer.alloc(fault==="short"?31:fault==="long"?33:32,82))
assert.throws(()=>effect.calculate(f.inputs),BandwidthNodeKeyEffectRefused)
if(fault==="directory")await rm(f.keyFile,{recursive:true})
await writeFile(f.keyFile,f.key);const n=opens;assert.throws(()=>effect.calculate(f.inputs),BandwidthNodeKeyEffectRefused);assert.equal(opens,n)
}finally{await f.dispose()}
})}
for(const phase of ["open","before-read","after-read","close"]){for(const who of ["actor","owner"] as const){await t.test(`${who} revocation during ${phase} suppresses MAC`,async()=>{
const f=await fixture();try{const effect=f.create();hook=p=>{if(p===phase)f[who].abort()};assert.throws(()=>effect.calculate(f.inputs),BandwidthNodeKeyEffectRefused)
}finally{await f.dispose()}
})}}
for(const phase of ["before-read","after-read","close"]){await t.test(`late synchronous ${phase} return cannot publish MAC`,async()=>{
const f=await fixture(),now=Date.now;try{const effect=f.create();hook=p=>{if(p===phase)Date.now=()=>f.config.deadlineAt+1};assert.throws(()=>effect.calculate(f.inputs),BandwidthNodeKeyEffectRefused)
}finally{Date.now=now;await f.dispose()}
})}
await t.test("key replacement after read refuses before publication",async()=>{
const f=await fixture();try{const effect=f.create();hook=p=>{if(p==="after-read"){fs.renameSync(f.keyFile,f.keyFile+".old");fs.writeFileSync(f.keyFile,f.key)}};assert.throws(()=>effect.calculate(f.inputs),BandwidthNodeKeyEffectRefused)
}finally{await f.dispose()}
})
await t.test("same-byte directory clone between phases refuses",async()=>{
const f=await fixture();try{const effect=f.create();effect.calculate(f.inputs);await rename(f.directory,f.directory+"-old");await mkdir(f.directory);await writeFile(f.keyFile,f.key);assert.throws(()=>effect.calculate(f.inputs),BandwidthNodeKeyEffectRefused)
}finally{await f.dispose()}
})
await t.test("key symlink refuses before opening target (synthetic stat fallback on Windows)",async()=>{
const f=await fixture();try{const target=path.join(f.base,"target");await writeFile(target,f.key);await rm(f.keyFile)
try{await symlink(target,f.keyFile)}catch(e){if((e as NodeJS.ErrnoException).code!=="EPERM")throw e;await writeFile(f.keyFile,f.key);syntheticLink=true}
const effect=f.create(),n=opens;assert.throws(()=>effect.calculate(f.inputs),BandwidthNodeKeyEffectRefused);assert.equal(opens,n)
}finally{await f.dispose()}
})
await t.test("invalid/callback/proxy input never opens key or invokes caller",async()=>{
const f=await fixture();try{let calls=0
const bad=[[],Array(1),[{purpose:"claim",get value(){calls++;return []}}],new Proxy([],{ownKeys(){calls++;return []}}),[{purpose:"unknown",value:[]}],Array(5).fill(f.inputs[0])]
for(const item of bad){const effect=f.create(),n=opens;assert.throws(()=>effect.calculate(item as BandwidthNodeProofInput[]),BandwidthNodeKeyEffectRefused);assert.equal(opens,n)}assert.equal(calls,0)
}finally{await f.dispose()}
})
await t.test("foreign root and v1 external proofs refuse before key IO",async()=>{
const f=await fixture(false);try{
const root={installationId:f.bootstrap.installationId,issuerKeySha256:f.bootstrap.issuerKeySha256,quiescenceProof:f.bootstrap.quiescenceProof}
const cases=[{purpose:"node",value:{...root,installationId:randomUUID(),nodeId:randomUUID(),claimProof:"e".repeat(64)}},{purpose:"external-alias",value:{...root,enrollmentId:randomUUID(),incarnation:randomUUID(),nodeId:randomUUID(),status:"active"}}]
for(const item of cases){const effect=f.create(),n=opens;assert.throws(()=>effect.calculate([item]),BandwidthNodeKeyEffectRefused);assert.equal(opens,n)}
}finally{await f.dispose()}
})
await t.test("closed or already expired original scope refuses before key IO",async()=>{
const f=await fixture();try{const n=opens,effect=f.create();effect.close();assert.throws(()=>effect.calculate(f.inputs));const expired=createBandwidthNodeKeyEffect({...f.config,deadlineAt:Date.now()-1});assert.throws(()=>expired.calculate(f.inputs));assert.equal(opens,n)
}finally{await f.dispose()}
})
await t.test("short reads complete exactly 32 bytes under the same checks",async()=>{
const f=await fixture();try{shortRead=true;const n=reads;assert.deepEqual(f.create().calculate(f.inputs),f.expected(f.inputs));assert.equal(reads-n,5)}finally{await f.dispose()}
})
await t.test("close failure suppresses output, wipes key and prohibits replay",async()=>{
const f=await fixture();try{const effect=f.create(),n=closes;closeFault=true;assert.throws(()=>effect.calculate(f.inputs),BandwidthNodeKeyEffectRefused);assert.equal(closes-n,1);closeFault=false;const before=opens;assert.throws(()=>effect.calculate(f.inputs));assert.equal(opens,before)}finally{await f.dispose()}
})
await t.test("scratch key is wiped before descriptor closure",async()=>{
const f=await fixture();try{const first=buffers.length;let checked=false;hook=p=>{if(p==="close"){checked=true;assert(buffers.slice(first).length>0);for(const b of buffers.slice(first))assert(b.every(byte=>byte===0))}};assert.deepEqual(f.create().calculate(f.inputs),f.expected(f.inputs));assert(checked)}finally{await f.dispose()}
})
await t.test("monotonic horizon still expires after wall clock rolls backward",async()=>{
const f=await fixture(),wall=Date.now,mono=performance.now.bind(performance);let elapsed=0
const clock=mock.method(performance,"now",()=>mono()+elapsed)
try{const effect=f.create();Date.now=()=>wall()-60000;elapsed=5001;const n=opens;assert.throws(()=>effect.calculate(f.inputs),BandwidthNodeKeyEffectRefused);assert.equal(opens,n)}finally{Date.now=wall;clock.mock.restore();await f.dispose()}
})
await t.test("longer requested deadline cannot extend five-second local horizon",async()=>{
const f=await fixture(),mono=performance.now.bind(performance);let elapsed=0
const clock=mock.method(performance,"now",()=>mono()+elapsed)
try{const effect=createBandwidthNodeKeyEffect({...f.config,deadlineAt:Date.now()+60000});elapsed=5001;const n=opens;assert.throws(()=>effect.calculate(f.inputs));assert.equal(opens,n)}finally{clock.mock.restore();await f.dispose()}
})
await t.test("constructor rejects getter configuration and fake owner signal without IO",async()=>{
const f=await fixture();try{let calls=0;const n=opens
assert.throws(()=>createBandwidthNodeKeyEffect({...f.config,get keyFile(){calls++;return f.keyFile}}));assert.throws(()=>createBandwidthNodeKeyEffect({...f.config,ownerSignal:{} as AbortSignal}));assert.equal(calls,0);assert.equal(opens,n)
}finally{await f.dispose()}
})
await t.test("proxy actor/owner signals are rejected without any traps",async()=>{
const f=await fixture();try{let calls=0;const n=opens
for(const name of ["signal","ownerSignal"] as const){const signal=new Proxy(f.config[name],{get(){calls++;return false},has(){calls++;return false},getPrototypeOf(){calls++;return AbortSignal.prototype}});assert.throws(()=>createBandwidthNodeKeyEffect({...f.config,[name]:signal}),BandwidthNodeKeyEffectRefused)}
assert.equal(calls,0);assert.equal(opens,n)
}finally{await f.dispose()}
})
await t.test("real signal own-symbol accessors refuse before the initial builtin aborted getter",async()=>{
for(const name of ["signal","ownerSignal"] as const){const f=await fixture();try{let calls=0;const n=opens,symbol=Object.getOwnPropertySymbols(f.config[name]).find(key=>String(key)==="Symbol(kAborted)");assert(symbol)
const original=Object.getOwnPropertyDescriptor(f.config[name],symbol)!
Object.defineProperty(f.config[name],symbol,{configurable:true,get(){calls++;return original.value}})
try{assert.throws(()=>f.create(),BandwidthNodeKeyEffectRefused);assert.equal(calls,0);assert.equal(opens,n)}finally{Object.defineProperty(f.config[name],symbol,original)}
}finally{await f.dispose()}}
})
await t.test("later own-symbol getter mutation cannot execute during key read/HMAC/close",async()=>{
for(const name of ["signal","ownerSignal"] as const){const f=await fixture();try{let calls=0;const effect=f.create(),symbol=Object.getOwnPropertySymbols(f.config[name]).find(key=>String(key)==="Symbol(kAborted)");assert(symbol)
const original=Object.getOwnPropertyDescriptor(f.config[name],symbol)!
Object.defineProperty(f.config[name],symbol,{configurable:true,get(){calls++;return original.value}})
try{assert.deepEqual(effect.calculate(f.inputs),f.expected(f.inputs));effect.close();assert.equal(calls,0)}finally{Object.defineProperty(f.config[name],symbol,original)}
}finally{await f.dispose()}}
})
})