Files
MikrotikManager/backend/scripts/source57-publication-owned.mjs
T

116 lines
9.2 KiB
JavaScript

import assert from 'node:assert/strict'
import {access,mkdir,readFile} from 'node:fs/promises'
import {join} from 'node:path'
export async function verifyOwnedSource57Publication({pg,control,operator,actor,main,directory,store,sha,bootstrapMaterial,bootstrap,request,pin,registry,tls,
activation,activationDirectory,publisherTransport,publisherTransportSha256,controlTransport,controlTransportSha256,ca,quarantine,publishSource58}){
const [{collectSource57Catalogue},{BUILD57_PROVENANCE,FIXED57_ROLE_TEMPLATE},{readProtectedRegistryStructureData},
{readCurrentApplicationWriterProfile},{sourceBindingBytes},{bytes,canonical},{retainPublisherTlsPeer}]=await Promise.all([
import('./writer-profile/catalogue.mts'),import('./writer-profile/fixed57-build-definition.ts'),
import('../src/db/application-writer-profile-registry-structure.ts'),import('../src/db/application-writer-profile-registry-read.ts'),
import('../src/db/database-source-binding.ts'),import('../src/db/application-writer-profile-format.ts'),import('./writer-profile/operator-contract.mjs'),
])
const bootstrapDir=join(directory,'source57-offline-bootstrap'),journal=join(directory,'source57-publication-journal')
await mkdir(bootstrapDir,{mode:0o700});await mkdir(journal,{mode:0o700})
const bootstrapFile=await store('source57-offline-bootstrap/bootstrap.json',bootstrap)
await store('source57-offline-bootstrap/signing-private.pem',bootstrapMaterial.privateKeyPem)
const definition=sourceBindingBytes({format:'application-writer-source57-definition-approval-v1',provenance:BUILD57_PROVENANCE,template:FIXED57_ROLE_TEMPLATE})
const definitionFile=await store('source57-definition.json',definition)
const subject=bootstrapMaterial.bootstrap.verificationSubject
// Review the already-provisioned isolated source through a separate ordinary
// operator backend, rather than letting the product publisher derive approval.
const approvedCatalogue=await (async()=>{
const client=await operator.connect()
try{
const retain=retainPublisherTlsPeer(client,tls)
await client.query('BEGIN ISOLATION LEVEL REPEATABLE READ READ ONLY')
const [base,security]=[await collectSource57Catalogue(client,{roleBindings:request.roles}),await readProtectedRegistryStructureData(client,request.roles)]
retain()
return sha(canonical({base:base.catalogSha256,security:security.sha256}))
}finally{await client.query('ROLLBACK');client.release(true)}
})()
const shared=['--bootstrap',bootstrapFile,'--bootstrap-sha256',sha(bootstrap),'--transport',publisherTransport,'--transport-sha256',publisherTransportSha256,
'--ca',ca,'--source-registry',pin.registryDirectory,'--source-spki-sha256',pin.publicKeySpkiSha256,
'--definition',definitionFile,'--definition-sha256',sha(definition),'--journal',journal,
'--activation-directory',activationDirectory,'--activation-sha256',sha(activation)]
const approval=async(expectedHeadSha256,name)=>{
const payload=sourceBindingBytes({format:'application-writer-publication-approval-v1',manifestSha256:BUILD57_PROVENANCE.manifestSha256,
definitionSha256:BUILD57_PROVENANCE.templateSha256,catalogSha256:approvedCatalogue,expectedHeadSha256,validityMs:120000,expiresAt:Date.now()+90000})
return ['--approval',await store(name,payload),'--approval-sha256',sha(payload)]
}
const observe=async()=>{
const connection=await operator.connect()
try{
const retained=retainPublisherTlsPeer(connection,tls)
await connection.query('BEGIN ISOLATION LEVEL REPEATABLE READ READ ONLY')
const current=await readCurrentApplicationWriterProfile(connection,subject)
retained()
return current
}finally{await connection.query('ROLLBACK');connection.release(true)}
}
const genesisArgs=await approval(null,'source57-genesis-approval.json')
const genesis=await main(['publish',...shared,...genesisArgs])
assert.equal(genesis.epoch,'1');assert.equal(genesis.cleanupUnconfirmed,false);assert.equal(genesis.journalUnconfirmed,false)
const first=await observe()
assert.equal(first.epoch,'1');assert.equal(first.headSha256,genesis.headSha256);assert.equal(first.policy.catalogSha256,approvedCatalogue)
assert.deepEqual(first.policy.source,request.source)
assert.deepEqual(first.policy.roles,Object.fromEntries(Object.entries(request.roles).map(([name,role])=>[name,role.signedOid])))
if(!quarantine){
await assert.rejects(main(['publish',...shared,...genesisArgs]),error=>error.cause?.message==='Expected protected current head mismatch')
assert.equal((await observe()).headSha256,first.headSha256)
}
const renewArgs=await approval(genesis.headSha256,'source57-renewal-approval.json')
const renewed=await main(['publish',...shared,...renewArgs])
assert.equal(renewed.epoch,'2');assert.equal(renewed.cleanupUnconfirmed,false);assert.equal(renewed.journalUnconfirmed,false)
const second=await observe();assert.equal(second.epoch,'2');assert.equal(second.headSha256,renewed.headSha256)
const {rows:links}=await control.query(`SELECT epoch::text,head_sha256,previous_head_sha256
FROM mmapp_control.application_writer_profile_history WHERE installation_id=$1 ORDER BY epoch`,[subject.installationId])
assert.deepEqual(links,[{epoch:'1',head_sha256:genesis.headSha256,previous_head_sha256:null},
{epoch:'2',head_sha256:renewed.headSha256,previous_head_sha256:genesis.headSha256}])
const preflight=['source-preflight',...shared,...renewArgs]
const checked=await main(preflight)
assert.equal(checked.outcome,'matched');assert.equal(checked.headSha256,renewed.headSha256);assert.equal(checked.platformProtectionVerified,true)
if(quarantine){
const {verifyOwnedSource58RestoreEnrollment}=await import('./source58-restore-enrollment-owned.mjs')
return await verifyOwnedSource58RestoreEnrollment({pg,control,actor,main,store,sha,request,approvedCatalogue,subject,renewed,observe,
bootstrapFile,bootstrap,controlTransport,controlTransportSha256,ca,shared,publishSource58})
}
const staleActivation=[...preflight]
staleActivation[staleActivation.indexOf('--activation-sha256')+1]='0'.repeat(64)
await assert.rejects(main(staleActivation),/Active activation digest changed/)
const replaceSignature=value=>({...value,signature:(value.signature[0]==='A'?'B':'A')+value.signature.slice(1)})
const badRegistry=join(directory,'source57-invalid-source-signature');await mkdir(badRegistry,{mode:0o700})
const headName='head-'+pin.currentHeadSha256+'.json',bindingName='binding-'+registry.head.bindingSha256+'.json'
const invalid=sourceBindingBytes(replaceSignature(JSON.parse(await readFile(join(pin.registryDirectory,headName),'utf8'))))
await store('source57-invalid-source-signature/operator-public.pem',await readFile(join(pin.registryDirectory,'operator-public.pem')))
await store('source57-invalid-source-signature/'+bindingName,await readFile(join(pin.registryDirectory,bindingName)))
await store('source57-invalid-source-signature/head-'+sha(invalid)+'.json',invalid)
const refusedActivation=join(directory,'source57-invalid-activation');await mkdir(refusedActivation,{mode:0o700})
const activationApproval=sourceBindingBytes({format:'database-source-activation-approval-v1',activationDirectory:refusedActivation,
sourcePin:{...pin,registryDirectory:badRegistry,currentHeadSha256:sha(invalid)},tlsSpkiSha256:tls.spkiSha256,expectedActivationSha256:null})
await assert.rejects(main(['source-activate','--directory',refusedActivation,'--approval',await store('source57-invalid-activation-approval.json',activationApproval),
'--approval-sha256',sha(activationApproval)]),{code:'DATABASE_SOURCE_BINDING_REFUSED'})
await assert.rejects(access(join(refusedActivation,'source-activation.json')),{code:'ENOENT'})
const {rows:[previous]}=await control.query(`SELECT head_bytes FROM mmapp_control.application_writer_profile_history WHERE installation_id=$1 AND epoch=1`,[subject.installationId])
const replacePredecessor=raw=>control.query(`UPDATE mmapp_control.application_writer_profile_history SET head_bytes=$2
WHERE installation_id=$1 AND epoch=1`,[subject.installationId,raw])
await replacePredecessor(bytes(replaceSignature(JSON.parse(previous.head_bytes.toString('utf8')))))
try{
await assert.rejects(observe(),/Installation signature refused/)
await assert.rejects(main(preflight),error=>error.cause?.message==='Installation signature refused')
}finally{await replacePredecessor(previous.head_bytes)}
assert.equal((await observe()).headSha256,renewed.headSha256)
const runtime=actor('runtime')
try{await assert.rejects(readCurrentApplicationWriterProfile(runtime,subject),{code:'42501'})}finally{await runtime.end()}
const {rows:[gate]}=await control.query("SELECT pg_catalog.to_regclass('mmapp_control.database_restore_quarantine') IS NULL AS absent")
assert.equal(gate.absent,true)
return {source57PublicationVerified:true,exactRetainedSourcePreflight:true,independentCatalogueReviewed:true,publishedEpochs:['1','2'],
signedGenesisAndPredecessorVerified:true,signedPredecessorTamperingRefused:true,wrongWriterCasRejected:true,activationDigestTamperingRefused:true,
forgedSourceHeadSignatureRefused:true,runtimeRegistryReadRefusedBefore58:true,catalogueSha256:approvedCatalogue,writerHeadSha256:renewed.headSha256,
source58QuarantineInstalled:false,readyAuthorized:false}
}