116 lines
9.2 KiB
JavaScript
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}
|
|
}
|