import assert from 'node:assert/strict' import {randomBytes,randomUUID,sign,X509Certificate} from 'node:crypto' import {mkdir,readFile,writeFile} from 'node:fs/promises' import {join} from 'node:path' import pg from 'pg' export async function verifyOwnedLegacyExecution({main,live,options,directory,archiveDirectory,coldState,leafBytes,originalPin,fullArchive,signedApproval, adopt,release,tail,sourcePrivateKey,coldPrivateKey,coldPublicKey,proof,coldApprovalSha256}){ assert.equal(process.env.MMAPP_OWN_PROBE_LEGACY_0037,'true') const [{sourceBindingBytes,sourceBindingCanonical,sourceBindingSha256,readDatabaseSourceBindingRegistry},{readReviewedLegacyProbe0037}, {LEGACY_HANDOFF_EXECUTION_DOMAIN,LEGACY_HANDOFF_RELEASE_DOMAIN},{captureLegacyHandoffSchema},{LEGACY_PROBE_RELATIONS},{acquireDatabaseSchemaControl},{observation,exactHistory}, {MIGRATION_MANIFEST,migrationManifestDigest},{DATABASE_RESTORE_QUARANTINE_DDL},{createBootstrapMaterial}]=await Promise.all([ import('../src/db/database-source-binding.ts'),import('../src/db/legacy-probe-0037-body.ts'),import('./writer-profile/legacy-handoff-execution.mts'), import('../src/services/server-probe-legacy-handoff-inspection.ts'),import('../src/services/server-probe-legacy-source-inventory.ts'), import('../src/db/database-schema-control.ts'),import('../src/db/controlled-migration-history.ts'),import('../src/db/migration-manifest.ts'), import('../src/db/database-restore-quarantine.ts'),import('./database-writer-bootstrap-operator.mjs'), ]) const sha=sourceBindingSha256,store=async(path,data)=>{await writeFile(path,data,{flag:'wx',mode:0o600});return path} const publisher=options.user,operator='owned_commit_operator',control='owned_commit_control' const appPassword=tail?.password??randomBytes(24).toString('hex'),controlPassword=randomBytes(24).toString('hex') await live.query(DATABASE_RESTORE_QUARANTINE_DDL) if(tail)assert.equal(tail.user,operator) else await live.query(`CREATE ROLE ${operator} LOGIN PASSWORD '${appPassword}'; GRANT ${publisher} TO ${operator}; ALTER SCHEMA public OWNER TO ${operator}`) await live.query(`CREATE ROLE ${control} LOGIN PASSWORD '${controlPassword}'; CREATE ROLE owned_commit_runtime NOLOGIN; CREATE ROLE owned_commit_capture NOLOGIN; GRANT EXECUTE ON FUNCTION pg_catalog.pg_control_system() TO ${control},${operator}; GRANT pg_read_all_stats TO ${control}; GRANT USAGE ON SCHEMA mmapp_control TO ${control},${operator}; GRANT SELECT, UPDATE ON mmapp_control.database_schema_state,mmapp_control.database_restore_quarantine TO ${control},${operator}; GRANT SELECT, INSERT, UPDATE ON mmapp_control.database_schema_intents TO ${control},${operator}`) let runTail if(tail){ const [{pool},{executeControlledSqlMigrations},{LEGACY_CONTROL_REFERENCE_DOMAIN,readControlledSchemaReference},{verifyControlledSchemaCurrentState}]=await Promise.all([ import('../src/db/index.ts'),import('../src/db/controlled-migrations.ts'),import('../src/db/controlled-schema-reference-core.ts'), import('../src/db/controlled-schema-verification.ts'), ]) runTail=async(quarantined,handoff)=>{ const files=[],fileHashes=new Map(MIGRATION_MANIFEST.map(pin=>[pin.sha256,pin.file])) const originalConnect=pool.connect pool.connect=async()=>{ const owned=await originalConnect.call(pool),query=owned.query,release=owned.release owned.query=function(text,...args){ const file=typeof text==='string'&&fileHashes.get(sha(Buffer.from(text))) if(file)files.push(file) return query.call(this,text,...args) } owned.release=function(...args){owned.query=query;owned.release=release;return release.apply(this,args)} return owned } try{ if(quarantined){ await assert.rejects(executeControlledSqlMigrations(),error=>error.cause?.message==='Authenticated legacy migration release required') assert.deepEqual(files,[]) return } const result=await executeControlledSqlMigrations() assert.equal(result.completedFiles,MIGRATION_MANIFEST.length);assert.equal(result.ready,false) assert.deepEqual(files,MIGRATION_MANIFEST.slice(37).map(pin=>pin.file)) }finally{pool.connect=originalConnect} const referenceRoles={publisher:request.roles.publisher,operator:request.roles.operator,control:request.roles.control} const approvalBody={format:'legacy-control-reference-approval-v1',manifestSha256,sourceHeadSha256:source.headSha256, sourceTlsSpkiSha256:tls.spkiSha256,...referenceRoles,expiresAt:Date.now()+90000} const referenceArgs=async(body,filename)=>{ const bytes=sourceBindingBytes({body,signature:sign(null,Buffer.from(LEGACY_CONTROL_REFERENCE_DOMAIN+sourceBindingCanonical(body)),coldPrivateKey).toString('base64url')}) const flags=['--bootstrap','--bootstrap-sha256','--publisher-transport','--publisher-transport-sha256','--operator-transport','--operator-transport-sha256', '--ca','--source-registry','--source-spki-sha256','--activation-directory','--activation-sha256','--cold-public-key','--cold-spki-sha256'] return ['legacy-control-reference',...flags.flatMap(flag=>[flag,args[args.indexOf(flag)+1]]), '--approval',await store(join(directory,filename),bytes),'--approval-sha256',sha(bytes)] } await assert.rejects(main(await referenceArgs({...approvalBody,control:referenceRoles.operator},'wrong-control-reference.json')),/independent split-control approval/) const approved=await referenceArgs(approvalBody,'control-reference.json') const reference=await main(approved),current=await verifyControlledSchemaCurrentState() assert.equal(reference.splitControlApprovalSha256,approved.at(-1));assert.equal(reference.referenceDatabaseDropped,true) assert.equal((await readControlledSchemaReference()).sha256,current.schemaSha256) assert.equal(current.schemaSha256,reference.logicalSchemaSha256);assert.equal(current.referenceStatus,'matched');assert.equal(current.ready,false) assert.equal(current.currentPristineDataInvariants,false) await live.query('GRANT USAGE ON SCHEMA mmapp_control TO owned_commit_runtime') try{ const extra=await verifyControlledSchemaCurrentState() assert.equal(extra.referenceStatus,'different');assert.equal(extra.ready,false);assert.equal(extra.dataFacts.length,0) }finally{await live.query('REVOKE USAGE ON SCHEMA mmapp_control FROM owned_commit_runtime')} const [{LEGACY_SOURCE58_PREFLIGHT_DOMAIN},{RESTORE_WRITER_PROFILE_DEFINITION_SHA256}]=await Promise.all([ import('../src/db/legacy-source58-transition.ts'),import('../src/db/database-restore-quarantine-profile.ts'), ]) const targetCatalogueSha256=sha(Buffer.from('owned signed intended Source58 target; installation outside this preflight')) const target={format:'legacy-source58-preflight-approval-v1',manifestSha256,sourceHeadSha256:source.headSha256, sourceTlsSpkiSha256:tls.spkiSha256,currentSchemaSha256:reference.logicalSchemaSha256,...handoff, targetDefinitionSha256:RESTORE_WRITER_PROFILE_DEFINITION_SHA256,targetCatalogueSha256,roles:request.roles,expiresAt:Date.now()+90000} const preflightArgs=async(body,name)=>{ const bytes=sourceBindingBytes({body,signature:sign(null,Buffer.from(LEGACY_SOURCE58_PREFLIGHT_DOMAIN+sourceBindingCanonical(body)),coldPrivateKey).toString('base64url')}) const flags=approved.slice(1,-4),operatorAt=flags.indexOf('--operator-transport') flags.splice(operatorAt,4) return ['legacy-source58-preflight',...flags,'--approval',await store(join(directory,name),bytes),'--approval-sha256',sha(bytes)] } await assert.rejects(main(await preflightArgs({...target,releaseApprovalSha256:'0'.repeat(64)},'wrong-source58-target.json')),/exact authenticated release/) const observed=await main(await preflightArgs(target,'source58-target.json')) assert.equal(observed.authenticatedFiles,MIGRATION_MANIFEST.length);assert.equal(observed.transitionAuthorized,false);assert.equal(observed.readyAuthorized,false) assert.equal(observed.approvedTargetCatalogueSha256,targetCatalogueSha256) const expectedBlockers=['CONTROL_NAMESPACE_OWNER','QUARANTINE_OWNER','WRITER_REGISTRY_MISSING','REVIEWED_MARKER_FENCE_MISSING', 'ROLE_PROFILE_OPERATOR','ROLE_PROFILE_PUBLISHER','ROLE_PROFILE_RUNTIME','ROLE_PROFILE_CAPTURE'] assert.deepEqual(observed.blockers,expectedBlockers) return {manifestSha256,logicalSchemaSha256:current.schemaSha256,referenceLogicalSchemaSha256:reference.logicalSchemaSha256, referenceStatus:current.referenceStatus,splitControlApprovalSha256:reference.splitControlApprovalSha256,exactSplitControlCatalogueMatched:true, invalidRoleRefused:true,excessNamespaceAclRefused:true, referenceDatabaseDropped:reference.referenceDatabaseDropped, files,legacySource58PredecessorAttested:true,wrongReleasePinRefused:true,source58Blockers:observed.blockers, source58TransitionAuthorized:false,readyAuthorized:current.ready,historicalDataEquivalent:current.historicalDataEquivalent} } } const manifestSha256=migrationManifestDigest(),controller=await acquireDatabaseSchemaControl(live) try{ for(const migration of MIGRATION_MANIFEST.slice(0,36)){ const id=randomUUID(),begun=await controller.transition({type:'begin',id,kind:'migration',manifestSha256,artifactSha256:migration.sha256}) await controller.transition({type:'terminal',id,outcome:'observed-success',observationSha256:await observation(begun.state.intent,migration)}) } }finally{await controller.close()} const {body,pin}=await readReviewedLegacyProbe0037(),preview=new pg.Client({...options,user:operator,password:appPassword}) await preview.connect() let preSchemaSha256,postSchemaSha256 try{ await preview.query('BEGIN ISOLATION LEVEL REPEATABLE READ READ ONLY') preSchemaSha256=await captureLegacyHandoffSchema(preview,Date.now()+30000);await preview.query('ROLLBACK') await preview.query('BEGIN ISOLATION LEVEL REPEATABLE READ READ WRITE') await preview.query(`TRUNCATE TABLE ${LEGACY_PROBE_RELATIONS.map(name=>`ONLY public.${name}`).join(', ')} CONTINUE IDENTITY RESTRICT`) await preview.query(body);await preview.query('SET TRANSACTION READ ONLY') postSchemaSha256=await captureLegacyHandoffSchema(preview,Date.now()+30000) }finally{try{await preview.query('ROLLBACK')}finally{await preview.end()}} assert.notEqual(preSchemaSha256,postSchemaSha256) const source=await readDatabaseSourceBindingRegistry(originalPin),host='localhost',tls={serverName:host,caSha256:sha(leafBytes), spkiSha256:sha(new X509Certificate(leafBytes).publicKey.export({type:'spki',format:'der'}))} const names={publisher,operator,control,runtime:'owned_commit_runtime',capture:'owned_commit_capture'} const {rows:rows}=await live.query('SELECT rolname AS name,oid::text AS "signedOid" FROM pg_catalog.pg_roles WHERE rolname=ANY($1)',[Object.values(names)]) const request={format:'application-writer-bootstrap-request-v1',installationId:originalPin.installationId,sourceHeadSha256:originalPin.currentHeadSha256,tls, roles:Object.fromEntries(Object.entries(names).map(([scope,name])=>[scope,rows.find(role=>role.name===name)])),source:{systemIdentifier:source.body.source.systemIdentifier, databaseOid:String(source.body.source.databaseOid),databaseName:source.body.source.databaseName,serverVersionNum:source.body.source.serverVersionNum,inRecovery:false}} const bootstrap=sourceBindingBytes(createBootstrapMaterial(request,sha(sourceBindingBytes(request))).bootstrap) const activeDirectory=join(directory,'owned-execute-activation');await mkdir(activeDirectory,{mode:0o700}) const activation=sourceBindingBytes({format:'database-source-activation-v1',activationDirectory:activeDirectory,installationId:originalPin.installationId, sourceIdentityId:source.body.sourceIdentityId,status:'active',publicKeySpkiSha256:originalPin.publicKeySpkiSha256, generations:[{generation:source.body.generation,headSha256:source.headSha256,bindingSha256:source.head.bindingSha256,tlsSpkiSha256:tls.spkiSha256}]}) await store(join(activeDirectory,'source-activation.json'),activation) const operationId=randomUUID(),approvalBody={format:'legacy-probe-0037-execution-approval-v1',decision:'execute-and-commit',operationId, sourceHeadSha256:originalPin.currentHeadSha256,sourceTlsSpkiSha256:tls.spkiSha256,custodySha256:sha(signedApproval),coldArchiveSha256:sha(fullArchive), coldProofSha256:sha(proof),coldApprovalSha256,preSchemaSha256,postSchemaSha256,manifestSha256,migrationSha256:pin.sha256,protectedRuntimePaused:true,expiresAt:Date.now()+90000} const approved=sourceBindingBytes({body:approvalBody,signature:sign(null,Buffer.from(LEGACY_HANDOFF_EXECUTION_DOMAIN+sourceBindingCanonical(approvalBody)),coldPrivateKey).toString('base64url')}) await store(join(archiveDirectory,'legacy-probe-cold-proof.json'),proof) const shared=['--bootstrap',await store(join(directory,'execute-bootstrap.json'),bootstrap),'--bootstrap-sha256',sha(bootstrap), '--ca',await store(join(directory,'execute-ca.pem'),leafBytes),'--source-registry',originalPin.registryDirectory,'--source-spki-sha256',originalPin.publicKeySpkiSha256, '--activation-directory',activeDirectory,'--activation-sha256',sha(activation),'--archive-directory',archiveDirectory] const args=['legacy-handoff-execute',...shared,'--legacy-key-directory',coldState,'--source-signing-key',await store(join(directory,'execute-source-key.pem'),sourcePrivateKey.export({type:'pkcs8',format:'pem'})), '--approval',await store(join(directory,'execute-approval.json'),approved),'--approval-sha256',sha(approved),'--cold-public-key',await store(join(directory,'execute-cold-pub.pem'),coldPublicKey.export({type:'spki',format:'pem'})), '--cold-spki-sha256',sha(coldPublicKey.export({type:'spki',format:'der'}))] let publisherTransport,publisherSha for(const [scope,user,password] of [['publisher',publisher,options.password],['operator',operator,appPassword],['control',control,controlPassword]]){ const transport=sourceBindingBytes({host,port:options.port,database:options.database,user,password}) const file=await store(join(directory,'execute-'+scope+'.json'),transport);args.push('--'+scope+'-transport',file,'--'+scope+'-transport-sha256',sha(transport)) if(scope==='publisher'){publisherTransport=file;publisherSha=sha(transport)} } const {rows:[credential]}=await live.query('SELECT id,digest FROM public.mcp_credentials LIMIT 1') await live.query('UPDATE public.mcp_credentials SET digest=$2 WHERE id=$1',[credential.id,randomUUID()]) try{await assert.rejects(main(args),/Original credentials differ/)}finally{await live.query('UPDATE public.mcp_credentials SET digest=$2 WHERE id=$1',[credential.id,credential.digest])} assert.equal((await live.query('SELECT operation_id FROM mmapp_control.database_restore_quarantine')).rows[0].operation_id,null) const connect=pg.Pool.prototype.connect let applicationCommits=0 pg.Pool.prototype.connect=function(...args){ const connection=connect.apply(this,args) if(args.length||this.options.application_name!=='mmapp-legacy-handoff-owner')return connection return connection.then(client=>{ const query=client.query client.query=function(text,...params){ const result=query.call(this,text,...params) if(text!=='COMMIT')return result return result.then(()=>{applicationCommits++;throw Error('owned application COMMIT ACK lost')}) } return client }) } try{await assert.rejects(main(args),{code:'LEGACY_HANDOFF_EXECUTION_UNKNOWN'})}finally{pg.Pool.prototype.connect=connect} assert.equal(applicationCommits,1) const intent=await readFile(join(archiveDirectory,'legacy-probe-handoff-intent.json')) const unknown=JSON.parse(await readFile(join(archiveDirectory,'legacy-probe-handoff-application-unknown.json'),'utf8')) assert.equal(unknown.operationId,operationId);assert.equal(unknown.automaticReplay,false) const inspectArgs=['legacy-handoff-inspect',...shared,'--transport',publisherTransport,'--transport-sha256',publisherSha,'--handoff-intent-sha256',sha(intent)] const inspected=await main(inspectArgs) assert.equal(inspected.outcome,'committed');assert.equal(inspected.operationId,operationId);assert.equal(inspected.quarantineActive,true) assert.equal((await live.query('SELECT operation_id FROM mmapp_control.database_restore_quarantine')).rows[0].operation_id,operationId) await assert.rejects(main(args),{code:'DATABASE_RESTORE_QUARANTINE_UNAVAILABLE'}) assert.equal(applicationCommits,1) if(adopt){ assert.equal(inspected.adoptionRecorded,false) const adoptArgs=[...args];adoptArgs[0]='legacy-handoff-adopt' adoptArgs.splice(adoptArgs.indexOf('--source-signing-key'),2,'--handoff-intent-sha256',sha(intent)) let action=adoptArgs,unknownCode='LEGACY_HANDOFF_ADOPTION_UNKNOWN',releaseApprovalSha256 if(release){ const adopted=await main(adoptArgs) assert.equal(adopted.quarantineActive,true) if(runTail)await runTail(true) const signedRelease=async(adoptionSha256,name)=>{ const body={format:'legacy-probe-0037-release-approval-v1',decision:'release-migration-quarantine',operationId,intentSha256:sha(intent),adoptionSha256, sourceHeadSha256:originalPin.currentHeadSha256,sourceTlsSpkiSha256:tls.spkiSha256,coldArchiveSha256:sha(fullArchive), coldProofSha256:sha(proof),postSchemaSha256,manifestSha256,migrationSha256:pin.sha256,protectedRuntimePaused:true,expiresAt:Date.now()+90000} const bytes=sourceBindingBytes({body,signature:sign(null,Buffer.from(LEGACY_HANDOFF_RELEASE_DOMAIN+sourceBindingCanonical(body)),coldPrivateKey).toString('base64url')}) return ['legacy-handoff-release',...adoptArgs.slice(1),'--release-approval',await store(join(directory,name),bytes),'--release-approval-sha256',sha(bytes)] } await assert.rejects(main(await signedRelease('0'.repeat(64),'wrong-release.json')),/Exact committed legacy handoff phase/) assert.equal((await main(inspectArgs)).quarantineActive,true) action=await signedRelease(adopted.observationSha256,'release.json') releaseApprovalSha256=action.at(-1);unknownCode='LEGACY_HANDOFF_RELEASE_UNKNOWN' } let controlCommits=0 pg.Pool.prototype.connect=function(...parameters){ const connection=connect.apply(this,parameters) if(parameters.length||this.options.application_name!=='mmapp-writer-registry-enroll')return connection return connection.then(client=>{ const query=client.query client.query=function(text,...params){ const result=query.call(this,text,...params) if(text!=='COMMIT')return result return result.then(ack=>{if(++controlCommits===2)throw Error('owned adoption COMMIT ACK lost');return ack}) } return client }) } try{await assert.rejects(main(action),{code:unknownCode})}finally{pg.Pool.prototype.connect=connect} assert.equal(controlCommits,2) const readback=await main(inspectArgs) assert.equal(readback.adoptionRecorded,true);assert.equal(readback.outcome,'committed');assert.equal(readback.readyAuthorized,false) const {rows:[gate]}=await live.query('SELECT q.operation_id::text AS active,s.state FROM mmapp_control.database_restore_quarantine q CROSS JOIN mmapp_control.database_schema_state s WHERE q.id=1 AND s.id=1') const {rows:history}=await live.query('SELECT id::text,intent,terminal FROM mmapp_control.database_schema_intents') assert.equal(gate.active,release?null:operationId);assert.equal(gate.state.intent,null) assert.equal(gate.state.terminal.intent.artifactSha256,sha(intent)) assert.equal(await exactHistory(history,gate.state,manifestSha256,true),37) if(release){ assert.equal(readback.releaseRecorded,true);assert.equal(readback.quarantineActive,false);assert.equal(readback.releaseApprovalSha256,releaseApprovalSha256) assert.equal(gate.state.terminal.legacyRelease.approvalSha256,releaseApprovalSha256) const {rows:[head]}=await live.query('SELECT journal_prefix_bytes,journal_prefix_sha256 FROM mmapp_control.database_restore_quarantine') assert.deepEqual(head,{journal_prefix_bytes:null,journal_prefix_sha256:null}) const unknown=JSON.parse(await readFile(join(archiveDirectory,'legacy-probe-handoff-release-unknown.json'),'utf8')) assert.deepEqual(unknown,{format:'legacy-probe-0037-release-unknown-v1',operationId,intentSha256:sha(intent),automaticReplay:false}) await assert.rejects(main(action),/Legacy release attempt requires inspection/) if(runTail){ const markers=()=>live.query('SELECT id,xmin::text AS xmin,applied_at::text FROM public.schema_migrations ORDER BY id').then(result=>result.rows) const ledger=()=>live.query('SELECT id::text,xmin::text AS xmin,intent,terminal FROM mmapp_control.database_schema_intents ORDER BY id').then(result=>result.rows) const beforeMarkers=await markers(),beforeLedger=await ledger() const result=await runTail(false,{operationId,intentSha256:sha(intent),releaseApprovalSha256}) assert.deepEqual((await markers()).slice(0,37),beforeMarkers) const afterLedger=new Map((await ledger()).map(row=>[row.id,row])) assert(beforeLedger.every(row=>JSON.stringify(row)===JSON.stringify(afterLedger.get(row.id)))) assert.equal((await main(inspectArgs)).releaseRecorded,true) return {controlledLegacyTailCompleted:true,quarantinedDispatchRefused:true,originalReceiptsAndMarkersPreserved:true,...result} } return {legacyHandoffReleased:true,wrongAdoptionRefused:true,releaseAckLossObserved:true,exactAuthenticatedPrefix:37, replayRefused:true,restoreJournalUnchanged:true,readyAuthorized:false} } const unknown=JSON.parse(await readFile(join(archiveDirectory,'legacy-probe-handoff-adoption-unknown.json'),'utf8')) assert.deepEqual(unknown,{format:'legacy-probe-0037-adoption-unknown-v1',operationId,intentSha256:sha(intent),automaticReplay:false}) await assert.rejects(main(adoptArgs),/Legacy adoption attempt requires inspection/) return {legacyHandoffAdopted:true,adoptionAckLossObserved:true,exactAuthenticatedPrefix:37,replayRefused:true,quarantineCleared:false,readyAuthorized:false} } return {legacyHandoffExecuted:true,credentialDriftRefused:true,applicationAckLossObserved:true,committedReconciled:true,quarantineCleared:false,readyAuthorized:false} }