222 lines
24 KiB
TypeScript
222 lines
24 KiB
TypeScript
import assert from "node:assert/strict"
|
|
import { test } from "node:test"
|
|
import { createHmac, randomUUID } from "node:crypto"
|
|
import { performance } from "node:perf_hooks"
|
|
import { setTimeout as delay } from "node:timers/promises"
|
|
import { createBandwidthPeerResolver, BandwidthPeerResolverError, type BandwidthPeerResolverDependencies } from "./bandwidth-peer-resolver.js"
|
|
import type { BandwidthPeerObservationEvidence } from "./bandwidth-peer-observation.js"
|
|
import type { BandwidthPeerRef } from "./bandwidth-peer-reference.js"
|
|
import type { ProbeStorageConnection } from "./server-probe-journal-maintenance.js"
|
|
|
|
type Row=Record<string,unknown>
|
|
const canonical=(value:unknown):string=>Array.isArray(value)?"["+value.map(canonical).join(",")+"]":value&&typeof value==="object"?"{"+Object.entries(value).sort(([a],[b])=>a<b?-1:a>b?1:0).map(([key,value])=>JSON.stringify(key)+":"+canonical(value)).join(",")+"}":JSON.stringify(value)
|
|
const mac=(purpose:string,value:unknown)=>createHmac("sha256","synthetic-owned-resolver-issuer").update("mmapp-bandwidth-node-"+purpose+"-v1:"+canonical(value)).digest("hex")
|
|
const root={installationId:"11111111-1111-4111-8111-111111111111",issuerKeySha256:"a".repeat(64),quiescenceProof:"b".repeat(64)}
|
|
const canonicalNodeId="22222222-2222-4222-8222-222222222222"
|
|
const deferred=()=>{let resolve!:()=>void;const promise=new Promise<void>(done=>{resolve=done});return{promise,resolve}}
|
|
const scope=(ms=2000)=>({deadlineAt:Date.now()+ms})
|
|
const refused=(error:unknown)=>error instanceof BandwidthPeerResolverError&&error.automaticReplay===false
|
|
function fixture(kind:"server"|"external"="external"){
|
|
const peerRef:BandwidthPeerRef=kind==="server"?{kind:"server",serverId:71}:{kind:"external",enrollmentId:randomUUID()}
|
|
const token=Object.freeze({kind:"owned-private-observation"}),now=Date.now()
|
|
let evidence:BandwidthPeerObservationEvidence={version:2,peerRef,sourceProof:"c".repeat(64),authorityGeneration:"source-v2",routingEndpointEpoch:randomUUID(),observedAt:now,expiresAt:now+60000,claims:[{kind:"system-id",value:"SHARED-SYSTEM"},{kind:"software-id",value:"SHARED-SOFTWARE"}],physicalUniquenessVerified:false,cloneResistanceVerified:false}
|
|
let authority={...root,authorityProof:"d".repeat(64),authorityGeneration:"original-operator-grant",expiresAt:now+60000}
|
|
const subject=kind==="server"?71:(peerRef as {enrollmentId:string}).enrollmentId,incarnation=randomUUID(),eventId=randomUUID(),external=kind==="external"
|
|
const claimProof=mac("claim",evidence.claims),id=external?{enrollmentId:String(subject)}:{serverId:Number(subject)}
|
|
const event={event_id:eventId,incarnation,node_id:canonicalNodeId,kind:"enroll",old_status:null,new_status:"active",authority_proof:authority.authorityProof,event_mac:mac(external?"external-event":"event",{...root,eventId,...id,incarnation,nodeId:canonicalNodeId,kind:"enroll",oldStatus:null,newStatus:"active",authorityProof:authority.authorityProof})}
|
|
let rows:Row[]=[{subject:String(subject),incarnation,node_id:canonicalNodeId,status:"active",record_mac:mac(external?"external-alias":"alias",{...root,...id,incarnation,nodeId:canonicalNodeId,status:"active"}),claim_proof:claimProof,enrollment_mac:mac("node",{...root,nodeId:canonicalNodeId,claimProof}),installation_id:root.installationId,issuer_key_sha256:root.issuerKeySha256,quiescence_proof:root.quiescenceProof,authority_status:"active",events:[event]}]
|
|
let command:unknown="SELECT",revoked=false,inspections=0,authorizations=0,connections=0
|
|
const queries:Array<{text:string;values?:unknown[];options?:{signal?:AbortSignal;timeoutMs:number}}>=[],releases:unknown[]=[],proofs:Array<{purpose:string;value:unknown}>=[]
|
|
let inspectHook:((count:number)=>Promise<void>)|undefined,authorizeHook:((count:number,e:Readonly<BandwidthPeerObservationEvidence>)=>Promise<void>)|undefined,connectHook:(()=>Promise<void>)|undefined,queryHook:(()=>Promise<void>)|undefined,proofHook:((purpose:string)=>Promise<void>)|undefined
|
|
const connection:ProbeStorageConnection={release(unsafe){releases.push(unsafe)},async query(text,values,options){queries.push({text,values,options});await queryHook?.();return{rows:structuredClone(rows),command}}}
|
|
const dependencies:BandwidthPeerResolverDependencies={
|
|
async inspect(value){inspections++;await inspectHook?.(inspections);if(value!==token)throw Error("not genuine");return structuredClone(evidence)},
|
|
async authorize(peer,_scope,e){authorizations++;assert.deepEqual(peer,peerRef);await authorizeHook?.(authorizations,e);if(revoked)throw Error("original grant revoked");return{...authority}},
|
|
async connect(){connections++;await connectHook?.();return connection},
|
|
async keyedProof(purpose,value){proofs.push({purpose,value:structuredClone(value)});await proofHook?.(purpose);return mac(purpose,value)},
|
|
}
|
|
const resolver=createBandwidthPeerResolver(dependencies)
|
|
return{resolver,dependencies,token,peerRef,queries,releases,proofs,row:()=>rows[0],event:()=>((rows[0].events as Row[])[0]),
|
|
setRows:(value:Row[])=>{rows=value},command:(value:unknown)=>{command=value},revoke:()=>{revoked=true},
|
|
setEvidence:(change:Partial<BandwidthPeerObservationEvidence>)=>{evidence={...evidence,...change}},setAuthority:(change:Partial<typeof authority>)=>{authority={...authority,...change}},
|
|
onInspect:(hook:typeof inspectHook)=>{inspectHook=hook},onAuthorize:(hook:typeof authorizeHook)=>{authorizeHook=hook},onConnect:(hook:typeof connectHook)=>{connectHook=hook},onQuery:(hook:typeof queryHook)=>{queryHook=hook},onProof:(hook:typeof proofHook)=>{proofHook=hook},
|
|
inspections:()=>inspections,authorizations:()=>authorizations,connections:()=>connections}
|
|
}
|
|
|
|
test("managed/external genuine v2 refs resolve through exactly one SELECT snapshot, original MAC domains, and frozen existing receipt",async()=>{
|
|
const fixtures=[fixture("server"),fixture("external")]
|
|
for(const f of fixtures){const result=await f.resolver.resolve(f.token,scope());assert.equal(result.canonicalNodeId,canonicalNodeId);assert.equal(result.outcome,"existing");assert.equal(result.status,"active");assert.deepEqual(result.peerRef,f.peerRef);assert(Object.isFrozen(result));assert(Object.isFrozen(result.peerRef));assert.equal(f.connections(),1);assert.equal(f.queries.length,1);assert.deepEqual(f.releases,[true])
|
|
const q=f.queries[0];assert(q.text.startsWith("WITH alias AS MATERIALIZED"));assert(q.text.includes("events AS MATERIALIZED"));assert(q.text.includes("JOIN mmapp_control.bandwidth_nodes"));assert(q.text.includes("JOIN mmapp_control.bandwidth_node_authority"));assert(!/\b(?:BEGIN|COMMIT|ROLLBACK|INSERT|UPDATE|DELETE|TRUNCATE|CREATE|ALTER)\b/.test(q.text));assert(!q.text.includes("bandwidth_node_occupancy"));assert.deepEqual(q.values,[f.peerRef.kind==="server"?f.peerRef.serverId:f.peerRef.enrollmentId]);assert(q.options?.signal instanceof AbortSignal);assert(q.options!.timeoutMs>0&&q.options!.timeoutMs<=5000)
|
|
const external=f.peerRef.kind==="external";assert(q.text.includes(external?"bandwidth_external_node_aliases":"bandwidth_node_aliases"));assert(q.text.includes(external?"$1::pg_catalog.uuid":"$1::pg_catalog.int8"));assert.deepEqual(f.proofs.map(p=>p.purpose),["claim","node",external?"external-alias":"alias",external?"external-event":"event"])
|
|
}
|
|
assert.deepEqual(fixtures[0].proofs[0],fixtures[1].proofs[0]);assert.deepEqual(fixtures[0].proofs[1],fixtures[1].proofs[1]);assert.notDeepEqual(fixtures[0].proofs[2],fixtures[1].proofs[2])
|
|
})
|
|
test("absent/duplicate snapshot, wrong SQL command and rows-only facade never auto-enroll or return a receipt",async()=>{
|
|
for(const mode of ["absent","duplicate","rows-only","wrong-command"]){const f=fixture();if(mode==="absent")f.setRows([]);if(mode==="duplicate")f.setRows([f.row(),structuredClone(f.row())]);if(mode==="rows-only")f.command(undefined);if(mode==="wrong-command")f.command("UPDATE");await assert.rejects(f.resolver.resolve(f.token,scope()),refused);assert.equal(f.queries.length,1);assert.equal(f.proofs.length,0);assert.deepEqual(f.releases,[true])}
|
|
})
|
|
test("typed evidence remains a private same-reader capability: copies, public evidence and another token refuse before checkout",async()=>{
|
|
const f=fixture();for(const token of [{...f.token},JSON.parse(JSON.stringify(f.token)),{version:2,peerRef:f.peerRef},fixture().token])await assert.rejects(f.resolver.resolve(token,scope()),refused)
|
|
assert.equal(f.connections(),0);assert.equal(f.queries.length,0)
|
|
})
|
|
test("snapshot authority/key/quiescence/status and original alias/node/event linkage are exact",async()=>{
|
|
for(const change of [
|
|
(f:ReturnType<typeof fixture>)=>{f.row().subject=randomUUID()},(f:ReturnType<typeof fixture>)=>{f.row().installation_id=randomUUID()},(f:ReturnType<typeof fixture>)=>{f.row().issuer_key_sha256="f".repeat(64)},(f:ReturnType<typeof fixture>)=>{f.row().quiescence_proof="f".repeat(64)},(f:ReturnType<typeof fixture>)=>{f.row().authority_status="quarantined"},(f:ReturnType<typeof fixture>)=>{f.row().status="tombstoned"},(f:ReturnType<typeof fixture>)=>{f.row().node_id=randomUUID()},(f:ReturnType<typeof fixture>)=>{f.event().incarnation=randomUUID()},(f:ReturnType<typeof fixture>)=>{f.event().node_id=randomUUID()},(f:ReturnType<typeof fixture>)=>{f.event().old_status="active"},(f:ReturnType<typeof fixture>)=>{f.event().kind="quarantine"},(f:ReturnType<typeof fixture>)=>{f.row().events=[]},(f:ReturnType<typeof fixture>)=>{f.row().events=[f.event(),structuredClone(f.event())]},(f:ReturnType<typeof fixture>)=>{f.row().unexpected="trusted"},
|
|
]){const f=fixture();change(f);await assert.rejects(f.resolver.resolve(f.token,scope()),refused);assert.equal(f.queries.length,1);assert.deepEqual(f.releases,[true])}
|
|
})
|
|
test("claim/node/managed-or-external alias/event MAC tampering cannot create a replacement identity",async()=>{
|
|
for(const kind of ["server","external"] as const)for(const field of ["claim_proof","enrollment_mac","record_mac","event_mac","authority_proof"]){const f=fixture(kind);if(field==="event_mac"||field==="authority_proof")f.event()[field]="f".repeat(64);else f.row()[field]="f".repeat(64);await assert.rejects(f.resolver.resolve(f.token,scope()),refused);assert.equal(f.queries.length,1);assert.deepEqual(f.releases,[true])}
|
|
})
|
|
test("source/native claim/routing epoch and original grant/key/generation/expiry drift during SELECT refuse before private proof or return",async()=>{
|
|
for(const mutate of [
|
|
(f:ReturnType<typeof fixture>)=>f.setEvidence({sourceProof:"f".repeat(64)}),
|
|
(f:ReturnType<typeof fixture>)=>f.setEvidence({claims:[{kind:"system-id",value:"CHANGED"}]}),
|
|
(f:ReturnType<typeof fixture>)=>f.setEvidence({routingEndpointEpoch:randomUUID()}),
|
|
(f:ReturnType<typeof fixture>)=>f.revoke(),
|
|
(f:ReturnType<typeof fixture>)=>f.setAuthority({issuerKeySha256:"f".repeat(64)}),
|
|
(f:ReturnType<typeof fixture>)=>f.setAuthority({authorityGeneration:"new-grant"}),
|
|
(f:ReturnType<typeof fixture>)=>f.setAuthority({expiresAt:Date.now()+120000}),
|
|
]){const f=fixture();f.onQuery(async()=>mutate(f));await assert.rejects(f.resolver.resolve(f.token,scope()),refused);assert.equal(f.proofs.length,0);assert.equal(f.queries.length,1);assert.deepEqual(f.releases,[true])}
|
|
})
|
|
test("the original grant is the last async guard after inspection and private signing; revocation does not admit another IO",async()=>{
|
|
for(const phase of ["inspect-after-sql","private-node-proof"]){const f=fixture();if(phase==="inspect-after-sql")f.onInspect(async()=>{if(f.queries.length)f.revoke()});else f.onProof(async purpose=>{if(purpose==="node")f.revoke()});await assert.rejects(f.resolver.resolve(f.token,scope()),refused);assert.equal(f.queries.length,1);assert.deepEqual(f.releases,[true]);if(phase==="inspect-after-sql")assert.equal(f.proofs.length,0);else assert.deepEqual(f.proofs.map(p=>p.purpose),["claim","node"])}
|
|
})
|
|
test("genuine evidence is deeply immutable for authorizer/private claim proof; returned source objects cannot be rewritten",async()=>{
|
|
const f=fixture();let checked=0
|
|
f.onAuthorize(async(_count,evidence)=>{checked++;assert(Object.isFrozen(evidence));assert(Object.isFrozen(evidence.peerRef));assert(Object.isFrozen(evidence.claims));assert(evidence.claims.every(Object.isFrozen))})
|
|
await f.resolver.resolve(f.token,scope());assert(checked>2)
|
|
const hostile=fixture();hostile.onAuthorize(async(_count,evidence)=>{(evidence as unknown as Row).sourceProof="f".repeat(64)})
|
|
await assert.rejects(hostile.resolver.resolve(hostile.token,scope()),refused);assert.equal(hostile.connections(),0)
|
|
})
|
|
test("construction captures server-owned dependency methods once; later request-side field replacements cannot select a SQL/source/key callback",async()=>{
|
|
const f=fixture();const forbidden=async()=>{assert.fail("replacement callback executed")}
|
|
f.dependencies.inspect=forbidden;f.dependencies.authorize=forbidden;f.dependencies.connect=forbidden;f.dependencies.keyedProof=forbidden
|
|
assert.equal((await f.resolver.resolve(f.token,scope())).canonicalNodeId,canonicalNodeId);assert.equal(f.queries.length,1)
|
|
})
|
|
test("invalid, accessor-bearing, symbol-bearing, expired or already-aborted scopes refuse before source/SQL",async()=>{
|
|
const controller=new AbortController();controller.abort()
|
|
const inputs:unknown[]=[null,{}, {deadlineAt:NaN},{deadlineAt:Date.now()-1},{deadlineAt:Date.now()+1000,extra:true},{deadlineAt:Date.now()+1000,signal:controller.signal},{deadlineAt:Date.now()+1000,signal:{aborted:false}}]
|
|
let accessors=0;inputs.push(Object.defineProperty({},"deadlineAt",{enumerable:true,get(){accessors++;return Date.now()+1000}}));const symbolic={deadlineAt:Date.now()+1000};Object.defineProperty(symbolic,Symbol("proof"),{value:true});inputs.push(symbolic)
|
|
for(const raw of inputs){const f=fixture();await assert.rejects(f.resolver.resolve(f.token,raw as {deadlineAt:number}),refused);assert.equal(f.inspections(),0);assert.equal(f.connections(),0)}assert.equal(accessors,0)
|
|
})
|
|
test("a stalled authorizer is bounded; late successful original authority never checks out a connection",{timeout:2000},async()=>{
|
|
const f=fixture(),entered=deferred(),gate=deferred();f.onAuthorize(async()=>{entered.resolve();await gate.promise})
|
|
const pending=f.resolver.resolve(f.token,scope(60));await entered.promise;await assert.rejects(pending,refused);gate.resolve();await delay(10);assert.equal(f.connections(),0);assert.equal(f.queries.length,0)
|
|
})
|
|
test("abort during owned checkout destroys a late lease exactly once and sends no SQL",{timeout:2000},async()=>{
|
|
const f=fixture(),entered=deferred(),gate=deferred(),controller=new AbortController();f.onConnect(async()=>{entered.resolve();await gate.promise})
|
|
const pending=f.resolver.resolve(f.token,{...scope(),signal:controller.signal});await entered.promise;controller.abort();await assert.rejects(pending,refused);assert.deepEqual(f.releases,[]);gate.resolve();await delay(10);assert.deepEqual(f.releases,[true]);assert.equal(f.queries.length,0)
|
|
})
|
|
test("abort during blocked SELECT bounds the operation, destroys lease, and late rows cannot run proofs or return success",{timeout:2000},async()=>{
|
|
const f=fixture(),entered=deferred(),gate=deferred(),controller=new AbortController();f.onQuery(async()=>{entered.resolve();await gate.promise})
|
|
const pending=f.resolver.resolve(f.token,{...scope(),signal:controller.signal});await entered.promise;assert.notEqual(f.queries[0].options?.signal,controller.signal);controller.abort();await assert.rejects(pending,refused);assert.equal(f.queries[0].options?.signal?.aborted,true);assert.deepEqual(f.releases,[true]);gate.resolve();await delay(10);assert.equal(f.proofs.length,0);assert.deepEqual(f.releases,[true]);assert.equal(f.queries.length,1)
|
|
})
|
|
test("original monotonic expiry survives a 60-second wall clock rollback during blocked SQL; late result cannot renew budget",{timeout:2000},async()=>{
|
|
const f=fixture(),entered=deferred(),gate=deferred(),realNow=Date.now;f.onQuery(async()=>{entered.resolve();await gate.promise})
|
|
const began=performance.now(),pending=f.resolver.resolve(f.token,scope(100))
|
|
try{await entered.promise;Date.now=()=>realNow()-60000;await assert.rejects(pending,refused);assert(performance.now()-began<1000);assert.deepEqual(f.releases,[true]);gate.resolve();await delay(10);assert.equal(f.proofs.length,0);assert.equal(f.queries.length,1)}finally{Date.now=realNow;gate.resolve()}
|
|
})
|
|
test("an earlier inspected capability expiry reschedules the original timer and cannot be renewed by later authority",{timeout:2000},async()=>{
|
|
const f=fixture(),entered=deferred(),gate=deferred();f.setEvidence({expiresAt:Date.now()+80});f.onQuery(async()=>{entered.resolve();await gate.promise})
|
|
const pending=f.resolver.resolve(f.token,scope(1500));await entered.promise;await assert.rejects(pending,refused);assert.deepEqual(f.releases,[true]);f.setEvidence({expiresAt:Date.now()+10000});gate.resolve();await delay(10);assert.equal(f.proofs.length,0);assert.equal(f.queries.length,1)
|
|
})
|
|
|
|
test("earlier original grant expiry and captured input deadline cannot be extended while a lease or SQL is pending",{timeout:2500},async()=>{
|
|
for(const phase of ["grant-sql","input-checkout"] as const){
|
|
const f=fixture(),entered=deferred(),gate=deferred(),originalScope=scope(phase==="input-checkout"?80:1500)
|
|
if(phase==="grant-sql"){f.setAuthority({expiresAt:Date.now()+80});f.onQuery(async()=>{entered.resolve();await gate.promise})}
|
|
else f.onConnect(async()=>{entered.resolve();await gate.promise})
|
|
const pending=f.resolver.resolve(f.token,originalScope);await entered.promise;originalScope.deadlineAt=Date.now()+60000
|
|
await assert.rejects(pending,refused);f.setAuthority({expiresAt:Date.now()+60000});gate.resolve();await delay(10)
|
|
assert.equal(f.proofs.length,0);assert.equal(f.queries.length,phase==="grant-sql"?1:0);assert.deepEqual(f.releases,[true])
|
|
}
|
|
})
|
|
test("driver/source failure exposes only stable refusal, destroys lease and never retries SELECT",async()=>{
|
|
const f=fixture();f.onQuery(async()=>{throw Error("private endpoint/password/key")})
|
|
await assert.rejects(f.resolver.resolve(f.token,scope()),error=>refused(error)&&!String(error).includes("password"));assert.equal(f.queries.length,1);assert.deepEqual(f.releases,[true]);assert.equal(f.proofs.length,0)
|
|
})
|
|
|
|
test("managed/external atomic issuer uses one frozen four-material batch with identical scalar domains and linkage",async()=>{
|
|
for(const kind of ["server","external"] as const){
|
|
const f=fixture(kind),batches:Array<readonly {purpose:string;value:unknown}[]>=[]
|
|
const dependencies={...f.dependencies,keyedProofs:async(inputs:readonly Readonly<{purpose:string;value:unknown}>[],current:{deadlineAt:number;signal?:AbortSignal})=>{
|
|
assert(Object.isFrozen(inputs));assert.equal(inputs.length,4);assert(current.signal instanceof AbortSignal)
|
|
for(const input of inputs){assert(Object.isFrozen(input));assert(Object.isFrozen(input.value))}
|
|
const claims=inputs[0].value as readonly object[];assert(Object.isFrozen(claims));assert(claims.every(Object.isFrozen))
|
|
batches.push(structuredClone(inputs));return Object.freeze(inputs.map(input=>mac(input.purpose,input.value)))
|
|
}}
|
|
const resolver=createBandwidthPeerResolver(dependencies)
|
|
dependencies.keyedProofs=async()=>{assert.fail("replacement batch issuer executed")}
|
|
const receipt=await resolver.resolve(f.token,scope())
|
|
assert.equal(receipt.canonicalNodeId,canonicalNodeId);assert(Object.isFrozen(receipt));assert.equal(batches.length,1);assert.equal(f.proofs.length,0)
|
|
assert.deepEqual(batches[0].map(input=>input.purpose),["claim","node",kind==="external"?"external-alias":"alias",kind==="external"?"external-event":"event"])
|
|
const row=f.row(),event=f.event(),values=batches[0].map(input=>mac(input.purpose,input.value))
|
|
assert.deepEqual(values,[row.claim_proof,row.enrollment_mac,row.record_mac,event.event_mac]);assert.equal(f.queries.length,1);assert.deepEqual(f.releases,[true])
|
|
assert.equal((batches[0][1].value as Row).claimProof,row.claim_proof)
|
|
}
|
|
})
|
|
|
|
test("atomic issuer rejects wrong length, mutable/sparse/accessor/symbol/nonenumerable outputs and invalid hashes without scalar fallback",async()=>{
|
|
let getterCalls=0
|
|
const outputs:Array<(values:string[])=>unknown>=[
|
|
values=>Object.freeze(values.slice(0,3)),values=>Object.freeze([...values,values[0]]),values=>values,
|
|
values=>Object.freeze([...values.slice(0,2),"g".repeat(64),values[3]]),values=>Object.freeze([...values.slice(0,2),null,values[3]]),
|
|
values=>{const result=[...values];delete result[1];return Object.freeze(result)},
|
|
values=>{const result=[...values];Object.defineProperty(result,"2",{get(){getterCalls++;return values[2]},enumerable:true});return Object.freeze(result)},
|
|
values=>{const result=[...values];Object.defineProperty(result,"2",{value:values[2],enumerable:false});return Object.freeze(result)},
|
|
values=>{const result=[...values];Object.defineProperty(result,Symbol("issuer-proof"),{value:true});return Object.freeze(result)},
|
|
]
|
|
for(const output of outputs){const f=fixture();let calls=0
|
|
const resolver=createBandwidthPeerResolver({...f.dependencies,keyedProofs:async inputs=>{calls++;return output(inputs.map(input=>mac(input.purpose,input.value))) as readonly string[]}})
|
|
await assert.rejects(resolver.resolve(f.token,scope()),refused);assert.equal(calls,1);assert.equal(f.proofs.length,0);assert.equal(f.queries.length,1);assert.deepEqual(f.releases,[true])
|
|
}
|
|
assert.equal(getterCalls,0)
|
|
})
|
|
|
|
test("atomic claim/node/alias/event MAC tampering still refuses every original material",async()=>{
|
|
for(const kind of ["server","external"] as const)for(const index of [0,1,2,3]){
|
|
const f=fixture(kind),resolver=createBandwidthPeerResolver({...f.dependencies,keyedProofs:async inputs=>Object.freeze(inputs.map((input,i)=>i===index?"f".repeat(64):mac(input.purpose,input.value)))})
|
|
await assert.rejects(resolver.resolve(f.token,scope()),refused);assert.equal(f.proofs.length,0);assert.equal(f.queries.length,1);assert.deepEqual(f.releases,[true])
|
|
}
|
|
})
|
|
|
|
test("atomic issuer captures parsed immutable materials before await; later driver object changes cannot rewrite them",async()=>{
|
|
const f=fixture(),entered=deferred(),gate=deferred();let inputsSeen:readonly Readonly<{purpose:string;value:unknown}>[]|undefined
|
|
const resolver=createBandwidthPeerResolver({...f.dependencies,keyedProofs:async inputs=>{
|
|
inputsSeen=inputs;entered.resolve();await gate.promise
|
|
return Object.freeze(inputs.map(input=>mac(input.purpose,input.value)))
|
|
}})
|
|
const pending=resolver.resolve(f.token,scope());await entered.promise
|
|
const originalNode=(inputsSeen![1].value as Row).nodeId
|
|
f.row().node_id=randomUUID();f.row().claim_proof="f".repeat(64);f.event().authority_proof="f".repeat(64)
|
|
assert.equal((inputsSeen![1].value as Row).nodeId,originalNode)
|
|
assert.throws(()=>{(inputsSeen![1].value as Row).nodeId=randomUUID()})
|
|
gate.resolve();assert.equal((await pending).canonicalNodeId,canonicalNodeId);assert.deepEqual(f.releases,[true])
|
|
})
|
|
|
|
test("atomic post-batch original actor/key/generation/expiry and native evidence revocation cannot return a receipt",async()=>{
|
|
for(const drift of ["actor","key","generation","expiry","source"] as const){const f=fixture()
|
|
const resolver=createBandwidthPeerResolver({...f.dependencies,keyedProofs:async inputs=>{
|
|
const values=Object.freeze(inputs.map(input=>mac(input.purpose,input.value)))
|
|
if(drift==="actor")f.revoke()
|
|
if(drift==="key")f.setAuthority({issuerKeySha256:"f".repeat(64)})
|
|
if(drift==="generation")f.setAuthority({authorityGeneration:"replacement"})
|
|
if(drift==="expiry")f.setAuthority({expiresAt:Date.now()+120000})
|
|
if(drift==="source")f.setEvidence({sourceProof:"f".repeat(64)})
|
|
return values
|
|
}})
|
|
await assert.rejects(resolver.resolve(f.token,scope()),refused);assert.equal(f.proofs.length,0);assert.equal(f.queries.length,1);assert.deepEqual(f.releases,[true])
|
|
}
|
|
})
|
|
|
|
test("abort/expiry during blocked atomic issuer destroys lease once; late MACs cause zero new SQL or success",{timeout:2500},async()=>{
|
|
for(const kind of ["abort","expiry"] as const){const f=fixture(),entered=deferred(),gate=deferred(),controller=new AbortController();let calls=0,issuerScope:{signal?:AbortSignal}|undefined
|
|
const resolver=createBandwidthPeerResolver({...f.dependencies,keyedProofs:async(inputs,current)=>{
|
|
calls++;issuerScope=current;entered.resolve();await gate.promise;return Object.freeze(inputs.map(input=>mac(input.purpose,input.value)))
|
|
}})
|
|
const pending=resolver.resolve(f.token,{...scope(kind==="expiry"?80:2000),signal:controller.signal});await entered.promise
|
|
if(kind==="abort")controller.abort()
|
|
await assert.rejects(pending,refused);assert.equal(issuerScope!.signal!.aborted,true);assert.deepEqual(f.releases,[true])
|
|
gate.resolve();await delay(10);assert.equal(calls,1);assert.equal(f.queries.length,1);assert.equal(f.proofs.length,0);assert.deepEqual(f.releases,[true])
|
|
}
|
|
})
|