Files
MikrotikManager/backend/scripts/writer-profile/legacy-cold-verification.mts
T

96 lines
8.1 KiB
TypeScript

import assert from 'node:assert/strict'
import {createPrivateKey,createPublicKey,sign} from 'node:crypto'
import path from 'node:path'
import {z} from 'zod'
import {assertJsDriverEnvironment,poolOptions,retainPublisherTlsPeer} from './operator-contract.mjs'
import {readProtected,withJournalLease,writeFile,sha} from './operator-files.mjs'
import {readProtectedDatabaseSourceBindingRegistry} from './protected-source-registry.mjs'
import {sourceBindingBodySchema,sourceBindingBytes,sourceBindingCanonical} from '../../src/db/database-source-binding.js'
import {assertDatabaseSourceObservationCurrent,captureDatabaseSourceObservation} from '../../src/db/database-source-observation.js'
import {verifyLegacyProbeArchiveApproval} from '../../src/services/server-probe-legacy-archive-approval.js'
import {captureLegacyProbeCredentialDigest,LEGACY_COLD_DIGEST,LEGACY_PROBE_COLD_PROOF_DOMAIN,legacyColdProofBody} from '../../src/services/server-probe-legacy-cold-proof.js'
import {captureLegacyProbeLineage,captureLegacyProbeStorage} from '../../src/services/server-probe-legacy-source-inventory.js'
const approvalSchema=z.object({format:z.literal('legacy-probe-cold-verification-approval-v1'),installationId:z.uuid(),
sourceHeadSha256:LEGACY_COLD_DIGEST,sourceSignerSpkiSha256:LEGACY_COLD_DIGEST,custodySha256:LEGACY_COLD_DIGEST,coldArchiveSha256:LEGACY_COLD_DIGEST,
coldSignerSpkiSha256:LEGACY_COLD_DIGEST,keySha256:LEGACY_COLD_DIGEST,coldSource:sourceBindingBodySchema.shape.source,
coldRoleOid:z.string().regex(/^[1-9][0-9]{0,9}$/),tls:z.object({serverName:z.string().regex(/^[A-Za-z0-9][A-Za-z0-9.-]{0,252}$/),
caSha256:LEGACY_COLD_DIGEST,spkiSha256:LEGACY_COLD_DIGEST}).strict(),expiresAt:z.number().int().positive()}).strict()
const parse=(bytes:Buffer)=>JSON.parse(new TextDecoder('utf-8',{fatal:true}).decode(bytes))
export async function verifyLegacyColdMain(args:string[]){
assert(args[0]==='legacy-cold-verify');assertJsDriverEnvironment(process.env)
const flags=['approval','approval-sha256','transport','transport-sha256','ca','source-registry','archive-directory','legacy-key-directory','cold-signing-key','output-directory']
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)!
const approvalSha256=LEGACY_COLD_DIGEST.parse(get('approval-sha256'))
const approval=approvalSchema.parse(parse(await readProtected(get('approval'),8192,approvalSha256)))
assert(approval.expiresAt>Date.now()&&approval.expiresAt-Date.now()<=900000&&approval.coldSignerSpkiSha256!==approval.sourceSignerSpkiSha256)
const deadlineAt=Math.min(Date.now()+60000,approval.expiresAt),pin={registryDirectory:get('source-registry'),installationId:approval.installationId,
publicKeySpkiSha256:approval.sourceSignerSpkiSha256,currentHeadSha256:approval.sourceHeadSha256}
const directory=get('archive-directory'),maxArchive=64*1024*1024
const [ca,transport,archive,signedApproval,coldArchive,operatorPublicKeyPem]=await Promise.all([
readProtected(get('ca'),65536,approval.tls.caSha256),readProtected(get('transport'),16384,LEGACY_COLD_DIGEST.parse(get('transport-sha256'))),
readProtected(path.join(directory,'legacy-probe.dump'),maxArchive),readProtected(path.join(directory,'legacy-probe-approval.json'),4096,approval.custodySha256),
readProtected(path.join(directory,'legacy-probe-cold.dump'),maxArchive,approval.coldArchiveSha256),readProtected(path.join(pin.registryDirectory,'operator-public.pem'),4096),
])
const legacyKey=await readProtected(path.join(get('legacy-key-directory'),'encryption-key'),32,approval.keySha256)
try{assert.equal(legacyKey.length,32)}finally{legacyKey.fill(0)}
const keyBytes=await readProtected(get('cold-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'}))===approval.coldSignerSpkiSha256)
assert.equal(coldArchive.subarray(0,5).toString(),'PGDMP')
const custody=await verifyLegacyProbeArchiveApproval(pin,{archive,signedApproval,operatorPublicKeyPem})
assert.equal(custody.format,'legacy-probe-custody-approval-v1')
const original=await readProtectedDatabaseSourceBindingRegistry(pin,{deadlineAt})
const cold=approval.coldSource
assert(cold.systemIdentifier!==original.body.source.systemIdentifier||cold.databaseOid!==original.body.source.databaseOid,'Cold database must differ from the original source')
assert(cold.serverVersionNum>=180000&&cold.serverVersionNum<190000,'Cold verification requires PostgreSQL 18')
assert.equal(cold.currentUser,cold.sessionUser)
const options=poolOptions(parse(transport),{source:cold,roles:{publisher:{name:cold.sessionUser}},tls:approval.tls},ca)
const {default:pg}=await import('pg');assertJsDriverEnvironment(process.env)
return withJournalLease(get('output-directory'),async()=>{
const pool=new pg.Pool(options)
let failed=false;pool.on('error',()=>{failed=true})
let hashes
try{
const client=await pool.connect()
try{
const retained=retainPublisherTlsPeer(client,approval.tls)
const sql={query:async(text:string,values?:unknown[])=>{
assert(!failed&&Date.now()<deadlineAt);retained();const result=await client.query(text,values);retained();assert(!failed&&Date.now()<deadlineAt);return result
}}
await sql.query('BEGIN ISOLATION LEVEL REPEATABLE READ READ ONLY')
await sql.query("SET LOCAL TimeZone='UTC'; SET LOCAL DateStyle='ISO, YMD'; SET LOCAL search_path=pg_catalog")
const observation=await captureDatabaseSourceObservation(sql,{deadlineAt})
assert.equal(sourceBindingCanonical(observation.source),sourceBindingCanonical(cold))
const {rows:[actor]}=await sql.query(`SELECT r.oid::text AS oid,
NOT (r.rolsuper OR r.rolreplication OR r.rolbypassrls OR r.rolcreatedb OR r.rolcreaterole)
AND NOT pg_catalog.has_schema_privilege(r.oid,'public','CREATE')
AND NOT EXISTS(SELECT FROM pg_catalog.pg_class c WHERE c.relnamespace='public'::regnamespace AND CASE
WHEN c.relkind IN ('r','p','v','m','f') THEN pg_catalog.has_table_privilege(r.oid,c.oid,'INSERT, UPDATE, DELETE, TRUNCATE, TRIGGER')
OR pg_catalog.has_any_column_privilege(r.oid,c.oid,'INSERT, UPDATE')
WHEN c.relkind='S' THEN pg_catalog.has_sequence_privilege(r.oid,c.oid,'USAGE, UPDATE') ELSE false END) AS readonly
FROM pg_catalog.pg_roles r WHERE r.rolname=CURRENT_USER`)
assert(actor?.oid===approval.coldRoleOid&&actor.readonly===true,'Cold restore reader must have read-only privileges')
const storage=await captureLegacyProbeStorage(sql),lineage=await captureLegacyProbeLineage(sql)
assert(storage.rowCount>0&&storage.sha256===custody.storageSha256&&lineage.sha256===custody.lineageSha256,'Restored cold rows differ from signed custody')
hashes={storageSha256:storage.sha256,lineageSha256:lineage.sha256,credentialSha256:await captureLegacyProbeCredentialDigest(sql)}
await assertDatabaseSourceObservationCurrent(sql,observation,{deadlineAt})
assert.equal((await sql.query('ROLLBACK')).command,'ROLLBACK')
} finally {client.release(true)}
} finally {await pool.end()}
assert(!failed&&Date.now()<deadlineAt)
await readProtectedDatabaseSourceBindingRegistry(pin,{deadlineAt})
const body=legacyColdProofBody.parse({format:'legacy-probe-cold-proof-v1',approvalSha256,custodySha256:custody.approvalSha256,
coldArchiveSha256:approval.coldArchiveSha256,...hashes,keySha256:approval.keySha256,tlsSpkiSha256:approval.tls.spkiSha256,
coldSource:cold,roleOid:approval.coldRoleOid,observedAt:Date.now(),expiresAt:approval.expiresAt})
const receipt=sourceBindingBytes({body,signature:sign(null,Buffer.from(LEGACY_PROBE_COLD_PROOF_DOMAIN+sourceBindingCanonical(body)),key).toString('base64url')})
const file='legacy-probe-cold-proof.json'
await writeFile(path.join(get('output-directory'),file),receipt,{flag:'wx',mode:0o600})
return {event:'database-legacy-cold-proof',outcome:'observed',proofFile:file,proofSha256:sha(receipt),conversionAllowed:false,readyAuthorized:false}
})
}