import assert from 'node:assert/strict' import {createPublicKey,verify} from 'node:crypto' import type {PoolClient} from 'pg' import {z} from 'zod' import {deploymentRequest} from '../database-writer-bootstrap-operator.mjs' import {assertJsDriverEnvironment,poolOptions,retainPublisherTlsPeer} from './operator-contract.mjs' import {readProtected,sha} from './operator-files.mjs' import {createProtectedDatabaseSourceBindingVerifier} from './protected-source-registry.mjs' import {withActiveSource} from './source-activation.mjs' import {BUILD57_PROVENANCE,FIXED57_ROLE_TEMPLATE} from './fixed57-build-definition.js' import {BUILD58_PROVENANCE} from './fixed58-build-definition.js' import {enrollWriterRegistryInTransaction,writerRegistryEnrollmentSql} from './registry-enrollment.mjs' import {reviewedSource57Admission} from './source57-admission-plan.mjs' import {collectSource57Catalogue} from './catalogue.mjs' import {canonical} from './application-writer-profile-canonical.js' import {readProtectedRegistryStructureData} from '../../src/db/application-writer-profile-registry-structure.js' import {captureDatabaseSourceObservation} from '../../src/db/database-source-observation.js' import {sourceBindingBytes,sourceBindingCanonical} from '../../src/db/database-source-binding.js' import {captureMigrationSchema} from '../../src/db/migration-schema-inventory.js' import {MIGRATION_MANIFEST,migrationManifestDigest} from '../../src/db/migration-manifest.js' import {SYSTEM_DATABASE_OPERATION_LOCK,SYSTEM_DATABASE_REQUEST_LOCK} from '../../src/db/operation-lock.js' export const SOURCE58_FOUNDATION_DOMAIN='mmapp:source58-foundation:ed25519:v1\n' export const SOURCE57_ADMISSION_DOMAIN='mmapp:source57-admission:ed25519:v1\n' const hash=z.string().regex(/^[a-f0-9]{64}$/) const fields={ bootstrapSha256:hash,sourceHeadSha256:hash,sourceTlsSpkiSha256:hash,manifestSha256:hash,definitionSha256:hash, preSchemaSha256:hash,expiresAt:z.number().int().positive(), } const approval=z.object({body:z.discriminatedUnion('format',[ z.object({...fields,format:z.literal('source58-foundation-approval-v1'),decision:z.literal('install-foundations'),foundationSha256:hash}).strict(), z.object({...fields,format:z.literal('source57-admission-approval-v1'),decision:z.literal('install-admission'),admissionSha256:hash}).strict(), ]), signature:z.string().regex(/^[A-Za-z0-9_-]{86}$/)}).strict() const parse=(bytes:Buffer)=>JSON.parse(new TextDecoder('utf-8',{fatal:true}).decode(bytes)) type Request=ReturnType type Sql={query:>(text:string,values?:unknown[])=>Promise<{rows:T[];command?:string}>} const keys=['candidate_require_preadmission','candidate_truncate_preadmitted','candidate_operator_ddl','server_partition_writer_guard'] const sorted=(rows:Record[])=>rows.map(sourceBindingCanonical).sort() const withSortedAcl=(row:Record)=>({...row,acl:Array.isArray(row.acl)?[...row.acl].sort():row.acl}) const identifier=(name:string)=>{assert(/^[a-z_][a-z0-9_]{0,62}$/.test(name));return '"'+name+'"'} const bind=(text:string,roles:Request['roles'])=>text.replace(/@mm-role:(operator|control|publisher|runtime|capture)@/g,(_,scope)=>roles[scope].name) function reviewedFoundation(roles:Request['roles']){ const expected=FIXED57_ROLE_TEMPLATE.functions.filter(row=>keys.includes(String(row.proname))).map(row=>JSON.parse(bind(sourceBindingCanonical(row),roles))) const publicGuard=expected.find(row=>row.namespace==='public') const functions=keys.slice(0,3).map(name=>expected.find(row=>row.proname===name).definition.replace('CREATE OR REPLACE FUNCTION ','CREATE FUNCTION ')) const schemas=FIXED57_ROLE_TEMPLATE.schemas.map(row=>JSON.parse(bind(sourceBindingCanonical(row),roles))) const events=FIXED57_ROLE_TEMPLATE.events.map(row=>JSON.parse(bind(sourceBindingCanonical(row),roles))) const {operator,publisher,runtime,capture}=roles const sql=[ 'ALTER FUNCTION public.server_partition_writer_guard() SET search_path = pg_catalog', 'REVOKE ALL ON SCHEMA public, mmapp_control FROM PUBLIC', `GRANT USAGE ON SCHEMA public TO ${[publisher,runtime,capture].map(role=>identifier(role.name)).join(', ')}`, `GRANT USAGE ON SCHEMA mmapp_control TO ${[operator,publisher].map(role=>identifier(role.name)).join(', ')}`, ...functions, `REVOKE ALL ON FUNCTION ${keys.slice(0,3).map(name=>'mmapp_control.'+name+'()').join(', ')} FROM PUBLIC`, `GRANT EXECUTE ON FUNCTION mmapp_control.candidate_truncate_preadmitted() TO ${identifier(operator.name)}`, 'CREATE EVENT TRIGGER candidate_operator_ddl ON ddl_command_start EXECUTE FUNCTION mmapp_control.candidate_operator_ddl()', ] return {expected,publicGuard,schemas,events,sql,sha256:sha(sourceBindingBytes([...sql,...writerRegistryEnrollmentSql(roles)]))} } export function source58FoundationSqlSha256(roles:Request['roles']){return reviewedFoundation(roles).sha256} const functionSql=`SELECT n.nspname AS namespace,p.proname, pg_catalog.pg_get_function_identity_arguments(p.oid) AS arguments, l.lanname AS language,pg_catalog.pg_get_userbyid(p.proowner) AS owner,p.proconfig,p.prokind,p.prosecdef,p.proacl::text[] AS acl, pg_catalog.pg_get_functiondef(p.oid) AS definition FROM pg_catalog.pg_proc p JOIN pg_catalog.pg_namespace n ON n.oid=p.pronamespace JOIN pg_catalog.pg_language l ON l.oid=p.prolang WHERE (n.nspname='public' AND p.proname=$1) OR (n.nspname='mmapp_control' AND p.proname=ANY($2::text[])) LIMIT 5` const eventSql=`SELECT e.evtname,e.evtevent,e.evtenabled,e.evttags, pg_catalog.pg_get_userbyid(e.evtowner) AS owner, n.nspname AS function_namespace,p.proname AS function_name,n.nspname||'.'||p.proname||'()' AS function FROM pg_catalog.pg_event_trigger e JOIN pg_catalog.pg_proc p ON p.oid=e.evtfoid JOIN pg_catalog.pg_namespace n ON n.oid=p.pronamespace LIMIT 2` async function checkTarget(sql:Sql,request:Request){ const subject=await sql.query(`SELECT (pg_catalog.pg_control_system()).system_identifier::text AS system,d.oid::text AS database, d.datname AS name,pg_catalog.current_setting('server_version_num')::int AS version,r.oid::text AS role,r.rolsuper AS superuser, n.nspowner::text AS control_owner, pub.nspowner::text AS public_owner FROM pg_catalog.pg_database d CROSS JOIN pg_catalog.pg_roles r JOIN pg_catalog.pg_namespace n ON n.nspname='mmapp_control' JOIN pg_catalog.pg_namespace pub ON pub.nspname='public' WHERE d.datname=pg_catalog.current_database() AND r.rolname=SESSION_USER AND SESSION_USER=CURRENT_USER AND NOT pg_catalog.pg_is_in_recovery() AND pg_catalog.current_setting('session_replication_role')='origin' AND pg_catalog.current_setting('event_triggers')='on'`) const {source,roles}=request assert.deepEqual(subject.rows,[{system:source.systemIdentifier,database:source.databaseOid,name:source.databaseName,version:source.serverVersionNum, role:roles.control.signedOid,superuser:true,control_owner:roles.control.signedOid,public_owner:roles.operator.signedOid}],'Exact authorized control DBA and namespace owners required') const {rows}=await sql.query(`SELECT rolname AS name,oid::text AS oid FROM pg_catalog.pg_roles WHERE rolname=ANY($1::text[])`,[Object.values(roles).map(role=>role.name)]) assert.deepEqual(sorted(rows),sorted(Object.values(roles).map(role=>({name:role.name,oid:role.signedOid}))),'Exact five role OIDs required') const markers=await sql.query('SELECT id FROM ONLY public.schema_migrations ORDER BY id COLLATE "C" LIMIT $1',[MIGRATION_MANIFEST.length+1]) assert.deepEqual(markers.rows,MIGRATION_MANIFEST.map(pin=>({id:pin.file.slice(0,-4)})),'Exact current migration markers required') } async function checkFresh(sql:Sql,review:ReturnType){ const fresh=await sql.query(`SELECT NOT EXISTS(SELECT FROM pg_catalog.pg_class WHERE relnamespace='mmapp_control'::pg_catalog.regnamespace) AND NOT EXISTS(SELECT FROM pg_catalog.pg_proc WHERE pronamespace='mmapp_control'::pg_catalog.regnamespace) AND NOT EXISTS(SELECT FROM pg_catalog.pg_type WHERE typnamespace='mmapp_control'::pg_catalog.regnamespace) AND NOT EXISTS(SELECT FROM pg_catalog.pg_event_trigger) AND NOT EXISTS(SELECT FROM pg_catalog.pg_trigger WHERE tgrelid='public.schema_migrations'::pg_catalog.regclass AND NOT tgisinternal) AS empty`) assert.deepEqual(fresh.rows,[{empty:true}],'Unenrolled staging control namespace and marker required') const funcs=await sql.query(functionSql,[keys[3],keys.slice(0,3)]) assert.deepEqual(funcs.rows,[{...review.publicGuard,proconfig:null,definition:review.publicGuard.definition.replace(" SET search_path TO 'pg_catalog'\n",'')}], 'Original numbered public guard required') } async function checkFoundation(sql:Sql,review:ReturnType){ const functions=(await sql.query(functionSql,[keys[3],keys.slice(0,3)])).rows assert.deepEqual(sorted(functions.map(withSortedAcl)),sorted(review.expected.map(withSortedAcl)),'Exact reviewed guard function readback required') assert.deepEqual(sorted((await sql.query(eventSql)).rows),sorted(review.events),'Exact reviewed event trigger readback required') const schemas=await sql.query(`SELECT nspname,pg_catalog.pg_get_userbyid(nspowner) AS owner,nspacl::text[] AS acl FROM pg_catalog.pg_namespace WHERE nspname IN('public','mmapp_control')`) assert.deepEqual(sorted(schemas.rows.map(withSortedAcl)),sorted(review.schemas.map(withSortedAcl)),'Exact reviewed schema ACL required') } async function checkUnenrolledRelations(sql:Sql,plan:ReturnType,operatorOid:string){ const tables=await sql.query(`SELECT c.relname AS name,c.relkind::text AS kind,c.relowner::text AS owner FROM pg_catalog.pg_class c WHERE c.relnamespace='public'::pg_catalog.regnamespace AND c.relkind IN ('r','p') LIMIT $1`,[plan.tables.length+1]) assert.deepEqual(sorted(tables.rows),sorted(plan.tables.map(row=>({...row,owner:operatorOid}))),'Exact unpartitioned staging relation inventory required') const sequences=await sql.query(`SELECT c.relname AS name,c.relowner::text AS owner FROM pg_catalog.pg_class c WHERE c.relnamespace='public'::pg_catalog.regnamespace AND c.relkind='S' LIMIT $1`,[plan.sequences.length+1]) assert.deepEqual(sorted(sequences.rows),sorted(plan.sequences.map(row=>({...row,owner:operatorOid}))),'Exact staging sequence inventory required') const {rows}=await sql.query(`SELECT NOT EXISTS(SELECT FROM pg_catalog.pg_trigger t JOIN pg_catalog.pg_class c ON c.oid=t.tgrelid WHERE c.relnamespace='public'::pg_catalog.regnamespace AND t.tgname IN ('candidate_application_statement_guard','candidate_truncate_preadmitted')) AND NOT EXISTS(SELECT FROM mmapp_control.application_writer_profile_history) AND NOT EXISTS(SELECT FROM mmapp_control.application_writer_profile_current) AND pg_catalog.to_regclass('mmapp_control.database_restore_quarantine') IS NULL AS fresh`) assert.deepEqual(rows,[{fresh:true}],'Unenrolled public relations and empty Source57 writer registry required') } export async function source58FoundationMain(args:string[]){ const flags=['bootstrap','bootstrap-sha256','publisher-transport','publisher-transport-sha256','control-transport','control-transport-sha256','ca', 'source-registry','source-spki-sha256','activation-directory','activation-sha256','approval','approval-sha256','approval-public-key','approval-spki-sha256'] const admission=args[0]==='source57-admission-enroll' assert((admission||args[0]==='source58-foundation-enroll')&&args.length===1+2*flags.length);assertJsDriverEnvironment(process.env) const values=new Map() for(let index=1;indexvalues.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 bytes=await readProtected(get('approval'),8192,get('approval-sha256')),raw=parse(bytes),{body,signature}=approval.parse(raw) const pem=await readProtected(get('approval-public-key'),4096),key=createPublicKey(pem),sig=Buffer.from(signature,'base64url') const sourcePin={registryDirectory:get('source-registry'),installationId:request.installationId,publicKeySpkiSha256:get('source-spki-sha256'),currentHeadSha256:request.sourceHeadSha256} assert(!pem.includes('PRIVATE KEY')&&key.asymmetricKeyType==='ed25519'&&get('approval-spki-sha256')!==sourcePin.publicKeySpkiSha256&& sha(key.export({type:'spki',format:'der'}))===get('approval-spki-sha256')&&sourceBindingBytes(raw).equals(bytes)&&sig.toString('base64url')===signature&& verify(null,Buffer.from((admission?SOURCE57_ADMISSION_DOMAIN:SOURCE58_FOUNDATION_DOMAIN)+sourceBindingCanonical(body)),key,sig),'Independent signed operator approval required') const review=reviewedFoundation(request.roles) const relationPlan=admission?reviewedSource57Admission(request.roles):undefined const planMatches=body.format==='source57-admission-approval-v1'? admission&&body.definitionSha256===BUILD57_PROVENANCE.templateSha256&&body.admissionSha256===relationPlan?.sha256: !admission&&body.definitionSha256===BUILD58_PROVENANCE.templateSha256&&body.foundationSha256===review.sha256 assert(body.bootstrapSha256===get('bootstrap-sha256')&&body.sourceHeadSha256===sourcePin.currentHeadSha256&&body.sourceTlsSpkiSha256===request.tls.spkiSha256&& body.manifestSha256===migrationManifestDigest()&&planMatches&&body.expiresAt>Date.now()&&body.expiresAt-Date.now()<=900000,'Exact reviewed writer plan required') const ca=await readProtected(get('ca'),65536,request.tls.caSha256) const transport=async(role:'publisher'|'control')=>poolOptions(parse(await readProtected(get(role+'-transport'),16384,get(role+'-transport-sha256'))),request,ca,role) const [publisherOptions,controlOptions]=await Promise.all([transport('publisher'),transport('control')]) const {default:pg}=await import('pg');assertJsDriverEnvironment(process.env) const expectedSource={...request.source,databaseOid:Number(request.source.databaseOid),sessionUser:request.roles.publisher.name,currentUser:request.roles.publisher.name} const deadlineAt=Math.min(body.expiresAt,Date.now()+120000) return withActiveSource({directory:get('activation-directory'),expectedSha256:get('activation-sha256'),sourcePin,expectedSource, tlsSpkiSha256:request.tls.spkiSha256,deadlineAt},createProtectedDatabaseSourceBindingVerifier(sourcePin),async verifier=>{ const publisher=new pg.Pool(publisherOptions),control=new pg.Pool(controlOptions) let lost=false,commitSent=false,committed=false,cleanupUnconfirmed=false,client:PoolClient|undefined,registryStructureSha256:string|undefined,catalogueSha256:string|undefined for(const pool of [publisher,control])pool.on('error',()=>{lost=true}) const retained=(client:PoolClient)=>{ const check=retainPublisherTlsPeer(client,request.tls) return {check,sql:{query:async>(text:string,values?:unknown[])=>{ assert(!lost&&Date.now()(text,values) check();assert(!lost&&Date.now()result.status==='rejected') } assert(committed&®istryStructureSha256) return {event:admission?'database-source57-admission':'database-source58-foundation',outcome:'committed',approvalSha256:sha(bytes), ...(relationPlan?{admissionSha256:relationPlan.sha256,catalogueSha256}:{foundationSha256:review.sha256}), registryStructureSha256,cleanupUnconfirmed:cleanupUnconfirmed||lost,automaticReplay:false,readyAuthorized:false} }) }