Files
MikrotikManager/backend/scripts/database-writer-profile-operator.mts
T

187 lines
18 KiB
TypeScript

/** Explicit operator process only. No HTTP, runtime import, role provisioning or READY. */
import assert from 'node:assert/strict'
import path from 'node:path'
import {pathToFileURL} from 'node:url'
import {createPrivateKey,createPublicKey,sign} from 'node:crypto'
import {readdir} from 'node:fs/promises'
import {readProtected,protectedDirectory,sha,withJournalLease,writeFile} from './writer-profile/operator-files.mjs'
import {approval,upgradeApproval,reconciliationApproval,poolOptions,roleKeys,assertJsDriverEnvironment} from './writer-profile/operator-contract.mjs'
import {deploymentRequest} from './database-writer-bootstrap-operator.mjs'
const hex=(v:unknown)=>typeof v==='string'&&/^[a-f0-9]{64}$/.test(v)
const parse=(b:Buffer)=>JSON.parse(new TextDecoder('utf-8',{fatal:true}).decode(b))
const sourceCommands=['source-activate','source-revoke','source-status']
export async function main(args:string[]){
if(args[0]==='legacy-cold-verify')return (await import('./writer-profile/legacy-cold-verification.mjs')).verifyLegacyColdMain(args)
if(args[0]==='source58-foundation-enroll'||args[0]==='source57-admission-enroll')return (await import('./writer-profile/source58-foundation.mjs')).source58FoundationMain(args)
if(args[0]==='legacy-control-reference'||args[0]==='legacy-source58-preflight')return (await import('./writer-profile/legacy-control-reference.mjs')).legacyControlReferenceMain(args)
if(['legacy-handoff-execute','legacy-handoff-adopt','legacy-handoff-release'].includes(args[0]))return (await import('./writer-profile/legacy-handoff-execution.mjs')).legacyHandoffExecuteMain(args)
if(['registry-enroll','registry-inspect','restore-profile-enroll'].includes(args[0]))return (await import('./writer-profile/registry-enrollment.mjs')).registryEnrollmentMain(args)
if(args[0]==='marker-fence-enroll')return (await import('./writer-profile/marker-fence-enrollment.mjs')).markerFenceEnrollmentMain(args)
if(sourceCommands.includes(args[0]))return (await import('./writer-profile/source-activation.mjs')).sourceActivationMain(args)
if(['maintenance-inspect','maintenance-resolve'].includes(args[0]))return (await import('./writer-profile/maintenance-resolution.mjs')).maintenanceMain(args)
const legacyCustody=args[0]==='legacy-custody'
const legacyHandoff=args[0]==='legacy-handoff-inspect'
const legacyExport=legacyCustody||args[0]==='legacy-export'
const legacyInspection=legacyExport||legacyHandoff||args[0]==='legacy-inspect'
const catalogueInspection=args[0]==='source-catalogue-inspect'
const activePreflight=args[0]==='source-preflight',preflight=activePreflight||args[0]==='preflight'
const upgrade=args[0]==='upgrade'
const writes=upgrade||args[0]==='publish'
const flags=['bootstrap','bootstrap-sha256','transport','transport-sha256','ca','source-registry','source-spki-sha256']
if(!legacyInspection)flags.push('definition','definition-sha256')
if(!legacyInspection&&!catalogueInspection)flags.push('approval','approval-sha256','journal')
if(legacyInspection||catalogueInspection||activePreflight||writes)flags.push('activation-directory','activation-sha256')
if(legacyExport)flags.push('archive-directory','source-signing-key')
if(legacyHandoff)flags.push('archive-directory','handoff-intent-sha256')
assert((legacyInspection||catalogueInspection||preflight||writes||args[0]==='reconcile')&&args.length===1+2*flags.length)
assertJsDriverEnvironment(process.env)
const values=new Map<string,string>()
for(let i=1;i<args.length;i+=2){assert(args[i].startsWith('--')&&flags.includes(args[i].slice(2))&&!values.has(args[i].slice(2))&&args[i+1]);values.set(args[i].slice(2),args[i+1])}
const get=(name:string)=>values.get(name)!
for(const flag of flags.filter(f=>f.endsWith('sha256')))assert(hex(get(flag)))
const bootstrap=parse(await readProtected(get('bootstrap'),32768,get('bootstrap-sha256')))
assert(bootstrap.format==='application-writer-bootstrap-v1'&&bootstrap.publicationAuthorized===false&&bootstrap.readyAuthorized===false)
const request=deploymentRequest(bootstrap.deploymentRequest),subject=bootstrap.verificationSubject
assert(subject.installationId===request.installationId&&hex(subject.publicKeySpkiSha256)&&sha(createPublicKey(subject.publicKeyPem).export({format:'der',type:'spki'}))===subject.publicKeySpkiSha256)
const pinned=legacyInspection||catalogueInspection?undefined:(args[0]==='reconcile'?reconciliationApproval:upgrade?upgradeApproval:approval)(parse(await readProtected(get('approval'),16384,get('approval-sha256'))))
const definition=legacyInspection?undefined:parse(await readProtected(get('definition'),4194304,get('definition-sha256')))
const transport=parse(await readProtected(get('transport'),16384,get('transport-sha256')))
const ca=await readProtected(get('ca'),65536,request.tls.caSha256)
const options=poolOptions(transport,request,ca)
if(!legacyInspection&&!catalogueInspection)await protectedDirectory(get('journal'))
await protectedDirectory(get('source-registry'))
const privateKeyFile=path.join(path.dirname(get('bootstrap')),'signing-private.pem')
if(writes){const key=await readProtected(privateKeyFile,8192);key.fill(0)}
// All explicit trust files are checked before app helper/PG imports. No .env URL is used.
// Existing source helper loads config/dotenv. Complete it BEFORE pg's first
// import so a newly loaded NODE_PG_FORCE_NATIVE cannot select another driver.
const {createProtectedDatabaseSourceBindingVerifier}=await import('./writer-profile/protected-source-registry.mjs')
assertJsDriverEnvironment(process.env)
const [{default:pg},{createConnectedPublisher,requireCurrentCatalogueDefinition},{collectSource44Catalogue,collectSource56Catalogue,collectSource57Catalogue,collectSource58Catalogue,approvedDefinition}]=await Promise.all([
import('pg'),import('./writer-profile/publisher.mjs'),import('./writer-profile/catalogue.mjs')])
assertJsDriverEnvironment(process.env)
const reviewedDefinition=legacyInspection?undefined:approvedDefinition(definition)
const collectCatalogues={44:collectSource44Catalogue,56:collectSource56Catalogue,57:collectSource57Catalogue,58:collectSource58Catalogue}
const collectCatalogue=collectCatalogues[reviewedDefinition&&'edition' in reviewedDefinition?reviewedDefinition.edition:44]
if(!legacyInspection&&!catalogueInspection){
assert.equal(reviewedDefinition!.definitionSha256,pinned!.definitionSha256)
if(args[0]!=='reconcile')requireCurrentCatalogueDefinition(pinned,reviewedDefinition)
}
const installation=Object.freeze({...subject,roles:Object.fromEntries(roleKeys.map(k=>[k,request.roles[k].signedOid])),roleBindings:request.roles,expectedSource:request.source,tls:Object.freeze({...request.tls})})
const sourcePin={registryDirectory:get('source-registry'),installationId:subject.installationId,publicKeySpkiSha256:get('source-spki-sha256'),currentHeadSha256:request.sourceHeadSha256}
const archiveDirectory=legacyExport?get('archive-directory'):undefined
let handoff
if(legacyHandoff){
const {verifyLegacyProbeHandoffIntent}=await import('../src/services/server-probe-legacy-handoff-inspection.js')
const directory=get('archive-directory'),maximum=64*1024*1024
const [archive,signedApproval,coldArchive,intent,operatorPublicKeyPem]=await Promise.all([
readProtected(path.join(directory,'legacy-probe.dump'),maximum),readProtected(path.join(directory,'legacy-probe-approval.json'),4096),
readProtected(path.join(directory,'legacy-probe-cold.dump'),maximum),
readProtected(path.join(directory,'legacy-probe-handoff-intent.json'),4096,get('handoff-intent-sha256')),
readProtected(path.join(sourcePin.registryDirectory,'operator-public.pem'),4096),
])
handoff=await verifyLegacyProbeHandoffIntent(sourcePin,{archive,signedApproval,coldArchive,intent,operatorPublicKeyPem})
}
// Use the same protected registry evidence for inspection and publication.
const verifier=createProtectedDatabaseSourceBindingVerifier(sourcePin)
async function connected(sourceVerifier:typeof verifier,deadlineAt:number){
const publisher=createConnectedPublisher(installation,(s:Parameters<typeof collectCatalogue>[0])=>collectCatalogue(s,installation),sourceVerifier,pinned,reviewedDefinition)
const pool=new pg.Pool(options)
// A pool-level async error never becomes raw stdout or a retry signal.
let asyncFailure=false;pool.on('error',()=>{asyncFailure=true})
let result,primary:unknown,failed=false
try{
const journalDirectory=get('journal')
if(legacyInspection)result=await publisher.inspectLegacyStorage(pool,{deadlineAt,archiveDirectory,custody:legacyCustody,handoff})
else if(catalogueInspection)result=await publisher.inspectCurrentCatalogue(pool,{deadlineAt})
else if(preflight)result=await publisher.preflightCurrentProfile(pool,{deadlineAt})
else if(args[0]==='reconcile')result=await publisher.reconcilePendingPublication(pool,{journalDirectory,deadlineAt})
else{
const publication={privateKeyFile,expectedHeadSha256:pinned.expectedHeadSha256,journalDirectory,validityMs:pinned.validityMs,deadlineAt}
result=upgrade?await publisher.upgradeCurrentProfile(pool,publication):await publisher.publishCurrentProfile(pool,publication)
}
}
catch(error){primary=error;failed=true}
try{await pool.end()}catch(error){primary??=error;failed=true}
if(legacyInspection&&result?.state==='observed'&&result.source.platformProtectionVerified===true&&!failed&&!asyncFailure){
const {installationId,sourceIdentityId,generation,ordinal,headSha256,bindingSha256}=result.source
if(legacyHandoff){assert(result.resolution);return {event:'database-legacy-handoff-inspection',...result.resolution,sourceActivationMatched:true,conversionAllowed:false}}
return {...(legacyExport?{archive:result.archive}:{}),...(result.lineageSnapshot?{lineageSnapshot:result.lineageSnapshot}:{}),event:'database-legacy-inspection',outcome:'observed',snapshot:result.snapshot,
source:{installationId,sourceIdentityId,generation,ordinal,headSha256,bindingSha256},sourceActivationMatched:true,
platformProtectionVerified:true,generationAuthenticated:false,allWriterDrainAuthenticated:false,
conversionAllowed:false,readyAuthorized:false,automaticReplay:false}
}
if(catalogueInspection&&result?.state==='observed'&&result.platformProtectionVerified===true&&!failed&&!asyncFailure){
const {state:_state,...catalogue}=result
return {event:'application-writer-source-catalogue-inspection',outcome:'observed',...catalogue,automaticReplay:false,writerAuthorized:false}
}
if(preflight&&result?.state==='matched'&&result.platformProtectionVerified===true&&!failed&&!asyncFailure)return {event:'application-writer-profile-preflight',outcome:'matched',epoch:result.epoch,headSha256:result.headSha256,notAfter:result.notAfter,sourceMatched:true,rolesMatched:true,catalogueMatched:true,platformProtectionVerified:true,writerAuthorized:false,cleanupUnconfirmed:false,automaticReplay:false,generationAuthenticated:false,readyAuthorized:false}
if(result?.outcome==='committed')return {event:'application-writer-profile-publication',outcome:'committed',epoch:result.epoch,headSha256:result.headSha256,notAfter:result.notAfter,
cleanupUnconfirmed:result.cleanupUnconfirmed||asyncFailure||failed,journalUnconfirmed:!!result.journalUnconfirmed,automaticReplay:false,generationAuthenticated:false,readyAuthorized:false}
if(args[0]==='reconcile'&&result&&!failed&&!asyncFailure&&['idle','confirmed','not-committed'].includes(result.state))return {event:'application-writer-profile-reconciliation',outcome:result.state,headSha256:result.headSha256??null,cleanupUnconfirmed:false,journalUnconfirmed:false,automaticReplay:false,generationAuthenticated:false,readyAuthorized:false}
throw primary??Error('Publisher terminal unconfirmed')
}
const deadlineAt=Date.now()+120000
if(!legacyInspection&&!catalogueInspection&&!activePreflight&&!writes)return connected(verifier,deadlineAt)
const {withActiveSource}=await import('./writer-profile/source-activation.mjs')
const publisherRole=request.roles.publisher.name
const expectedSource={...request.source,databaseOid:Number(request.source.databaseOid),sessionUser:publisherRole,currentUser:publisherRole}
const active=()=>withActiveSource({directory:get('activation-directory'),expectedSha256:get('activation-sha256'),sourcePin,expectedSource,tlsSpkiSha256:request.tls.spkiSha256,deadlineAt},verifier,
guardedVerifier=>connected(guardedVerifier,deadlineAt))
if(archiveDirectory)return withJournalLease(archiveDirectory,async()=>{
assert.deepEqual(await readdir(archiveDirectory),['publisher-lease.lock'],'Empty protected archive directory required')
const keyBytes=await readProtected(get('source-signing-key'),8192)
let key
try{key=createPrivateKey(keyBytes)}finally{keyBytes.fill(0)}
assert(key.asymmetricKeyType==='ed25519'&&sha(createPublicKey(key).export({type:'spki',format:'der'}))===sourcePin.publicKeySpkiSha256,'Source signer differs from deployment pin')
const {sourceBindingBytes,sourceBindingCanonical}=await import('../src/db/database-source-binding.js')
const {LEGACY_PROBE_ARCHIVE_APPROVAL_DOMAIN,LEGACY_PROBE_CUSTODY_APPROVAL_DOMAIN}=await import('../src/services/server-probe-legacy-archive-approval.js')
const result=await active()
assert(result.event==='database-legacy-inspection'&&Buffer.isBuffer(result.archive)&&Date.now()<deadlineAt)
const {archive,...receipt}=result
const base={...receipt.source,archiveSha256:sha(archive),storageSha256:receipt.snapshot.sha256}
assert(!legacyCustody||receipt.lineageSnapshot)
const body=legacyCustody?{format:'legacy-probe-custody-approval-v1',...base,lineageSha256:receipt.lineageSnapshot.sha256}
:{format:'legacy-probe-archive-approval-v1',...base}
const domain=legacyCustody?LEGACY_PROBE_CUSTODY_APPROVAL_DOMAIN:LEGACY_PROBE_ARCHIVE_APPROVAL_DOMAIN
const signedApproval=sourceBindingBytes({body,signature:sign(null,Buffer.from(domain+sourceBindingCanonical(body)),key).toString('base64url')})
const dumpFile='legacy-probe.dump',approvalFile='legacy-probe-approval.json'
await writeFile(path.join(archiveDirectory,dumpFile),archive,{flag:'wx',mode:0o600})
await writeFile(path.join(archiveDirectory,approvalFile),signedApproval,{flag:'wx',mode:0o600})
return {...receipt,event:legacyCustody?'database-legacy-custody':'database-legacy-export',outcome:'exported',dumpFile,approvalFile,archiveSha256:body.archiveSha256,approvalSha256:sha(signedApproval)}
})
const result=await active()
if(writes||legacyInspection||catalogueInspection)return result
assert.equal(result.event,'application-writer-profile-preflight')
return {...result,event:'application-writer-profile-source-preflight',sourceActivationMatched:true}
}
if(process.argv[1]&&import.meta.url===pathToFileURL(path.resolve(process.argv[1])).href){
try{const result=await main(process.argv.slice(2));console.log(JSON.stringify(result));if(result.cleanupUnconfirmed||result.journalUnconfirmed)process.exitCode=2}
catch(error){
const sourceCommand=sourceCommands.includes(process.argv[2])
const command=process.argv[2], code=(error as NodeJS.ErrnoException|null)?.code
const unknown=sourceCommand&&code==='SOURCE_ACTIVATION_TERMINAL_UNKNOWN'||['registry-enroll','restore-profile-enroll'].includes(command)&&code==='WRITER_REGISTRY_TERMINAL_UNKNOWN'||
command==='marker-fence-enroll'&&code==='MARKER_FENCE_TERMINAL_UNKNOWN'||command==='legacy-handoff-execute'&&code==='LEGACY_HANDOFF_EXECUTION_UNKNOWN'||
command==='legacy-handoff-adopt'&&code==='LEGACY_HANDOFF_ADOPTION_UNKNOWN'||command==='legacy-handoff-release'&&code==='LEGACY_HANDOFF_RELEASE_UNKNOWN'||
command==='source58-foundation-enroll'&&code==='SOURCE58_FOUNDATION_UNKNOWN'||command==='source57-admission-enroll'&&code==='SOURCE57_ADMISSION_UNKNOWN'
console.error(JSON.stringify({event:sourceCommand?(unknown?'database-source-activation-unknown':'database-source-activation-refused'):
command==='registry-inspect'?'application-writer-registry-inspection-refused':
command==='registry-enroll'?(unknown?'application-writer-registry-enrollment-unknown':'application-writer-registry-enrollment-refused'):
command==='restore-profile-enroll'?(unknown?'application-writer-restore-profile-enrollment-unknown':'application-writer-restore-profile-enrollment-refused'):
command==='source-catalogue-inspect'?'application-writer-source-catalogue-inspection-refused':
command==='marker-fence-enroll'?(unknown?'application-writer-marker-fence-enrollment-unknown':'application-writer-marker-fence-enrollment-refused'):
command==='legacy-export'?'database-legacy-export-refused':
command==='legacy-custody'?'database-legacy-custody-refused':
command==='legacy-handoff-inspect'?'database-legacy-handoff-inspection-refused':
command==='legacy-cold-verify'?'database-legacy-cold-proof-refused':
command==='legacy-handoff-execute'?(unknown?'database-legacy-handoff-execution-unknown':'database-legacy-handoff-execution-refused'):
command==='legacy-handoff-adopt'?(unknown?'database-legacy-handoff-adoption-unknown':'database-legacy-handoff-adoption-refused'):
command==='legacy-handoff-release'?(unknown?'database-legacy-handoff-release-unknown':'database-legacy-handoff-release-refused'):
command==='legacy-control-reference'?'database-legacy-control-reference-refused':
command==='legacy-source58-preflight'?'database-legacy-source58-preflight-refused':
command==='source58-foundation-enroll'?(unknown?'database-source58-foundation-unknown':'database-source58-foundation-refused'):
command==='source57-admission-enroll'?(unknown?'database-source57-admission-unknown':'database-source57-admission-refused'):
['maintenance-inspect','maintenance-resolve'].includes(process.argv[2])?'database-maintenance-command-refused':process.argv[2]==='legacy-inspect'?'database-legacy-inspection-refused':process.argv[2]==='source-preflight'?'application-writer-profile-source-preflight-refused':'application-writer-profile-publication-refused',automaticReplay:false,inspectPendingBeforeRetry:true,readyAuthorized:false}));process.exitCode=unknown?2:1
}
}