Files
MikrotikManager/backend/scripts/writer-profile/legacy-handoff-execution.mts
T

244 lines
21 KiB
TypeScript

import assert from 'node:assert/strict'
import {createPrivateKey,createPublicKey,sign,verify} from 'node:crypto'
import path from 'node:path'
import {lstat} from 'node:fs/promises'
import {z} from 'zod'
import {assertJsDriverEnvironment,poolOptions,retainPublisherTlsPeer} from './operator-contract.mjs'
import {readProtected,writeFile,sha} from './operator-files.mjs'
import {createProtectedDatabaseSourceBindingVerifier} from './protected-source-registry.mjs'
import {withActiveSource} from './source-activation.mjs'
import {publishLegacyHandoffIntent} from './publisher.mjs'
import {deploymentRequest} from '../database-writer-bootstrap-operator.mjs'
import {acquireDatabaseSchemaControl} from '../../src/db/database-schema-control.js'
import {assertDatabaseRestoreQuarantineOpen} from '../../src/db/database-restore-quarantine.js'
import {captureDatabaseSourceObservation,assertDatabaseSourceObservationCurrent} from '../../src/db/database-source-observation.js'
import {sourceBindingBytes,sourceBindingCanonical} from '../../src/db/database-source-binding.js'
import {readReviewedLegacyProbe0037} from '../../src/db/legacy-probe-0037-body.js'
import {migrationManifestDigest} from '../../src/db/migration-manifest.js'
import {SYSTEM_DATABASE_OPERATION_LOCK,SYSTEM_DATABASE_REQUEST_LOCK} from '../../src/db/operation-lock.js'
import {LEGACY_COLD_DIGEST,verifyLegacyColdProof,captureLegacyProbeCredentialDigest} from '../../src/services/server-probe-legacy-cold-proof.js'
import {verifyLegacyProbeArchiveApproval} from '../../src/services/server-probe-legacy-archive-approval.js'
import {captureLegacyHandoffSchema,checkLegacyHandoffPostState,LEGACY_HANDOFF_ADOPTION_RELATIONS,LEGACY_PROBE_HANDOFF_DOMAIN,
verifyLegacyHandoffAdoption,verifyLegacyProbeHandoffIntent} from '../../src/services/server-probe-legacy-handoff-inspection.js'
import {captureLegacyProbeStorage,LEGACY_PROBE_CUSTODY_RELATIONS,LEGACY_PROBE_RELATIONS} from '../../src/services/server-probe-legacy-source-inventory.js'
import type {PoolClient} from 'pg'
export const LEGACY_HANDOFF_EXECUTION_DOMAIN='mmapp:legacy-probe-0037-execute:ed25519:v1\n'
export const LEGACY_HANDOFF_RELEASE_DOMAIN='mmapp:legacy-probe-0037-release:ed25519:v1\n'
const hash=LEGACY_COLD_DIGEST
const approvalEnvelope=z.object({body:z.object({format:z.literal('legacy-probe-0037-execution-approval-v1'),decision:z.literal('execute-and-commit'),
operationId:z.uuidv4(),sourceHeadSha256:hash,sourceTlsSpkiSha256:hash,custodySha256:hash,coldArchiveSha256:hash,coldProofSha256:hash,
coldApprovalSha256:hash,preSchemaSha256:hash,postSchemaSha256:hash,manifestSha256:hash,migrationSha256:hash,
protectedRuntimePaused:z.literal(true),expiresAt:z.number().int().positive()}).strict(),signature:z.string().regex(/^[A-Za-z0-9_-]{86}$/)}).strict()
const releaseEnvelope=approvalEnvelope.extend({body:z.object({format:z.literal('legacy-probe-0037-release-approval-v1'),
decision:z.literal('release-migration-quarantine'),operationId:z.uuidv4(),intentSha256:hash,adoptionSha256:hash,sourceHeadSha256:hash,
sourceTlsSpkiSha256:hash,coldArchiveSha256:hash,coldProofSha256:hash,postSchemaSha256:hash,manifestSha256:hash,migrationSha256:hash,
protectedRuntimePaused:z.literal(true),expiresAt:z.number().int().positive()}).strict()})
const parse=(raw:Buffer)=>JSON.parse(new TextDecoder('utf-8',{fatal:true}).decode(raw))
const pendingUnknown=()=>Object.assign(Error('Legacy 0037 outcome must be inspected'),{code:'LEGACY_HANDOFF_EXECUTION_UNKNOWN'})
export async function legacyHandoffExecuteMain(args:string[]){
const release=args[0]==='legacy-handoff-release',adopt=release||args[0]==='legacy-handoff-adopt'
assert(adopt||args[0]==='legacy-handoff-execute');assertJsDriverEnvironment(process.env)
const flags=['bootstrap','bootstrap-sha256','publisher-transport','publisher-transport-sha256','operator-transport','operator-transport-sha256',
'control-transport','control-transport-sha256','ca','source-registry','source-spki-sha256','activation-directory','activation-sha256',
'archive-directory','legacy-key-directory','approval','approval-sha256','cold-public-key','cold-spki-sha256',adopt?'handoff-intent-sha256':'source-signing-key']
if(release)flags.push('release-approval','release-approval-sha256')
assert.equal(args.length,1+flags.length*2)
const values=new Map<string,string>()
for(let i=1;i<args.length;i+=2){const name=args[i].slice(2);assert(args[i].startsWith('--')&&flags.includes(name)&&!values.has(name)&&args[i+1]);values.set(name,args[i+1])}
const get=(name:string)=>values.get(name)!
for(const flag of flags.filter(name=>name.endsWith('sha256')))hash.parse(get(flag))
const bootstrap=parse(await readProtected(get('bootstrap'),32768,get('bootstrap-sha256'))),request=deploymentRequest(bootstrap.deploymentRequest)
assert(bootstrap.format==='application-writer-bootstrap-v1'&&bootstrap.publicationAuthorized===false&&bootstrap.readyAuthorized===false)
const sourcePin=Object.freeze({registryDirectory:get('source-registry'),installationId:request.installationId,
publicKeySpkiSha256:get('source-spki-sha256'),currentHeadSha256:request.sourceHeadSha256})
const coldSignerSpkiSha256=get('cold-spki-sha256'),coldPublicKey=await readProtected(get('cold-public-key'),4096)
const approvingKey=createPublicKey(coldPublicKey)
assert(coldSignerSpkiSha256!==sourcePin.publicKeySpkiSha256&&approvingKey.asymmetricKeyType==='ed25519'&&sha(approvingKey.export({type:'spki',format:'der'}))===coldSignerSpkiSha256)
const approvalBytes=await readProtected(get('approval'),8192,get('approval-sha256')),raw=parse(approvalBytes)
const {body:approval,signature}=approvalEnvelope.parse(raw),signatureBytes=Buffer.from(signature,'base64url')
assert(sourceBindingBytes(raw).equals(approvalBytes)&&signatureBytes.toString('base64url')===signature&&verify(null,
Buffer.from(LEGACY_HANDOFF_EXECUTION_DOMAIN+sourceBindingCanonical(approval)),approvingKey,signatureBytes),'Independent exact 0037 execution approval required')
const {body:migration,pin}=await readReviewedLegacyProbe0037()
assert((adopt||approval.expiresAt>Date.now()&&approval.expiresAt-Date.now()<=900000)&&approval.migrationSha256===pin.sha256&&approval.manifestSha256===migrationManifestDigest()&&
approval.sourceHeadSha256===sourcePin.currentHeadSha256&&approval.sourceTlsSpkiSha256===request.tls.spkiSha256)
const archiveDirectory=get('archive-directory'),max=64*1024*1024
const [archive,signedApproval,coldProof,operatorPublicKeyPem]=await Promise.all([
readProtected(path.join(archiveDirectory,'legacy-probe.dump'),max),readProtected(path.join(archiveDirectory,'legacy-probe-approval.json'),4096,approval.custodySha256),
readProtected(path.join(archiveDirectory,'legacy-probe-cold-proof.json'),8192,approval.coldProofSha256),readProtected(path.join(sourcePin.registryDirectory,'operator-public.pem'),4096),
])
const coldArchive=await readProtected(path.join(archiveDirectory,'legacy-probe-cold.dump'),max,approval.coldArchiveSha256)
const custody=await verifyLegacyProbeArchiveApproval(sourcePin,{archive,signedApproval,operatorPublicKeyPem})
assert.equal(custody.format,'legacy-probe-custody-approval-v1')
const coldPin={publicKeyPem:coldPublicKey,signerSpkiSha256:coldSignerSpkiSha256,sourceSignerSpkiSha256:sourcePin.publicKeySpkiSha256,
approvalSha256:approval.coldApprovalSha256,custodySha256:approval.custodySha256,coldArchiveSha256:approval.coldArchiveSha256,
storageSha256:custody.storageSha256,lineageSha256:custody.lineageSha256}
const coldObservedAt=adopt?parse(coldProof)?.body?.observedAt:undefined
if(adopt)assert(Number.isSafeInteger(coldObservedAt))
const cold=verifyLegacyColdProof(coldProof,coldPin,coldObservedAt)
const legacyKey=await readProtected(path.join(get('legacy-key-directory'),'encryption-key'),32,cold.keySha256)
try{assert.equal(legacyKey.length,32)}finally{legacyKey.fill(0)}
let key,adopting
let releaseProof:{approvalSha256:string;adoptionSha256:string}|undefined,releaseExpiresAt=Infinity
const stage=release?'release':'adoption'
const adoptionUnknownFile=path.join(archiveDirectory,`legacy-probe-handoff-${stage}-unknown.json`)
const adoptionAttemptFile=path.join(archiveDirectory,`legacy-probe-handoff-${stage}-attempt.json`)
if(adopt){
for(const file of [adoptionAttemptFile,adoptionUnknownFile]){
try{await lstat(file);throw Error(`Legacy ${stage} attempt requires inspection`)}catch(error){if((error as NodeJS.ErrnoException).code!=='ENOENT')throw error}
}
const intent=await readProtected(path.join(archiveDirectory,'legacy-probe-handoff-intent.json'),4096,get('handoff-intent-sha256'))
adopting=await verifyLegacyProbeHandoffIntent(sourcePin,{archive,signedApproval,coldArchive,intent,operatorPublicKeyPem})
assert(adopting.operationId===approval.operationId&&adopting.approvalSha256===approval.custodySha256&&adopting.coldArchiveSha256===approval.coldArchiveSha256&&
adopting.preSchemaSha256===approval.preSchemaSha256&&adopting.postSchemaSha256===approval.postSchemaSha256&&
adopting.executionApprovalSha256===sha(approvalBytes)&&adopting.coldProofSha256===approval.coldProofSha256,'Execution approval differs from durable handoff')
if(release){
const bytes=await readProtected(get('release-approval'),8192,get('release-approval-sha256')),raw=parse(bytes)
const {body,signature}=releaseEnvelope.parse(raw),sig=Buffer.from(signature,'base64url')
assert(sourceBindingBytes(raw).equals(bytes)&&sig.toString('base64url')===signature&&verify(null,
Buffer.from(LEGACY_HANDOFF_RELEASE_DOMAIN+sourceBindingCanonical(body)),approvingKey,sig),'Independent signed release approval required')
assert(body.operationId===adopting.operationId&&body.intentSha256===adopting.intentSha256&&body.sourceHeadSha256===approval.sourceHeadSha256&&
body.sourceTlsSpkiSha256===approval.sourceTlsSpkiSha256&&body.coldArchiveSha256===approval.coldArchiveSha256&&body.coldProofSha256===approval.coldProofSha256&&
body.postSchemaSha256===approval.postSchemaSha256&&body.manifestSha256===approval.manifestSha256&&body.migrationSha256===approval.migrationSha256&&
body.expiresAt>Date.now()&&body.expiresAt-Date.now()<=900000,'Release approval differs from exact legacy handoff')
releaseProof={approvalSha256:sha(bytes),adoptionSha256:body.adoptionSha256};releaseExpiresAt=body.expiresAt
}
}else{
const keyBytes=await readProtected(get('source-signing-key'),8192)
try{key=createPrivateKey(keyBytes)}finally{keyBytes.fill(0)}
assert(key.asymmetricKeyType==='ed25519'&&sha(createPublicKey(key).export({type:'spki',format:'der'}))===sourcePin.publicKeySpkiSha256)
}
const ca=await readProtected(get('ca'),65536,request.tls.caSha256)
const transport=async(role:'publisher'|'operator'|'control')=>poolOptions(parse(await readProtected(get(role+'-transport'),16384,get(role+'-transport-sha256'))),request,ca,role)
const [publisherOptions,applicationOptions,controlOptions]=await Promise.all([transport('publisher'),transport('operator'),transport('control')])
const {default:pg}=await import('pg');assertJsDriverEnvironment(process.env)
const deadlineAt=adopt?Math.min(Date.now()+120000,releaseExpiresAt):Math.min(Date.now()+120000,approval.expiresAt,cold.expiresAt)
const expectedSource={...request.source,databaseOid:Number(request.source.databaseOid),sessionUser:request.roles.publisher.name,currentUser:request.roles.publisher.name}
const verifier=createProtectedDatabaseSourceBindingVerifier(sourcePin)
return withActiveSource({directory:get('activation-directory'),expectedSha256:get('activation-sha256'),sourcePin,expectedSource,
tlsSpkiSha256:request.tls.spkiSha256,deadlineAt},verifier,async sourceVerifier=>{
const publisher=new pg.Pool(publisherOptions),application=new pg.Pool({...applicationOptions,application_name:'mmapp-legacy-handoff-owner'}),controlPool=new pg.Pool(controlOptions)
let failed=false,committed=false,commitSent=false,controlUnknown=false,recorded=false,app:PoolClient|undefined,control
let intentSha256:string|undefined,cleanupUnconfirmed=false
for(const pool of [publisher,application,controlPool])pool.on('error',()=>{failed=true})
const fence=()=>assert(!failed&&Date.now()<deadlineAt,'Legacy handoff lifetime ended')
const retainedSql=(client:PoolClient)=>{
const retained=retainPublisherTlsPeer(client,request.tls)
return {query:async(text:string,values?:unknown[])=>{fence();retained();const result=await client.query(text,values);retained();fence();return result}}
}
const assertRole=async(sql:ReturnType<typeof retainedSql>,role:'publisher'|'operator'|'control')=>{
const {rows:[actual]}=await sql.query(`SELECT r.rolname AS actor,r.oid::text AS role_oid,d.oid::text AS db_oid,d.datname AS db_name,
c.system_identifier::text AS system,pg_catalog.current_setting('server_version_num')::int AS version,pg_catalog.pg_is_in_recovery() AS recovery
FROM pg_catalog.pg_roles r CROSS JOIN pg_catalog.pg_database d CROSS JOIN pg_catalog.pg_control_system() c
WHERE r.rolname=CURRENT_USER AND r.rolname=SESSION_USER AND d.datname=pg_catalog.current_database()`)
assert.deepEqual(actual,{actor:request.roles[role].name,role_oid:request.roles[role].signedOid,db_oid:request.source.databaseOid,
db_name:request.source.databaseName,system:request.source.systemIdentifier,version:request.source.serverVersionNum,recovery:false})
}
const observePublisher=async<T,>(checkSchema:boolean,inspect?:(sql:ReturnType<typeof retainedSql>)=>Promise<T>)=>{
const client=await publisher.connect()
try{
const sql=retainedSql(client)
await assertRole(sql,'publisher')
await sql.query('BEGIN ISOLATION LEVEL REPEATABLE READ READ ONLY')
await sql.query("SET LOCAL TimeZone='UTC'; SET LOCAL DateStyle='ISO, YMD'")
const observation=await captureDatabaseSourceObservation(sql,{deadlineAt})
await sourceVerifier.verify(sql,observation,{deadlineAt})
if(checkSchema)assert.equal(await captureLegacyHandoffSchema(sql,deadlineAt),approval.preSchemaSha256,'Original 0036 catalogue differs from reviewed approval')
const result=await inspect?.(sql)
await assertDatabaseSourceObservationCurrent(sql,observation,{deadlineAt})
assert.equal((await sql.query('ROLLBACK')).command,'ROLLBACK')
return result
}finally{client.release(true)}
}
try{
control=await acquireDatabaseSchemaControl({async connect(){
const client=await controlPool.connect()
try{
const sql=retainedSql(client);await assertRole(sql,'control')
if(adopting){
const {rows:[gate]}=await sql.query(`SELECT q.operation_id::text AS active,s.state->'intent'->>'id' AS pending,
s.state->'terminal'->'intent'->>'id' AS adopted
FROM mmapp_control.database_restore_quarantine q CROSS JOIN mmapp_control.database_schema_state s WHERE q.id=1 AND s.id=1`)
assert(gate?.active===adopting.operationId&&(release?gate.pending===null&&gate.adopted===adopting.operationId:gate.pending===adopting.operationId),'Exact quarantined legacy phase required')
}else await assertDatabaseRestoreQuarantineOpen(sql)
return {...sql,release:(destroy?:boolean)=>client.release(destroy)}
}catch(error){client.release(true);throw error}
}})
app=await application.connect();const sql=retainedSql(app)
await assertRole(sql,'operator')
for(const lock of [SYSTEM_DATABASE_REQUEST_LOCK,SYSTEM_DATABASE_OPERATION_LOCK,8723110]){
const {rows:[row]}=await sql.query('SELECT pg_catalog.pg_try_advisory_lock($1::bigint) AS held',[lock]);assert.equal(row.held,true,'Legacy exclusive drain unavailable')
}
await sql.query('BEGIN ISOLATION LEVEL REPEATABLE READ READ WRITE')
if(adopting){
await sql.query(`LOCK TABLE ${LEGACY_HANDOFF_ADOPTION_RELATIONS.map(name=>`public.${name}`).join(', ')} IN SHARE MODE NOWAIT`)
const adoption=await observePublisher(false,observer=>verifyLegacyHandoffAdoption(sql,observer,adopting,deadlineAt,releaseProof))
assert(adoption);await observePublisher(false)
assert(adoption.appliedAt<=Date.now()&&adoption.appliedAt<=approval.expiresAt&&approval.expiresAt-adoption.appliedAt<=900000,'Original approval was outside its signed execution window')
verifyLegacyColdProof(coldProof,coldPin,adoption.appliedAt)
await writeFile(adoptionAttemptFile,sourceBindingBytes({format:`legacy-probe-0037-${stage}-attempt-v1`,
operationId:adopting.operationId,intentSha256:adopting.intentSha256,automaticReplay:false}),{flag:'wx',mode:0o600})
try{
const receipt=release?await control.releaseLegacyHandoff(adoption):await control.adoptLegacyHandoff(adoption)
const terminal=receipt.state.terminal!
return {event:`database-legacy-handoff-${stage}`,outcome:'committed',operationId:adopting.operationId,intentSha256:adopting.intentSha256,
observationSha256:terminal.legacyRelease?.observationSha256??terminal.observationSha256,quarantineActive:!release,automaticReplay:false,readyAuthorized:false}
}catch(error){
if((error as {outcomeUnknown?:boolean})?.outcomeUnknown===true){
const value=sourceBindingBytes({format:`legacy-probe-0037-${stage}-unknown-v1`,operationId:adopting.operationId,intentSha256:adopting.intentSha256,automaticReplay:false})
try{await writeFile(adoptionUnknownFile,value,{flag:'wx',mode:0o600})}catch{/* Preserve the existing intent and control history. */}
throw Object.assign(Error(`Legacy 0037 ${stage} must be inspected`),{code:release?'LEGACY_HANDOFF_RELEASE_UNKNOWN':'LEGACY_HANDOFF_ADOPTION_UNKNOWN'})
}
throw error
}
}
const historyTables=[...LEGACY_PROBE_CUSTODY_RELATIONS,'mcp_credentials','mcp_settings'].sort().map(name=>`public.${name}`).join(', ')
await sql.query(`LOCK TABLE ${historyTables} IN SHARE MODE NOWAIT`)
await observePublisher(true)
await sql.query(`LOCK TABLE ${historyTables} IN ACCESS EXCLUSIVE MODE NOWAIT`)
await captureLegacyProbeStorage(sql)
assert.equal(await captureLegacyProbeCredentialDigest(sql),cold.credentialSha256,'Original credentials differ from verified cold rows')
const {rows:[triggers]}=await sql.query(`SELECT EXISTS(SELECT FROM pg_catalog.pg_trigger t JOIN pg_catalog.pg_class c ON c.oid=t.tgrelid
WHERE c.relnamespace='public'::regnamespace AND c.relname::text=ANY($1::text[]) AND (t.tgtype::int & 32)<>0) AS truncate_trigger`,[LEGACY_PROBE_RELATIONS])
assert.equal(triggers.truncate_trigger,false,'Unreviewed diagnostic TRUNCATE trigger')
const {rows:[{xid}]}=await sql.query('SELECT pg_catalog.pg_current_xact_id()::text AS xid')
const intent={format:'legacy-probe-0037-handoff-intent-v1',operationId:approval.operationId,applicationXid:xid,
approvalSha256:approval.custodySha256,coldArchiveSha256:approval.coldArchiveSha256,preSchemaSha256:approval.preSchemaSha256,
postSchemaSha256:approval.postSchemaSha256,manifestSha256:approval.manifestSha256,migrationSha256:approval.migrationSha256,
executionApprovalSha256:sha(approvalBytes),coldProofSha256:approval.coldProofSha256}
assert(key)
const signedIntent=sourceBindingBytes({body:intent,signature:sign(null,Buffer.from(LEGACY_PROBE_HANDOFF_DOMAIN+sourceBindingCanonical(intent)),key).toString('base64url')})
intentSha256=sha(signedIntent)
try{await publishLegacyHandoffIntent({application:app,control,sourcePin,tlsPin:request.tls,archiveDirectory,signedIntent,deadlineAt});recorded=true}
catch(error){const state=error as {outcomeUnknown?:boolean;controlAcknowledged?:boolean};controlUnknown=state?.outcomeUnknown===true||state?.controlAcknowledged===true;throw error}
await sql.query("SET LOCAL search_path=public,pg_catalog,pg_temp; SET LOCAL synchronous_commit=on")
await sql.query(`TRUNCATE TABLE ${LEGACY_PROBE_RELATIONS.map(name=>`ONLY public.${name}`).join(', ')} CONTINUE IDENTITY RESTRICT`)
await sql.query(migration)
await sql.query('SET TRANSACTION READ ONLY')
assert(await checkLegacyHandoffPostState(sql,approval.postSchemaSha256,xid,deadlineAt),'Exact 0037 post-state refused')
await observePublisher(false)
fence();commitSent=true
// Observe the physical acknowledgement before any subsequent check can fail.
assert.equal((await app.query('COMMIT')).command,'COMMIT');committed=true
}catch(error){
if(!commitSent&&app){try{await app.query('ROLLBACK')}catch{/* Destroy the checked-out application backend. */}}
if(commitSent||controlUnknown||recorded){
if(commitSent){
const value=sourceBindingBytes({format:'legacy-probe-0037-application-unknown-v1',operationId:approval.operationId,intentSha256,automaticReplay:false})
try{await writeFile(path.join(archiveDirectory,'legacy-probe-handoff-application-unknown.json'),value,{flag:'wx',mode:0o600})}catch{/* Existing protected intent remains the recovery reference. */}
}
throw pendingUnknown()
}
throw error
}finally{
try{await control?.close()}catch{cleanupUnconfirmed=true}
try{app?.release(true)}catch{cleanupUnconfirmed=true}
const closed=await Promise.allSettled([publisher.end(),application.end(),controlPool.end()]);cleanupUnconfirmed ||= closed.some(result=>result.status==='rejected')
}
assert(recorded&&committed)
return {event:'database-legacy-handoff-execution',outcome:'committed',operationId:approval.operationId,intentSha256,quarantineActive:true,
cleanupUnconfirmed:cleanupUnconfirmed||failed,automaticReplay:false,readyAuthorized:false}
})
}