Files
MikrotikManager/backend/src/db/legacy-source58-transition.ts
T

96 lines
8.1 KiB
TypeScript

import { createPublicKey, verify } from "node:crypto"
import { z } from "zod"
import { readControlledSchemaReference } from "./controlled-schema-reference-core.js"
import { exactHistory } from "./controlled-migration-history.js"
import { checkDatabaseSchemaControlState, type DatabaseSchemaTerminal } from "./database-schema-control-model.js"
import { RESTORE_WRITER_PROFILE_DEFINITION_SHA256 } from "./database-restore-quarantine-profile.js"
import { sourceBindingBytes, sourceBindingCanonical, sourceBindingSha256 } from "./database-source-binding.js"
import { MIGRATION_MANIFEST, migrationManifestDigest } from "./migration-manifest.js"
import { captureMigrationSchema, compareMigrationSchemas, type SchemaInventoryClient } from "./migration-schema-inventory.js"
export const LEGACY_SOURCE58_PREFLIGHT_DOMAIN = "mmapp:legacy-source58-preflight:ed25519:v1\n"
const digest = z.string().regex(/^[a-f0-9]{64}$/)
const role = z.object({ name: z.string().regex(/^(?!pg_)[a-z_][a-z0-9_]{0,62}$/),
signedOid: z.string().regex(/^[1-9][0-9]{0,9}$/).refine(value => Number(value) <= 4294967295) }).strict()
const roles = z.object({ publisher: role, control: role, operator: role, runtime: role, capture: role }).strict()
const approval = z.object({ body: z.object({ format: z.literal("legacy-source58-preflight-approval-v1"), manifestSha256: digest,
sourceHeadSha256: digest, sourceTlsSpkiSha256: digest, currentSchemaSha256: digest, operationId: z.uuidv4(),
intentSha256: digest, releaseApprovalSha256: digest, targetDefinitionSha256: z.literal(RESTORE_WRITER_PROFILE_DEFINITION_SHA256),
targetCatalogueSha256: digest, roles, expiresAt: z.number().int().positive() }).strict(),
signature: z.string().regex(/^[A-Za-z0-9_-]{86}$/) }).strict()
const verified = new WeakSet<object>()
const refuse = (reason: string): never => { throw new Error("Legacy Source58 predecessor refused: " + reason) }
export function verifyLegacySource58PreflightApproval(raw: Buffer, pem: Buffer, pins: {
coldSpkiSha256: string; sourceSpkiSha256: string; sourceHeadSha256: string; sourceTlsSpkiSha256: string; roles: z.infer<typeof roles>
}) {
const parsed: unknown = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(raw))
const { body, signature } = approval.parse(parsed), key = createPublicKey(pem), sig = Buffer.from(signature, "base64url")
const bindings = Object.values(body.roles)
if (!sourceBindingBytes(parsed).equals(raw) || sig.toString("base64url") !== signature || pem.includes("PRIVATE KEY") ||
key.asymmetricKeyType !== "ed25519" || pins.coldSpkiSha256 === pins.sourceSpkiSha256 ||
sourceBindingSha256(key.export({ type: "spki", format: "der" })) !== pins.coldSpkiSha256 ||
body.sourceHeadSha256 !== pins.sourceHeadSha256 || body.sourceTlsSpkiSha256 !== pins.sourceTlsSpkiSha256 ||
body.manifestSha256 !== migrationManifestDigest() || body.expiresAt <= Date.now() || body.expiresAt - Date.now() > 900000 ||
new Set(bindings.map(binding => binding.name)).size !== bindings.length || new Set(bindings.map(binding => binding.signedOid)).size !== bindings.length ||
sourceBindingCanonical(body.roles) !== sourceBindingCanonical(pins.roles) ||
!verify(null, Buffer.from(LEGACY_SOURCE58_PREFLIGHT_DOMAIN + sourceBindingCanonical(body)), key, sig)) return refuse("independent target approval")
for (const binding of bindings) Object.freeze(binding)
const result = Object.freeze({ ...body, roles: Object.freeze(body.roles), approvalSha256: sourceBindingSha256(raw) })
verified.add(result)
return result
}
/** Verify the exact pre-transition state through one retained snapshot. The
* independently approved target is a pin for future enrollment and is never
* inferred from the source or interpreted as an applied catalogue. */
export async function inspectApprovedLegacySource58Predecessor(sql: SchemaInventoryClient,
pin: ReturnType<typeof verifyLegacySource58PreflightApproval>, deadlineAt: number) {
if (!verified.has(pin) || Date.now() >= pin.expiresAt) return refuse("verified approval required")
const reference = await readControlledSchemaReference()
if (!reference || reference.sha256 !== pin.currentSchemaSha256) return refuse("independent predecessor reference")
const actual = await captureMigrationSchema(sql, { scope: reference.scope, deadlineAt })
compareMigrationSchemas(reference, actual)
const { rows: [gate] } = await sql.query(`SELECT q.operation_id AS quarantine_operation,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 state = checkDatabaseSchemaControlState(gate?.state)
const { rows: history } = await sql.query(`SELECT id::text AS id,intent,terminal FROM mmapp_control.database_schema_intents
ORDER BY id LIMIT ${MIGRATION_MANIFEST.length + 1}`)
const completedFiles = await exactHistory(history, state, pin.manifestSha256, true)
const terminal = history.find(row => row.id === pin.operationId)?.terminal as DatabaseSchemaTerminal | undefined
if (gate.quarantine_operation !== null || completedFiles !== MIGRATION_MANIFEST.length ||
terminal?.intent.artifactSha256 !== pin.intentSha256 || terminal.legacyRelease?.approvalSha256 !== pin.releaseApprovalSha256) {
return refuse("exact authenticated release and open quarantine")
}
const { rows: markers } = await sql.query('SELECT id FROM public.schema_migrations ORDER BY id COLLATE "C" LIMIT $1', [MIGRATION_MANIFEST.length + 1])
if (markers.length !== MIGRATION_MANIFEST.length ||
!markers.every((row, index) => row.id === MIGRATION_MANIFEST[index].file.slice(0, -4))) return refuse("exact current markers")
const { rows: liveRoles } = await sql.query(`SELECT rolname AS name,oid::text AS oid,rolcanlogin AS login,
(rolsuper OR rolcreatedb OR rolcreaterole OR rolreplication OR rolbypassrls OR EXISTS(SELECT FROM pg_catalog.pg_database d WHERE d.datdba=r.oid)
OR EXISTS(SELECT FROM pg_catalog.pg_auth_members m WHERE m.member=r.oid OR m.roleid=r.oid)) AS unsafe
FROM pg_catalog.pg_roles r WHERE rolname=ANY($1::text[])`, [Object.values(pin.roles).map(binding => binding.name)])
if (liveRoles.length !== 5 || !Object.values(pin.roles).every(binding => liveRoles.some(row => row.name === binding.name && row.oid === binding.signedOid))) {
return refuse("exact live role OIDs")
}
const { rows: [layout] } = await sql.query(`SELECT q.relowner::text AS quarantine_owner,n.nspowner::text AS namespace_owner,
pg_catalog.to_regclass('mmapp_control.application_writer_profile_history') IS NOT NULL AS history,
pg_catalog.to_regclass('mmapp_control.application_writer_profile_current') IS NOT NULL AS current,
(SELECT count(*)::int FROM pg_catalog.pg_trigger WHERE tgrelid='public.schema_migrations'::pg_catalog.regclass AND NOT tgisinternal) AS marker_triggers
FROM pg_catalog.pg_class q JOIN pg_catalog.pg_namespace n ON n.oid=q.relnamespace WHERE q.oid='mmapp_control.database_restore_quarantine'::pg_catalog.regclass`)
if (!layout || (layout.history !== layout.current)) return refuse("partial writer registry")
const blockers = [
...(layout.namespace_owner !== pin.roles.control.signedOid ? ["CONTROL_NAMESPACE_OWNER"] : []),
...(layout.quarantine_owner !== pin.roles.control.signedOid ? ["QUARANTINE_OWNER"] : []),
...(!layout.history ? ["WRITER_REGISTRY_MISSING"] : []),
...(layout.marker_triggers !== 3 ? ["REVIEWED_MARKER_FENCE_MISSING"] : []),
...(["operator", "publisher", "runtime", "capture"] as const).filter(scope => {
const actor = liveRoles.find(row => row.oid === pin.roles[scope].signedOid)
return actor?.unsafe !== false || actor.login !== true
}).map(scope => "ROLE_PROFILE_" + scope.toUpperCase()),
]
if (Date.now() >= deadlineAt || Date.now() >= pin.expiresAt) return refuse("attestation lifetime")
return Object.freeze({ approvalSha256: pin.approvalSha256, sourceHeadSha256: pin.sourceHeadSha256, releaseApprovalSha256: pin.releaseApprovalSha256,
currentSchemaSha256: actual.sha256, approvedTargetCatalogueSha256: pin.targetCatalogueSha256, authenticatedFiles: completedFiles,
blockers, transitionAuthorized: false as const, readyAuthorized: false as const })
}