Files
MikrotikManager/backend/scripts/test-database-writer-retained-tls.mjs
T

550 lines
36 KiB
JavaScript

import assert from 'node:assert/strict'
import {execFile, execFileSync} from 'node:child_process'
import {randomBytes, randomUUID, X509Certificate} from 'node:crypto'
import {setDefaultResultOrder} from 'node:dns'
import {mkdtemp, mkdir, cp, readFile, writeFile, rename, rm, chmod, access} from 'node:fs/promises'
import {createServer} from 'node:net'
import {tmpdir} from 'node:os'
import {dirname, join, resolve} from 'node:path'
import {fileURLToPath} from 'node:url'
import {promisify} from 'node:util'
import EmbeddedPostgres from 'embedded-postgres'
import pg from 'pg'
import {tsImport} from 'tsx/esm/api'
import {poolOptions, retainPublisherTlsPeer} from './writer-profile/operator-contract.mjs'
import {sha} from './writer-profile/operator-files.mjs'
const openssl = process.env.MMAPP_TLS_FIXTURE_OPENSSL || 'openssl'
const activationOnly = process.argv.includes('--activation-only')
const schemaOnly = process.argv.includes('--schema-only')
const runtimeRoleOnly = process.argv.includes('--runtime-role-only')
const registryOnly = process.argv.includes('--registry-only')
const run = promisify(execFile)
setDefaultResultOrder('ipv4first')
const host = 'localhost'
const reservePort = async () => {
const listener = createServer()
await new Promise((ready, reject) => listener.once('error', reject).listen(0, '127.0.0.1', ready))
return listener
}
const releasePort = listener => new Promise((ready, reject) => listener.close(error => error ? reject(error) : ready()))
const sourcePort = await reservePort()
const clonePort = await reservePort()
const port = sourcePort.address().port, clonePortNumber = clonePort.address().port
await Promise.all([releasePort(sourcePort), releasePort(clonePort)])
const transport = {host, port, user: 'mcp_test', password: randomBytes(24).toString('hex'), database: 'postgres'}
const runtime = 'tls_fixture_runtime', runtimePassword = randomBytes(24).toString('hex')
const runtimeUrl = targetPort => `postgresql://${runtime}:${runtimePassword}@${host}:${targetPort}/${transport.database}`
const runtimeRefused = {code: 'DATABASE_RUNTIME_SOURCE_REFUSED'}
const certFile = 'server.pem', keyFile = 'server-key.pem'
const root = await mkdtemp(join(tmpdir(), 'mm-writer-tls-owned-'))
const databaseDir = join(root, 'pg'), cloneDir = join(root, 'pg-clone')
const sourceTlsDir = join(root, 'source-tls'), cloneTlsDir = join(root, 'clone-tls')
const postgresLog = []
const cluster = (databaseDir, port, tlsDir) => new EmbeddedPostgres({databaseDir, port, user: transport.user, password: transport.password,
persistent: true, createPostgresUser: false, initdbFlags: ['--encoding=UTF8'],
postgresFlags: ['-h', '127.0.0.1', '-c', 'ssl=on', '-c', `ssl_cert_file=${join(tlsDir, certFile)}`, '-c', `ssl_key_file=${join(tlsDir, keyFile)}`, '-c', 'log_line_prefix=[%u] '],
onLog: message => { postgresLog.push(message) }, onError: () => {}})
const postgres = cluster(databaseDir, port, sourceTlsDir), clone = cluster(cloneDir, clonePortNumber, cloneTlsDir)
let sourceStarted = false, cloneStarted = false
const fingerprint = ca => sha(new X509Certificate(ca).publicKey.export({format:'der', type:'spki'}))
const issue = async tlsDir => {
await mkdir(tlsDir, {mode:0o700})
execFileSync(openssl, ['req', '-new', '-newkey', 'rsa:2048', '-x509', '-nodes', '-days', '1', '-subj', '/CN=localhost',
'-addext', 'subjectAltName=DNS:localhost', '-keyout', keyFile, '-out', certFile], {cwd: tlsDir, stdio: 'ignore', windowsHide: true})
await chmod(join(tlsDir, keyFile), 0o600)
return readFile(join(tlsDir, certFile))
}
const withClient = async (config, work) => {
const pool = new pg.Pool({connectionTimeoutMillis:5000, ...config})
let client
try { client = await pool.connect(); return await work(client) }
finally { client?.release(true); await pool.end() }
}
const query = "SELECT (pg_control_system()).system_identifier::text AS system, oid::text AS oid FROM pg_database WHERE datname=current_database()"
const createRuntime = async client => {
await client.query(`CREATE ROLE ${runtime} LOGIN PASSWORD '${runtimePassword}'; GRANT EXECUTE ON FUNCTION pg_catalog.pg_control_system() TO ${runtime}`)
const {rows: [{oid}]} = await client.query('SELECT oid::text FROM pg_catalog.pg_roles WHERE rolname=$1', [runtime])
return oid
}
const runtimeFiles = async (request, ca, targetPort = port) => {
const requestFile = join(root, 'runtime-request.json'), caFile = join(root, 'runtime-ca.pem')
const bytes = Buffer.from(JSON.stringify(request))
await Promise.all([writeFile(requestFile, bytes), writeFile(caFile, ca)])
return {databaseUrl: runtimeUrl(targetPort), requestFile, requestSha256: sha(bytes), caFile}
}
const unexpectedConnection = () => assert.fail('Unverified runtime connection became available to application SQL')
async function verifyRegistryEnrollment(owner, runtimeRequest, ca) {
const {mock} = await import('node:test')
const filesUrl = new URL('./writer-profile/operator-files.mjs', import.meta.url)
const files = await import(filesUrl.href)
const {MIGRATION_MANIFEST, migrationManifestDigest} = await tsImport('../src/db/migration-manifest.ts', import.meta.url)
const {FIXED56_ROLE_TEMPLATE} = await tsImport('./writer-profile/fixed56-build-definition.ts', import.meta.url)
const operator = runtimeRequest.roles.operator.name, capture = runtimeRequest.roles.capture.name
const publisher = runtimeRequest.roles.publisher.name, control = runtimeRequest.roles.control.name
const password = randomBytes(24).toString('hex')
const guard = name => FIXED56_ROLE_TEMPLATE.functions.find(row => row.namespace === 'mmapp_control' && row.proname === name).definition
await owner.query(`CREATE ROLE ${operator} LOGIN; CREATE ROLE ${capture} LOGIN; CREATE ROLE ${publisher} LOGIN;
CREATE ROLE ${control} LOGIN PASSWORD '${password}'; ALTER SCHEMA mmapp_control OWNER TO ${control};
REVOKE ALL ON SCHEMA mmapp_control FROM PUBLIC;
GRANT USAGE ON SCHEMA mmapp_control TO ${operator}, ${publisher};
CREATE TABLE public.schema_migrations (id text PRIMARY KEY);
GRANT SELECT ON TABLE public.schema_migrations TO ${control};
GRANT EXECUTE ON FUNCTION pg_catalog.pg_control_system() TO ${operator}, ${publisher}, ${control};
${guard('candidate_require_preadmission')}; ${guard('candidate_truncate_preadmitted')};
ALTER FUNCTION mmapp_control.candidate_require_preadmission() OWNER TO ${control};
ALTER FUNCTION mmapp_control.candidate_truncate_preadmitted() OWNER TO ${control};
REVOKE ALL ON FUNCTION mmapp_control.candidate_require_preadmission(), mmapp_control.candidate_truncate_preadmitted() FROM PUBLIC;
GRANT EXECUTE ON FUNCTION mmapp_control.candidate_truncate_preadmitted() TO ${operator}`)
await owner.query('INSERT INTO public.schema_migrations SELECT unnest($1::text[])', [MIGRATION_MANIFEST.map(pin => pin.file.slice(0, -4))])
const keys = Object.keys(runtimeRequest.roles)
const names = keys.map(key => runtimeRequest.roles[key].name)
const {rows} = await owner.query('SELECT rolname AS name, oid::text AS oid FROM pg_catalog.pg_roles WHERE rolname=ANY($1)', [names])
const roles = Object.fromEntries(keys.map((key, index) => [key, {name:names[index], signedOid:rows.find(row => row.name === names[index]).oid}]))
const manifestSha256 = migrationManifestDigest()
const bytes = new Map([
['owned-approval', Buffer.from(JSON.stringify({format:'application-writer-registry-enrollment-v1', manifestSha256,
deploymentRequest:{...runtimeRequest, roles}}))],
['owned-transport', Buffer.from(JSON.stringify({...transport, user:control, password}))],
['owned-ca', ca],
])
// Windows fixture supplies protected bytes. The real TLS, SQL and catalog verifier run unchanged.
const fileFixture = mock.module(filesUrl, {namedExports:{...files, async readProtected(name, max, expected) {
const value = bytes.get(name)
assert(value && value.length <= max && sha(value) === expected)
return value
}}})
try {
const {registryEnrollmentMain} = await import('./writer-profile/registry-enrollment.mts')
const args = ['registry-enroll', '--approval', 'owned-approval', '--approval-sha256', sha(bytes.get('owned-approval')),
'--transport', 'owned-transport', '--transport-sha256', sha(bytes.get('owned-transport')), '--ca', 'owned-ca']
const inspectArgs = ['registry-inspect', ...args.slice(1)]
const count = async () => (await owner.query(`SELECT count(*)::int AS n FROM pg_catalog.pg_class c JOIN pg_catalog.pg_namespace n
ON n.oid=c.relnamespace WHERE n.nspname='mmapp_control' AND c.relname IN ('application_writer_profile_history','application_writer_profile_current')`)).rows[0].n
assert.equal((await registryEnrollmentMain(inspectArgs)).outcome, 'absent')
assert.equal(await count(), 0)
await owner.query('CREATE TABLE mmapp_control.application_writer_profile_history (id int)')
try { await assert.rejects(registryEnrollmentMain(inspectArgs), /relations are incomplete/) }
finally { await owner.query('DROP TABLE mmapp_control.application_writer_profile_history') }
await owner.query(`GRANT pg_read_all_data TO ${runtime}`)
try {
await assert.rejects(registryEnrollmentMain(args), /Role ownership\/membership/)
assert.equal(await count(), 0)
} finally { await owner.query(`REVOKE pg_read_all_data FROM ${runtime}`) }
const report = await registryEnrollmentMain(args)
assert.equal(report.outcome, 'committed')
assert.equal(report.readyAuthorized, false)
assert.equal(report.cleanupUnconfirmed, false)
assert.equal(report.manifestSha256, manifestSha256)
assert.match(report.registryStructureSha256, /^[a-f0-9]{64}$/)
assert.equal(await count(), 2)
const observed = await registryEnrollmentMain(inspectArgs)
assert.equal(observed.outcome, 'installed')
assert.equal(observed.registryStructureSha256, report.registryStructureSha256)
await owner.query(`GRANT UPDATE ON mmapp_control.application_writer_profile_history TO ${runtime}`)
try { await assert.rejects(registryEnrollmentMain(inspectArgs), /effective grant boundary/) }
finally { await owner.query(`REVOKE UPDATE ON mmapp_control.application_writer_profile_history FROM ${runtime}`) }
await assert.rejects(registryEnrollmentMain(args), /Registry target\/owner\/absence refused/)
assert.equal(await count(), 2)
console.log('Owned registry enrollment and inspection: live TLS, strict catalog readback, rollback on role drift, ACL drift and repeat enrollment refused')
} finally { fileFixture.restore() }
}
async function verifyRuntimeRolePrivileges(owner, createPool) {
const settable = 'tls_fixture_settable'
await owner.query(`CREATE ROLE ${settable} NOLOGIN;
CREATE TABLE public.runtime_privilege_fixture (value int);
INSERT INTO public.runtime_privilege_fixture VALUES (1);
GRANT SELECT, UPDATE ON public.runtime_privilege_fixture TO ${runtime}`)
const withRuntime = async work => {
const fresh = createPool(1)
try { await work(fresh) } finally { await fresh.end() }
}
await withRuntime(async fresh => {
const {rows} = await fresh.query('UPDATE public.runtime_privilege_fixture SET value=2 RETURNING value')
assert.deepEqual(rows, [{value:2}])
})
for (const [grant, revoke] of [
[`GRANT pg_write_all_data TO ${runtime} WITH INHERIT TRUE, SET FALSE`, `REVOKE pg_write_all_data FROM ${runtime}`],
[`GRANT ${settable} TO ${runtime} WITH INHERIT FALSE, SET TRUE`, `REVOKE ${settable} FROM ${runtime}`],
[`GRANT ${runtime} TO ${settable}`, `REVOKE ${runtime} FROM ${settable}`],
[`GRANT TEMPORARY ON DATABASE postgres TO ${runtime}`, `REVOKE TEMPORARY ON DATABASE postgres FROM ${runtime}`],
[`GRANT CREATE ON SCHEMA mmapp_control TO ${runtime}`, `REVOKE CREATE ON SCHEMA mmapp_control FROM ${runtime}`],
[`GRANT SET ON PARAMETER session_replication_role TO ${runtime}`, `REVOKE SET ON PARAMETER session_replication_role FROM ${runtime}`],
[`ALTER TABLE public.runtime_privilege_fixture OWNER TO ${runtime}`,
`ALTER TABLE public.runtime_privilege_fixture OWNER TO ${transport.user};
GRANT SELECT, UPDATE ON public.runtime_privilege_fixture TO ${runtime}`],
]) {
await owner.query(grant)
try {
await withRuntime(async fresh => assert.rejects(
fresh.query('UPDATE public.runtime_privilege_fixture SET value=3'), runtimeRefused, grant,
))
assert.deepEqual((await owner.query('SELECT value FROM public.runtime_privilege_fixture')).rows, [{value:2}])
} finally { await owner.query(revoke) }
}
await withRuntime(async fresh => assert.deepEqual(
(await fresh.query('SELECT value FROM public.runtime_privilege_fixture')).rows, [{value:2}],
))
await withRuntime(async retained => {
await retained.query('SELECT 1')
assert.equal(retained.idleCount, 1)
await owner.query(`GRANT ${settable} TO ${runtime}`)
try {
await assert.rejects(retained.query('UPDATE public.runtime_privilege_fixture SET value=3'), runtimeRefused)
assert.equal(retained.idleCount, 0)
} finally { await owner.query(`REVOKE ${settable} FROM ${runtime}`) }
await retained.query('SELECT 1')
assert.equal(retained.idleCount, 1)
await owner.query(`GRANT TEMPORARY ON DATABASE postgres TO ${runtime}`)
try {
await assert.rejects(retained.connect(), runtimeRefused)
assert.equal(retained.idleCount, 0)
} finally { await owner.query(`REVOKE TEMPORARY ON DATABASE postgres FROM ${runtime}`) }
assert.deepEqual((await retained.query('SELECT value FROM public.runtime_privilege_fixture')).rows, [{value:2}])
})
console.log('Runtime roles: direct DML accepted; unsafe privilege drift refused on fresh and retained TLS connections before application SQL')
}
async function verifyRuntimeActivation(createPool, ownerPool, request) {
const {sourceBindingBytes} = await tsImport('../src/db/database-source-binding.ts', import.meta.url)
const {DATABASE_SOURCE_ACTIVATION_FILENAME} = await tsImport('../src/db/database-source-activation-record.ts', import.meta.url)
const directory = join(root, 'activation')
const file = join(directory, DATABASE_SOURCE_ACTIVATION_FILENAME), pending = `${file}.pending`
const state = {
format: 'database-source-activation-v1', activationDirectory: directory, installationId: request.installationId,
sourceIdentityId: randomUUID(), publicKeySpkiSha256: 'c'.repeat(64), status: 'active',
generations: [{generation: randomUUID(), headSha256: request.sourceHeadSha256, bindingSha256: 'b'.repeat(64),
tlsSpkiSha256: request.tls.spkiSha256}],
}
const active = sourceBindingBytes(state)
const revoked = sourceBindingBytes({...state, status:'revoked'})
const publish = async bytes => {
await writeFile(pending, bytes, {flag:'wx', mode:0o600})
await rename(pending, file)
}
await mkdir(directory, {mode:0o700})
await publish(active)
await ownerPool.query(`CREATE SEQUENCE mmapp_control.activation_query; GRANT USAGE ON mmapp_control.activation_query TO ${runtime}`)
const blockedSql = "SELECT nextval('mmapp_control.activation_query')"
const pidSql = 'SELECT pg_backend_pid() AS pid'
const directoryKey = 'DATABASE_RUNTIME_ACTIVATION_DIRECTORY', digestKey = 'DATABASE_RUNTIME_ACTIVATION_SHA256'
const previousDirectory = process.env[directoryKey], previousDigest = process.env[digestKey]
process.env[directoryKey] = directory
process.env[digestKey] = sha(active)
let pool
try {
pool = createPool(1)
const {rows:[{pid}]} = await pool.query(pidSql)
const retained = await pool.connect()
let queued
try {
assert.equal((await retained.query(pidSql)).rows[0].pid, pid)
queued = assert.rejects(pool.connect().then(client => {
client.release()
unexpectedConnection()
}), runtimeRefused)
await writeFile(pending, revoked, {flag:'wx', mode:0o600})
} finally { retained.release() }
await queued
await assert.rejects(pool.query(blockedSql), runtimeRefused)
await rm(pending)
assert.equal((await pool.query(pidSql)).rowCount, 1)
assert.equal(pool.idleCount, 1)
await publish(revoked)
await assert.rejects(pool.query(blockedSql), runtimeRefused)
await assert.rejects(pool.connect().then(client => {
client.release()
unexpectedConnection()
}), runtimeRefused)
const refuseFresh = async expectedDigest => {
process.env[digestKey] = expectedDigest
await assert.rejects(async () => {
const fresh = createPool(1)
try { await fresh.query(blockedSql) }
finally { await fresh.end() }
}, runtimeRefused)
}
await refuseFresh(sha(revoked))
await publish(active)
await refuseFresh('0'.repeat(64))
assert.equal((await pool.query(pidSql)).rowCount, 1)
const [generation] = state.generations
const newHead = 'd'.repeat(64), newSpki = 'e'.repeat(64)
for (const wrongState of [
{...state, installationId:randomUUID()},
{...state, generations:[{...generation, headSha256:newHead}]},
{...state, generations:[{...generation, tlsSpkiSha256:newSpki}]},
{...state, generations:[generation, {...generation, generation:randomUUID(), headSha256:newHead, tlsSpkiSha256:newSpki}]},
]) {
const wrong = sourceBindingBytes(wrongState)
await publish(wrong)
await refuseFresh(sha(wrong))
}
const {rows:[{is_called}]} = await ownerPool.query('SELECT is_called FROM mmapp_control.activation_query')
assert.equal(is_called, false, 'Refused application SQL reached PostgreSQL')
} finally {
if (previousDirectory === undefined) delete process.env[directoryKey]
else process.env[directoryKey] = previousDirectory
if (previousDigest === undefined) delete process.env[digestKey]
else process.env[digestKey] = previousDigest
await pool?.end()
}
console.log('Runtime activation: retained PostgreSQL client admitted under active pin; pending, revoked, digest and latest generation mismatches refused before application SQL')
}
async function verifyRestrictedStartup(ownerPool, validFiles) {
const sqlitePath = join(root, 'fixture.sqlite')
const runBackend = (args, env) => run(process.execPath, ['--import', import.meta.resolve('tsx'), ...args], {
cwd: root, timeout: 120_000, windowsHide: true, env: {
SystemRoot: process.env.SystemRoot, PATH: process.env.PATH, TEMP: process.env.TEMP, TMP: process.env.TMP,
NODE_ENV: 'test', DATABASE_PATH: sqlitePath, MCP_STATE_DIR: join(root, 'startup-state'), ...env,
},
})
const prepare = fileURLToPath(new URL('../src/scripts/prepare-database.ts', import.meta.url))
const ownerUrl = `postgresql://${transport.user}:${transport.password}@127.0.0.1:${transport.port}/${transport.database}`
await runBackend([prepare], {DATABASE_URL: ownerUrl})
await ownerPool.query(`REVOKE CREATE ON SCHEMA public FROM PUBLIC;
GRANT SELECT ON public.schema_migrations, public.traffic_settings, public.uptime_settings,
public.internet_path_settings, public.data_migration, public.servers TO ${runtime};
ALTER ROLE ${runtime} SET log_statement = 'all'`)
const {FIXED56_ROLE_TEMPLATE} = await tsImport('./writer-profile/fixed56-build-definition.ts', import.meta.url)
const guardFunction = name => FIXED56_ROLE_TEMPLATE.functions.find(row => row.namespace === 'mmapp_control' && row.proname === name)
const admissionGuard = guardFunction('candidate_require_preadmission')
const truncateGuard = guardFunction('candidate_truncate_preadmitted')
const operatorGuard = guardFunction('candidate_operator_ddl')
const trigger = FIXED56_ROLE_TEMPLATE.triggers.find(row => row.relname === 'mcp_operation_replay_tombstones' && row.tgname === 'candidate_truncate_preadmitted')
const eventTrigger = FIXED56_ROLE_TEMPLATE.events.find(row => row.evtname === 'candidate_operator_ddl')
assert.equal(trigger.tgenabled, 'A')
assert.equal(eventTrigger.evtenabled, 'O')
assert.equal(eventTrigger.evttags, null)
await ownerPool.query(`${admissionGuard.definition}; ${truncateGuard.definition}; ${trigger.definition};
ALTER TABLE public.mcp_operation_replay_tombstones ENABLE ALWAYS TRIGGER candidate_truncate_preadmitted;
${operatorGuard.definition.replace('@mm-role:operator@', 'tls_operator')};
CREATE EVENT TRIGGER ${eventTrigger.evtname} ON ${eventTrigger.evtevent} EXECUTE FUNCTION ${eventTrigger.function};
REVOKE ALL ON FUNCTION mmapp_control.candidate_require_preadmission(), mmapp_control.candidate_truncate_preadmitted(),
mmapp_control.candidate_operator_ddl() FROM PUBLIC`)
const databaseModule = new URL('../src/db/index.ts', import.meta.url).href
const bootstrapModule = new URL('../src/db/bootstrap.ts', import.meta.url).href
const runtimeEnv = {
DATABASE_URL: validFiles.databaseUrl, DATABASE_RUNTIME_REQUEST_FILE: validFiles.requestFile,
DATABASE_RUNTIME_REQUEST_SHA256: validFiles.requestSha256, DATABASE_RUNTIME_CA_FILE: validFiles.caFile,
}
const schemaRefused = 'DATABASE_RUNTIME_SCHEMA_REFUSED'
const startup = async (expectedError, schemaSha256) => {
const start = postgresLog.length
await runBackend(['--input-type=module', '--eval', `
import assert from 'node:assert/strict';
import {closePool, pool} from ${JSON.stringify(databaseModule)};
import {initDatabase} from ${JSON.stringify(bootstrapModule)};
try {
const {rows: [role]} = await pool.query(\`SELECT session_user::text AS login,
current_user::text AS principal, has_schema_privilege('public', 'CREATE') AS create_schema,
has_database_privilege(current_database(), 'CREATE,TEMP') AS create_database\`);
assert.deepEqual(role, {login:${JSON.stringify(runtime)}, principal:${JSON.stringify(runtime)}, create_schema:false, create_database:false});
const expected = process.argv[1];
if (expected === ${JSON.stringify(schemaRefused)}) await assert.rejects(initDatabase(), {code: expected});
else if (expected) await assert.rejects(initDatabase(), new RegExp(expected));
else await initDatabase();
} finally { await closePool(); }
`, expectedError ?? ''], {
...runtimeEnv,
...(schemaSha256 === undefined ? {} : {DATABASE_RUNTIME_SCHEMA_SHA256: schemaSha256}),
})
const statements = postgresLog.slice(start).join('').split(new RegExp(`\\[${runtime}\\] (?:LOG: +(?:statement|execute [^:]+)|STATEMENT):`, 'g')).slice(1)
const readsMigrationHistory = statements.some(statement => /^\s*SELECT id FROM public\.schema_migrations\b/i.test(statement))
assert.equal(readsMigrationHistory, expectedError !== schemaRefused, 'Migration history must be read only after the schema guard passes')
if (schemaSha256 !== undefined) {
assert(statements.some(statement => /^\s*BEGIN ISOLATION LEVEL REPEATABLE READ READ ONLY\b/i.test(statement)))
assert(statements.some(statement => /^\s*\/\* migration-schema:columns \*\//i.test(statement)))
}
if (expectedError === schemaRefused) {
assert(!statements.some(statement => /\bFROM\s+(?:public\.)?(?:data_migration|servers|traffic_settings|uptime_settings|internet_path_settings)\b/i.test(statement)), 'Refused startup must stop before application reads')
}
assert(!statements.some(statement => /^\s*(CREATE|ALTER|DROP|INSERT|UPDATE|DELETE|TRUNCATE|COPY|CALL|DO)\b/i.test(statement)), 'PostgreSQL observed no runtime DDL or data writes during startup')
}
const {captureRuntimeDatabaseSchema} = await tsImport('../src/db/database-runtime-schema.ts', import.meta.url)
const {withSystemDatabaseOperationLock} = await tsImport('../src/db/operation-lock.ts', import.meta.url)
const capture = () => withSystemDatabaseOperationLock(() => ownerPool.connect(), captureRuntimeDatabaseSchema)
const baseline = await capture()
const {format, serverVersion, sha256} = baseline
const inspect = fileURLToPath(new URL('../src/scripts/inspect-database-schema.ts', import.meta.url))
const {stdout} = await runBackend([inspect], runtimeEnv)
assert.deepEqual(JSON.parse(stdout), {format, schemaSha256: sha256, serverVersion})
await startup(undefined, sha256)
const migrations = () => ownerPool.query('SELECT id, applied_at FROM public.schema_migrations ORDER BY id').then(result => result.rows)
const before = await migrations()
await ownerPool.query('ALTER TABLE public.traffic_settings ALTER COLUMN interval_sec SET DEFAULT 31')
await startup(schemaRefused, sha256)
assert.deepEqual(await migrations(), before)
const {rows: [{column_default}]} = await ownerPool.query(`SELECT column_default FROM information_schema.columns
WHERE table_schema = 'public' AND table_name = 'traffic_settings' AND column_name = 'interval_sec'`)
assert.equal(column_default, '31')
await ownerPool.query('ALTER TABLE public.traffic_settings ALTER COLUMN interval_sec SET DEFAULT 30')
console.log('Restricted application startup: accepted the operator schema digest over TLS and refused changed column default before application reads without runtime DDL or data writes')
const publicRows = ({sections}) => Object.values(sections).map(rows => rows.filter(row => row.namespace === 'public'))
const assertControlDrift = async () => {
const changed = await capture()
assert.notEqual(changed.sha256, sha256)
assert.deepEqual(publicRows(changed), publicRows(baseline))
await startup(schemaRefused, sha256)
assert.deepEqual(await migrations(), before)
}
const driftedBody = admissionGuard.definition.replace('pg_advisory_xact_lock_shared(8723110::bigint)', 'pg_advisory_xact_lock_shared(8723111::bigint)')
assert.notEqual(driftedBody, admissionGuard.definition)
await ownerPool.query(driftedBody)
await assertControlDrift()
await ownerPool.query(admissionGuard.definition)
await ownerPool.query(`GRANT EXECUTE ON FUNCTION mmapp_control.candidate_truncate_preadmitted() TO ${runtime}`)
await assertControlDrift()
await ownerPool.query(`REVOKE EXECUTE ON FUNCTION mmapp_control.candidate_truncate_preadmitted() FROM ${runtime}`)
await ownerPool.query(`ALTER EVENT TRIGGER ${eventTrigger.evtname} DISABLE`)
await assertControlDrift()
await ownerPool.query(`ALTER EVENT TRIGGER ${eventTrigger.evtname} ENABLE`)
await startup(undefined, sha256)
console.log('Restricted application startup: refused control guard body, ACL and event trigger state drift with the public catalog and migration markers intact')
await startup()
const currentPartition = `flow_buckets_d_${new Date().toISOString().slice(0, 10).replaceAll('-', '')}`
const expiredPartition = 'flow_buckets_d_20000101'
const partitionExists = async name => (await ownerPool.query('SELECT to_regclass($1) IS NOT NULL AS present', [`public.${name}`])).rows[0].present
await ownerPool.query(`DROP TABLE public.${currentPartition}; CREATE TABLE public.${expiredPartition}
PARTITION OF public.flow_buckets FOR VALUES FROM ('2000-01-01T00:00:00Z') TO ('2000-01-02T00:00:00Z')`)
await startup(`Required PostgreSQL partition ${currentPartition} is absent or incompatible`)
assert.equal(await partitionExists(currentPartition), false)
const {rows: [migration]} = await ownerPool.query('DELETE FROM public.schema_migrations WHERE id = (SELECT max(id) FROM public.schema_migrations) RETURNING id, applied_at')
await startup('Версия схемы PostgreSQL не совпадает')
const maintain = () => runBackend([prepare, '--partitions-only'], {DATABASE_URL: ownerUrl})
await assert.rejects(maintain(), /Версия схемы PostgreSQL не совпадает/)
assert.equal(await partitionExists(currentPartition), false)
assert.equal(await partitionExists(expiredPartition), true)
assert.equal((await ownerPool.query('SELECT id FROM public.schema_migrations WHERE id=$1', [migration.id])).rowCount, 0)
await ownerPool.query('INSERT INTO public.schema_migrations (id, applied_at) VALUES ($1, $2)', [migration.id, migration.applied_at])
await writeFile(sqlitePath, 'SQLite format 3\0')
await maintain()
assert.equal(await partitionExists(currentPartition), true)
assert.equal(await partitionExists(expiredPartition), false)
assert.deepEqual(await migrations(), before)
await startup('оператор должен завершить импорт SQLite')
await rm(sqlitePath)
await startup()
console.log('Operator partition maintenance: missing migration refused before partition DDL; missing and expired partitions handled without migrations or SQLite import')
}
try {
await postgres.initialise()
const first = await issue(sourceTlsDir)
await postgres.start(); sourceStarted = true
const pin = {serverName:host, caSha256:sha(first), spkiSha256:fingerprint(first)}
const request = {tls:pin, roles:{publisher:{name:transport.user}}, source:{databaseName:transport.database}}
const baseline = await withClient(poolOptions(transport, request, first), async client => {
const retained = retainPublisherTlsPeer(client, pin)
retained()
const {rows:[source]} = await client.query(query)
const {rows:[status]} = await client.query('SELECT ssl FROM pg_stat_ssl WHERE pid=pg_backend_pid()')
assert.equal(status.ssl, true)
await client.query(`CREATE SCHEMA mmapp_control; GRANT USAGE ON SCHEMA mmapp_control TO PUBLIC;
CREATE TABLE mmapp_control.notes (note text PRIMARY KEY); INSERT INTO mmapp_control.notes VALUES ('original')`)
await client.query('REVOKE CREATE, TEMP ON DATABASE postgres FROM PUBLIC; REVOKE EXECUTE ON FUNCTION pg_catalog.pg_control_system() FROM PUBLIC')
source.runtimeOid = await createRuntime(client)
const {rows: [{server_version_num}]} = await client.query('SHOW server_version_num')
source.serverVersionNum = Number(server_version_num)
const connection = client.connection, socket = connection.stream
connection.stream = undefined
try { assert.throws(retained, /retained TLS peer unavailable/) } finally { connection.stream = socket }
return source
})
await withClient({...transport, ssl:false}, async client => assert.throws(() => retainPublisherTlsPeer(client,pin), /retained TLS peer unavailable/))
const runtimeRequest = {
format: 'application-writer-bootstrap-request-v1', installationId: randomUUID(), sourceHeadSha256: 'a'.repeat(64),
source: {systemIdentifier: baseline.system, databaseOid: baseline.oid, databaseName: transport.database,
serverVersionNum: baseline.serverVersionNum, inRecovery: false},
roles: {runtime: {name: runtime, signedOid: baseline.runtimeOid}, operator: {name: 'tls_operator', signedOid: '30000'},
capture: {name: 'tls_capture', signedOid: '30001'}, publisher: {name: 'tls_publisher', signedOid: '30002'},
control: {name: 'tls_control', signedOid: '30003'}},
tls: pin,
}
const validFiles = await runtimeFiles(runtimeRequest, first)
Object.assign(process.env, {DATABASE_URL: validFiles.databaseUrl, DATABASE_RUNTIME_REQUEST_FILE: validFiles.requestFile,
DATABASE_RUNTIME_REQUEST_SHA256: validFiles.requestSha256, DATABASE_RUNTIME_CA_FILE: validFiles.caFile})
const {pool: appPool, createPool} = await tsImport('../src/db/index.ts', import.meta.url)
const {readRuntimeDatabasePoolOptions} = await tsImport('../src/db/database-runtime-source.ts', import.meta.url)
try {
const {rows: [identity]} = await appPool.query(`SELECT session_user::text AS login, current_user::text AS principal,
(SELECT ssl FROM pg_catalog.pg_stat_ssl WHERE pid=pg_backend_pid()) AS tls,
pg_catalog.has_database_privilege(current_database(), 'CREATE,TEMP') AS can_create_or_temp`)
assert.deepEqual(identity, {login: runtime, principal: runtime, tls: true, can_create_or_temp: false})
await assert.rejects(appPool.query('SELECT * FROM mmapp_control.notes'), {code: '42501'})
} finally { await appPool.end() }
const ownerPool = new pg.Pool(poolOptions(transport, request, first))
try {
if (registryOnly) await verifyRegistryEnrollment(ownerPool, runtimeRequest, first)
else {
if (!schemaOnly && !activationOnly) await verifyRuntimeRolePrivileges(ownerPool, createPool)
if (!schemaOnly && !runtimeRoleOnly) await verifyRuntimeActivation(createPool, ownerPool, runtimeRequest)
if (!activationOnly && !runtimeRoleOnly) await verifyRestrictedStartup(ownerPool, validFiles)
}
} finally { await ownerPool.end() }
if (!activationOnly && !schemaOnly && !runtimeRoleOnly && !registryOnly) {
assert.throws(() => readRuntimeDatabasePoolOptions({...validFiles, databaseUrl: `${validFiles.databaseUrl}?sslmode=disable`}), runtimeRefused)
assert.throws(() => readRuntimeDatabasePoolOptions({...validFiles, requestSha256: '0'.repeat(64)}), runtimeRefused)
await withClient(poolOptions(transport, request, first), client => client.query(`REVOKE EXECUTE ON FUNCTION pg_catalog.pg_control_system() FROM ${runtime}`))
await assert.rejects(withClient(readRuntimeDatabasePoolOptions(validFiles), unexpectedConnection), runtimeRefused)
await withClient(poolOptions(transport, request, first), client => client.query(`GRANT EXECUTE ON FUNCTION pg_catalog.pg_control_system() TO ${runtime}`))
const wrongDb = await runtimeFiles({...runtimeRequest, source: {...runtimeRequest.source, databaseOid: String(Number(baseline.oid) + 1)}}, first)
await assert.rejects(withClient(readRuntimeDatabasePoolOptions(wrongDb), unexpectedConnection), runtimeRefused)
await runtimeFiles(runtimeRequest, first)
await postgres.stop(); sourceStarted = false
await cp(databaseDir, cloneDir, {recursive:true, force:false, errorOnExist:true})
await assert.rejects(access(join(cloneDir, keyFile)), {code:'ENOENT'})
const second = await issue(cloneTlsDir)
assert.notEqual(fingerprint(second), pin.spkiSha256)
await postgres.start(); sourceStarted = true
await clone.start(); cloneStarted = true
const cloneTransport = {...transport, port:clonePortNumber}
const bothTrusted = Buffer.concat([first,second])
await assert.rejects(withClient(poolOptions(cloneTransport, {...request,tls:{...pin,caSha256:sha(bothTrusted)}}, bothTrusted),
() => assert.fail('Wrong physical cluster must not reach application SQL')), /TLS SPKI refused/)
await withClient({...cloneTransport, ssl:{ca:bothTrusted, servername:host, rejectUnauthorized:true}}, async client => {
assert.equal(client.connection.stream.authorized, true)
const {rows:[source]} = await client.query(query)
assert.deepEqual(source, {system: baseline.system, oid: baseline.oid})
assert.throws(() => retainPublisherTlsPeer(client,pin), /TLS SPKI refused/)
retainPublisherTlsPeer(client,{...pin,spkiSha256:fingerprint(second)})()
assert.deepEqual((await client.query('SELECT note FROM mmapp_control.notes')).rows, [{note:'original'}])
await client.query("INSERT INTO mmapp_control.notes VALUES ('clone-only')")
})
const cloneFiles = await runtimeFiles({...runtimeRequest, tls: {...pin, caSha256: sha(bothTrusted)}}, bothTrusted, clonePortNumber)
await assert.rejects(withClient(readRuntimeDatabasePoolOptions(cloneFiles), unexpectedConnection), runtimeRefused)
await runtimeFiles(runtimeRequest, first)
await withClient(poolOptions(transport, request, first), async client => {
retainPublisherTlsPeer(client,pin)()
assert.deepEqual((await client.query('SELECT note FROM mmapp_control.notes')).rows, [{note:'original'}])
await client.query(`DROP OWNED BY ${runtime}; DROP ROLE ${runtime}`)
assert.notEqual(await createRuntime(client), baseline.runtimeOid)
})
const freshAppPool = createPool(1)
try { await assert.rejects(freshAppPool.query('SELECT 1'), runtimeRefused) }
finally { await freshAppPool.end() }
console.log('Genuine PostgreSQL TLS: original accepted; independently writable physical clone with identical DB coordinates and a different CA-valid TLS key refused')
console.log('Runtime pool: restricted login accepted; TLS override, incorrect request digest, missing observation grant, wrong database OID, clone key and recreated role refused')
}
} finally {
const stops = await Promise.allSettled([
cloneStarted ? clone.stop() : undefined,
sourceStarted ? postgres.stop() : undefined,
])
assert(stops.every(result => result.status === 'fulfilled'), 'Owned cluster stop unconfirmed')
assert.equal(dirname(resolve(root)), resolve(tmpdir()))
assert.match(root, /mm-writer-tls-owned-/)
await rm(root, {recursive:true, force:true, maxRetries:20, retryDelay:100})
await assert.rejects(access(root), {code:'ENOENT'})
console.log('Owned PostgreSQL and temporary TLS material removed')
}