Files
MikrotikManager/backend/scripts/writer-profile/legacy-control-reference.mts
T

95 lines
6.6 KiB
TypeScript

import assert from 'node:assert/strict'
import type {PoolClient} from 'pg'
import {deploymentRequest} from '../database-writer-bootstrap-operator.mjs'
import {assertJsDriverEnvironment,poolOptions,retainPublisherTlsPeer} from './operator-contract.mjs'
import {readProtected,protectedDirectory} from './operator-files.mjs'
import {createProtectedDatabaseSourceBindingVerifier} from './protected-source-registry.mjs'
import {withActiveSource} from './source-activation.mjs'
import {mcpStateDirectory} from '../../src/modules/mcp/security.js'
import {captureDatabaseSourceObservation} from '../../src/db/database-source-observation.js'
import {provisionControlledSchemaReferenceOn,verifyLegacyControlReferenceApproval} from '../../src/db/controlled-schema-reference-core.js'
import {inspectApprovedLegacySource58Predecessor,verifyLegacySource58PreflightApproval} from '../../src/db/legacy-source58-transition.js'
import {SYSTEM_DATABASE_OPERATION_LOCK,SYSTEM_DATABASE_REQUEST_LOCK} from '../../src/db/operation-lock.js'
import type {SchemaInventoryClient} from '../../src/db/migration-schema-inventory.js'
const parse=(bytes:Buffer)=>JSON.parse(new TextDecoder('utf-8',{fatal:true}).decode(bytes))
export async function legacyControlReferenceMain(args:string[]) {
const preflight=args[0]==='legacy-source58-preflight'
const flags=['bootstrap','bootstrap-sha256','publisher-transport','publisher-transport-sha256',
'ca','source-registry','source-spki-sha256','activation-directory','activation-sha256','approval','approval-sha256','cold-public-key','cold-spki-sha256']
if(!preflight)flags.push('operator-transport','operator-transport-sha256')
assert((preflight||args[0]==='legacy-control-reference')&&args.length===1+2*flags.length)
assertJsDriverEnvironment(process.env)
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')))assert(/^[a-f0-9]{64}$/.test(get(flag)))
await protectedDirectory(mcpStateDirectory())
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={registryDirectory:get('source-registry'),installationId:request.installationId,
publicKeySpkiSha256:get('source-spki-sha256'),currentHeadSha256:request.sourceHeadSha256}
const [bytes,coldKey]=await Promise.all([readProtected(get('approval'),8192,get('approval-sha256')),readProtected(get('cold-public-key'),4096)])
const pins={coldSpkiSha256:get('cold-spki-sha256'),sourceSpkiSha256:sourcePin.publicKeySpkiSha256,
sourceHeadSha256:sourcePin.currentHeadSha256,sourceTlsSpkiSha256:request.tls.spkiSha256,roles:request.roles}
const approval=preflight?undefined:verifyLegacyControlReferenceApproval(bytes,coldKey,pins)
const transition=preflight?verifyLegacySource58PreflightApproval(bytes,coldKey,pins):undefined
const ca=await readProtected(get('ca'),65536,request.tls.caSha256)
const transport=async(role:'publisher'|'operator')=>poolOptions(parse(await readProtected(get(role+'-transport'),16384,get(role+'-transport-sha256'))),request,ca,role)
const [publisher,application]=await Promise.all([transport('publisher'),preflight?undefined:transport('operator')])
const {default:pg}=await import('pg')
assertJsDriverEnvironment(process.env)
const deadlineAt=Math.min((transition??approval)!.expiresAt,Date.now()+120000)
const expectedSource={...request.source,databaseOid:Number(request.source.databaseOid),sessionUser:request.roles.publisher.name,currentUser:request.roles.publisher.name}
return withActiveSource({directory:get('activation-directory'),expectedSha256:get('activation-sha256'),sourcePin,expectedSource,
tlsSpkiSha256:request.tls.spkiSha256,deadlineAt},createProtectedDatabaseSourceBindingVerifier(sourcePin),async verifier=>{
const source=new pg.Pool(publisher),liveApplication=application&&new pg.Pool(application)
let failed=false
for(const pool of [source,liveApplication])pool?.on('error',()=>{failed=true})
const retain=(client:PoolClient)=>{
const peer=retainPublisherTlsPeer(client,request.tls)
return ()=>{assert(!failed);peer()}
}
async function observe<T>(inspect?:(sql:SchemaInventoryClient)=>Promise<T>){
const client=await source.connect()
try{
const peer=retain(client),sql={query:async(text:string,parameters?:unknown[])=>{
peer();assert(Date.now()<deadlineAt);const result=await client.query(text,parameters);peer();assert(Date.now()<deadlineAt);return result
}}
if(inspect)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 Source58 drain unavailable')
}
await sql.query('BEGIN ISOLATION LEVEL REPEATABLE READ READ ONLY')
await sql.query("SET LOCAL TimeZone='UTC'; SET LOCAL DateStyle='ISO, YMD'")
assert.equal((await sql.query('SELECT oid::text AS oid FROM pg_catalog.pg_roles WHERE rolname=CURRENT_USER AND rolname=SESSION_USER')).rows[0]?.oid,request.roles.publisher.signedOid)
await verifier.verify(sql,await captureDatabaseSourceObservation(sql,{deadlineAt}),{deadlineAt})
let result:T|undefined
if(inspect){
await sql.query("SET LOCAL search_path=pg_catalog; SET LOCAL standard_conforming_strings=on; SET LOCAL statement_timeout='5s'")
result=await inspect(sql)
await verifier.verify(sql,await captureDatabaseSourceObservation(sql,{deadlineAt}),{deadlineAt})
}
assert.equal((await sql.query('ROLLBACK')).command,'ROLLBACK')
return result
}finally{client.release(true)}
}
try{
if(transition){
const observation=await observe(sql=>inspectApprovedLegacySource58Predecessor(sql,transition,deadlineAt))
return {event:'database-legacy-source58-preflight',outcome:'observed',...observation}
}
assert(approval&&application&&liveApplication)
await observe()
const result=await provisionControlledSchemaReferenceOn({approval,liveApplication,application,publisher,systemIdentifier:request.source.systemIdentifier,
sourceDatabaseOid:request.source.databaseOid,retain,beforePublish:async()=>{await observe()}})
return {event:'database-legacy-control-reference',outcome:'committed',...result}
}finally{await Promise.all([source.end(),liveApplication?.end()])}
})
}