Files
MikrotikManager/backend/scripts/legacy-probe-cold-verify-owned.mjs
T

79 lines
7.1 KiB
JavaScript

import assert from 'node:assert/strict'
import {createPublicKey,generateKeyPairSync,X509Certificate} from 'node:crypto'
import {mkdir,open,readFile,realpath,readdir,unlink,writeFile} from 'node:fs/promises'
import {dirname,join,sep} from 'node:path'
export async function modelOwnedOperatorFiles(directory,sha){
if(process.platform!=='win32')return
const {mock}=await import('node:test'),url=new URL('./writer-profile/operator-files.mjs',import.meta.url),files=await import(url.href)
const protectedDirectory=async path=>{assert(path===directory||path.startsWith(directory+sep));assert.equal(await realpath(path),path)}
return mock.module(url,{namedExports:{...files,protectedDirectory,async writeFile(path,blob,opts){
await protectedDirectory(dirname(path));const file=await open(path,opts.flag,opts.mode);try{await file.writeFile(blob);await file.sync()}finally{await file.close()}
},async readProtected(path,limit,hash){
await protectedDirectory(dirname(path));const bytes=await readFile(path);assert(bytes.length>0&&bytes.length<=limit);if(hash!==undefined)assert.equal(sha(bytes),hash);return bytes
},async withJournalLease(path,work){
await protectedDirectory(path);const lock=join(path,'publisher-lease.lock'),file=await open(lock,'wx',0o600)
try{return await work()}finally{await file.close();await unlink(lock)}
}}})
}
export async function verifyOwnedLegacyColdCommand({live,coldAdmin,cold,options,directory,coldState,leafBytes,originalPin,archive,fullArchive,signedApproval,execute,adopt,release,tail,sourcePrivateKey}){
assert.equal(process.env.MMAPP_OWN_PROBE_LEGACY_0037,'true')
const [{sourceBindingBytes,sourceBindingSha256},{captureLegacyProbeCredentialDigest,verifyLegacyColdProof},{captureLegacyProbeStorage,captureLegacyProbeLineage}]=await Promise.all([
import('../src/db/database-source-binding.ts'),import('../src/services/server-probe-legacy-cold-proof.ts'),import('../src/services/server-probe-legacy-source-inventory.ts'),
])
const sha=sourceBindingSha256,store=async(path,data)=>{await writeFile(path,data,{flag:'wx',mode:0o600});return path}
const archiveDirectory=join(directory,'cold-protected-archive'),outputDirectory=join(directory,'cold-proof-output')
await mkdir(archiveDirectory,{mode:0o700});await mkdir(outputDirectory,{mode:0o700})
for(const [name,data] of [['legacy-probe.dump',archive],['legacy-probe-approval.json',signedApproval],['legacy-probe-cold.dump',fullArchive]])await store(join(archiveDirectory,name),data)
await coldAdmin.query('GRANT EXECUTE ON FUNCTION pg_catalog.pg_control_system() TO owned_legacy_reader')
const {rows:[identity]}=await cold.query(`SELECT current_database() AS "databaseName", current_user::text AS "currentUser", session_user::text AS "sessionUser",
(pg_catalog.pg_control_system()).system_identifier::text AS "systemIdentifier",pg_catalog.pg_is_in_recovery() AS "inRecovery",
current_setting('server_version_num')::int AS "serverVersionNum",d.oid::int AS "databaseOid",r.oid::text AS "roleOid"
FROM pg_catalog.pg_database d,pg_catalog.pg_roles r WHERE d.datname=current_database() AND r.rolname=current_user`)
const {roleOid,...coldSource}=identity
const key=generateKeyPairSync('ed25519').privateKey,publicKey=createPublicKey(key),host='localhost'
const signerSpkiSha256=sha(publicKey.export({type:'spki',format:'der'}))
const storedKey=await readFile(join(coldState,'encryption-key'));const keySha256=sha(storedKey);storedKey.fill(0)
const approval=sourceBindingBytes({format:'legacy-probe-cold-verification-approval-v1',installationId:originalPin.installationId,
sourceHeadSha256:originalPin.currentHeadSha256,sourceSignerSpkiSha256:originalPin.publicKeySpkiSha256,custodySha256:sha(signedApproval),
coldArchiveSha256:sha(fullArchive),coldSignerSpkiSha256:signerSpkiSha256,keySha256,coldSource,coldRoleOid:roleOid,
tls:{serverName:host,caSha256:sha(leafBytes),spkiSha256:sha(new X509Certificate(leafBytes).publicKey.export({type:'spki',format:'der'}))},expiresAt:Date.now()+120000})
const transport=sourceBindingBytes({host,port:options.port,user:cold.user,password:cold.password,database:cold.database})
const argv=['legacy-cold-verify','--approval',await store(join(directory,'cold-verification.json'),approval),'--approval-sha256',sha(approval),
'--transport',await store(join(directory,'cold-transport.json'),transport),'--transport-sha256',sha(transport),
'--ca',await store(join(directory,'cold-ca.pem'),leafBytes),'--source-registry',originalPin.registryDirectory,'--archive-directory',archiveDirectory,
'--legacy-key-directory',coldState,'--cold-signing-key',await store(join(directory,'cold-signing.pem'),key.export({type:'pkcs8',format:'pem'})),
'--output-directory',outputDirectory]
const modeledFiles=await modelOwnedOperatorFiles(directory,sha)
try{
const {main}=await import('./database-writer-profile-operator.mts')
if(!execute){
await coldAdmin.query('GRANT UPDATE ON public.mcp_credentials TO owned_legacy_reader')
try{await assert.rejects(main(argv),/read-only privileges/)}finally{await coldAdmin.query('REVOKE UPDATE ON public.mcp_credentials FROM owned_legacy_reader')}
assert.deepEqual(await readdir(outputDirectory),[])
}
const result=await main(argv),proof=await readFile(join(outputDirectory,result.proofFile))
assert.equal(result.event,'database-legacy-cold-proof');assert.equal(result.proofSha256,sha(proof));assert.equal(result.conversionAllowed,false)
const source=await live.connect()
try{
await source.query('BEGIN ISOLATION LEVEL REPEATABLE READ READ ONLY')
const storage=await captureLegacyProbeStorage(source),lineage=await captureLegacyProbeLineage(source)
const pinned={publicKeyPem:Buffer.from(publicKey.export({type:'spki',format:'pem'})),signerSpkiSha256,
sourceSignerSpkiSha256:originalPin.publicKeySpkiSha256,approvalSha256:sha(approval),coldArchiveSha256:sha(fullArchive),custodySha256:sha(signedApproval),
storageSha256:storage.sha256,lineageSha256:lineage.sha256}
const verified=verifyLegacyColdProof(proof,pinned)
assert.equal(verified.credentialSha256,await captureLegacyProbeCredentialDigest(source));assert.equal(verified.keySha256,keySha256)
assert.deepEqual(verified.coldSource,coldSource)
assert.throws(()=>verifyLegacyColdProof(proof,{...pinned,coldArchiveSha256:'0'.repeat(64)}),/proof refused/)
assert.throws(()=>verifyLegacyColdProof(proof,{...pinned,sourceSignerSpkiSha256:signerSpkiSha256}),/proof refused/)
}finally{try{await source.query('ROLLBACK')}finally{source.release()}}
if(execute){
const {verifyOwnedLegacyExecution}=await import('./legacy-probe-handoff-execute-owned.mjs')
return await verifyOwnedLegacyExecution({main,live,options,directory,archiveDirectory,coldState,leafBytes,originalPin,fullArchive,signedApproval,
adopt,release,tail,sourcePrivateKey,coldPrivateKey:key,coldPublicKey:publicKey,proof,coldApprovalSha256:sha(approval)})
}
return {coldProofIssued:true,distinctIssuerVerified:true,credentialDigestMatched:true,writePrivilegedRoleRefused:true,readyAuthorized:false}
}finally{modeledFiles?.restore()}
}