Files
MikrotikManager/backend/src/modules/mcp/principal-security-source.owned.test.ts
T

262 lines
21 KiB
TypeScript

/** Owned SQL source/refusal evidence only. Real connection/token/security-source
* factories, synthetic owners, no HTTP/native traffic or MCP mutation success. */
import assert from "node:assert/strict"
import { createHash, createHmac, randomBytes, randomUUID } from "node:crypto"
import { readFile, unlink, writeFile } from "node:fs/promises"
import { basename, dirname, isAbsolute, join, resolve } from "node:path"
import type { PoolClient } from "pg"
import type { AuthUser } from "../../lib/permissions.js"
import { checkOwnedPollPolicySource } from "./poll-runtime-policy-source.owned-helper.test.js"
import { checkOwnedPollPolicyLoan } from "./poll-policy-loan.owned-helper.test.js"
assert.equal(process.env.MMAPP_OWN_PRINCIPAL_SECURITY_SOURCE, "true")
assert.equal(process.env.NODE_ENV, "test")
const endpoint = new URL(process.env.DATABASE_URL ?? "")
assert(["postgres:", "postgresql:"].includes(endpoint.protocol))
assert.equal(endpoint.hostname, "127.0.0.1"); assert.equal(endpoint.username, "mcp_test"); assert(endpoint.password)
assert.equal(endpoint.pathname, "/postgres"); assert.equal(endpoint.search, ""); assert.equal(endpoint.hash, "")
assert(Number.isInteger(Number(endpoint.port)) && Number(endpoint.port) > 0 && Number(endpoint.port) <= 65535)
assert(process.env.MCP_STATE_DIR && isAbsolute(process.env.MCP_STATE_DIR))
assert.equal(basename(resolve(process.env.MCP_STATE_DIR)), "state")
assert.match(basename(dirname(resolve(process.env.MCP_STATE_DIR))), /^mm-mcp-test-[A-Za-z0-9-]+$/)
const { pool, closePool } = await import("../../db/index.js")
const { applySqlMigrations } = await import("../../db/migrate.js")
const { MIGRATION_MANIFEST } = await import("../../db/migration-manifest.js")
const { mcpConnectionCreateSchema, mcpTemporaryGrantSchema } = await import("@mmapp/contracts/mcp")
const { createMcpConnection, authenticateMcpToken, getConnection, validatePrincipal, effectiveMcpConnectionSource } = await import("./store.js")
const { acceptPortalRevocation } = await import("./portal-revocation.js")
const { connectProbeStorage } = await import("../../services/server-probe-storage-connection.js")
const { principalSourceSql, principalSourceStatementName } = await import("./principal-security-sql.js")
const { ProbeStorageUnknown, ProbeStorageRefused } = await import("../../services/server-probe-journal-maintenance.js")
const connectionIds: string[] = [], groups: string[] = []
let priorEnabled: boolean | undefined
const check = async (name: string, work: () => Promise<void>) => { await work(); groups.push(name); console.log("Owned principal source group PASS:", name) }
async function fixture() {
const actor: AuthUser = { id: "owned-principal-source-" + randomUUID(), email: "[email protected]", name: "Owned SQL principal source",
apps: ["mm"], permissions: ["mm:servers:read", "mm:servers:write", "mm:mcp:manage", "mm:mcp:admin", "mm:mcp:approve"],
issuedAt: Date.now() - 1000, expiresAt: Date.now() + 3600000 }
const access = await createMcpConnection(mcpConnectionCreateSchema.parse({ name: "Owned source", mode: "approval", dangerousPolicy: "explicit-allow",
permissions: ["mm:servers:read", "mm:servers:write"], expiresAt: new Date(actor.expiresAt!).toISOString(),
scope: { serverIds: [], operationIds: ["servers.poll"], allowGlobal: true },
limits: { callsPerMinute: 10000, mutationsPerHour: 10000, serversPerPlan: 1, objectsPerPlan: 10000 } }), actor)
connectionIds.push(access.connection.id)
const principal = await authenticateMcpToken(access.token)
return { actor, principal }
}
type Fixture = Awaited<ReturnType<typeof fixture>>
async function grant(f: Fixture, oversized = false) {
const id = randomUUID(), value = mcpTemporaryGrantSchema.parse({ id, startsAt: new Date(Date.now() - 1000).toISOString(),
expiresAt: new Date(Date.now() + 600000).toISOString(), scope: { serverIds: [], operationIds: ["servers.poll"], allowGlobal: false } })
const payload = { ...value, credentialId: f.principal.credentialId }
if (oversized) await pool.query("INSERT INTO mcp_grants(id,connection_id,payload) VALUES($1,$2,$3::jsonb||jsonb_build_object('opaque',repeat('x',2097153)))", [id, f.principal.connectionId, JSON.stringify(payload)])
else await pool.query("INSERT INTO mcp_grants(id,connection_id,payload) VALUES($1,$2,$3::jsonb)", [id, f.principal.connectionId, JSON.stringify(payload)])
return payload
}
/** Transparent observer: every call executes original SQL/arguments and returns
* its exact actual result. The independent held writer cannot be reused by pool
* reads. No source row, proof, cutoff or permission decision is substituted. */
async function between<T>(hook: (writer: PoolClient) => Promise<void>, work: (client: Pick<PoolClient, "query">) => Promise<T>) {
const writer = await pool.connect(), texts: string[] = [], observedNumbers: unknown[] = [], observedGrantNumbers: unknown[] = []
const client: Pick<PoolClient, "query"> = { query: (async (...args: unknown[]) => {
const result = await Reflect.apply(pool.query, pool, args)
if (typeof args[0] === "string" && args[0].includes("mcp-principal:coherent-source-v1")) {
texts.push(args[0]); observedNumbers.push(result.rows[0]?.policy?.limits?.callsPerMinute)
observedGrantNumbers.push(result.rows[0]?.__ps_grant_payload?.scope?.serverIds?.[0])
if (texts.length === 1) await hook(writer)
}
return result
}) as PoolClient["query"] }
try { return { result: await work(client), texts, observedNumbers, observedGrantNumbers } }
finally { writer.release(true) }
}
async function refusalBetween(f: Fixture, hook: (writer: PoolClient) => Promise<void>, code: string, effective = false) {
let error: unknown
const observed = await between(hook, async client => { try { if (effective) await effectiveMcpConnectionSource(f.principal, client); else await validatePrincipal(f.principal, client) } catch (caught) { error = caught } })
assert(error && typeof error === "object" && "code" in error && error.code === code, "Expected fixed source refusal code")
assert.equal(observed.texts.length, code === "OWNER_CLAIMS_REVOKED" ? 1 : 2)
assert(observed.texts.every(text => text === observed.texts[0]), "Both captures must execute the identical actual fixed SQL")
return observed
}
try {
await applySqlMigrations(pool)
assert.equal((await pool.query("SELECT count(*)::int AS n FROM schema_migrations")).rows[0].n, MIGRATION_MANIFEST.length)
priorEnabled = Boolean((await pool.query("SELECT enabled FROM mcp_settings WHERE id=1")).rows[0].enabled)
await pool.query("UPDATE mcp_settings SET enabled=true WHERE id=1")
await check("poll current policy tuple: real SQL bounds, clock, backend, scopes and fresh committed updates", async () => {
const f = await fixture()
console.log("Owned poll policy tuple SQL:", JSON.stringify(await checkOwnedPollPolicySource(pool, f.principal.connectionId, f.principal.credentialId)))
})
await check("borrowed policy transaction: actual origin bridge and real original-grant/credential races", async () => {
console.log("Owned poll policy loan SQL:", JSON.stringify(await checkOwnedPollPolicyLoan(pool, fixture)))
})
await check("actual factories, two fixed captures, no grant and exact connection DTO", async () => {
const f = await fixture(), expected = await getConnection(f.principal.connectionId)
const captured = await between(async () => {}, client => validatePrincipal(f.principal, client))
assert.equal(captured.texts.length, 2); assert.equal(captured.texts[0], captured.texts[1]); assert.deepEqual(captured.result, expected)
assert(captured.result.owner_valid_until instanceof Date); assert(!Object.keys(captured.result).some(key => key.startsWith("__ps_")))
const effective = await effectiveMcpConnectionSource(f.principal)
assert.deepEqual(effective.grantRows, []); assert.deepEqual(effective.connection, expected)
})
await check("exact raw grantRows payload shape and excluded-grant base principal", async () => {
const f = await fixture(), payload = await grant(f)
const base = await validatePrincipal(f.principal); assert.equal(base.policy.scope.allowGlobal, true)
const effective = await effectiveMcpConnectionSource(f.principal)
assert.equal(effective.connection.policy.scope.allowGlobal, false)
assert.deepEqual(effective.grantRows, [{ payload }]); assert.deepEqual(Object.keys(effective.grantRows[0]), ["payload"])
})
await check("borrowed non-RC readonly transactions fail closed", async () => {
const f = await fixture()
for (const isolation of ["REPEATABLE READ", "SERIALIZABLE"]) {
const owner = await pool.connect()
try { await owner.query("BEGIN ISOLATION LEVEL " + isolation + " READ ONLY"); await assert.rejects(validatePrincipal(f.principal, owner), { code: "STATE_UNAVAILABLE" }) }
finally { await owner.query("ROLLBACK"); owner.release(true) }
}
})
await check("actual reserved alias column refuses rather than silently replacing c star fields", async () => {
const f = await fixture(); let added = false
try {
await pool.query('ALTER TABLE mcp_connections ADD COLUMN "__ps_exists" boolean'); added = true
await assert.rejects(validatePrincipal(f.principal), { code: "STATE_UNAVAILABLE" })
} finally { if (added) await pool.query('ALTER TABLE mcp_connections DROP COLUMN "__ps_exists"') }
assert.equal((await validatePrincipal(f.principal)).id, f.principal.connectionId)
})
await check("independent SQL credential, settings and owner changes between captures refuse", async () => {
const credential = await fixture()
await refusalBetween(credential, async writer => { await writer.query("UPDATE mcp_credentials SET revoked_at=clock_timestamp() WHERE id=$1 AND connection_id=$2", [credential.principal.credentialId, credential.principal.connectionId]) }, "STATE_CONFLICT")
const settings = await fixture()
try { await refusalBetween(settings, async writer => { await writer.query("UPDATE mcp_settings SET enabled=false WHERE id=1") }, "STATE_CONFLICT") }
finally { await pool.query("UPDATE mcp_settings SET enabled=true WHERE id=1") }
const owner = await fixture()
await refusalBetween(owner, async writer => { await writer.query("UPDATE mcp_connections SET owner_id=$2 WHERE id=$1", [owner.principal.connectionId, "owned-source-replacement-" + randomUUID()]) }, "STATE_CONFLICT")
})
await check("actual HMAC portal revoke and private external cutoff interrupt source capture", async () => {
const f = await fixture(), secret = randomBytes(32).toString("hex")
await refusalBetween(f, async () => {
const timestamp = String(Math.floor(Date.now() / 1000)), raw = Buffer.from(JSON.stringify({ eventId: randomUUID(), userId: f.actor.id, type: "sessions.revoked" }))
const signature = "sha256=" + createHmac("sha256", secret).update(timestamp + ".").update(raw).digest("hex")
assert.deepEqual(await acceptPortalRevocation(raw, timestamp, signature, secret), { ok: true, duplicate: false })
}, "OWNER_CLAIMS_REVOKED")
await assert.rejects(validatePrincipal(f.principal), { code: "OWNER_CLAIMS_REVOKED" })
})
await check("duplicate signed revocation repairs the external cutoff without moving recorded authority", async () => {
const f = await fixture(), secret = randomBytes(32).toString("hex")
const cutoffSeconds = Math.floor(Date.now() / 1000) - 10
const eventId = randomUUID()
const raw = Buffer.from(JSON.stringify({ eventId, userId: f.actor.id, type: "sessions.revoked" }))
const deliver = (seconds: number, body = raw) => {
const timestamp = String(seconds)
const signature = "sha256=" + createHmac("sha256", secret).update(timestamp + ".").update(body).digest("hex")
return acceptPortalRevocation(body, timestamp, signature, secret)
}
assert.deepEqual(await deliver(cutoffSeconds), { ok: true, duplicate: false })
const latest = cutoffSeconds * 1000 + 123
const newer = Buffer.from(JSON.stringify({ version: 2, eventId: randomUUID(), userId: f.actor.id,
type: "sessions.revoked", eventOccurredAt: latest }))
assert.deepEqual(await deliver(cutoffSeconds, newer), { ok: true, duplicate: false })
const file = join(resolve(process.env.MCP_STATE_DIR!), "owner-revocations", createHash("sha256").update(f.actor.id).digest("hex") + ".json")
await unlink(file)
const conflict = Buffer.from(JSON.stringify({ eventId, userId: f.actor.id, type: "user.disabled" }))
await assert.rejects(deliver(cutoffSeconds + 8, conflict), { code: "STATE_CONFLICT" })
await assert.rejects(readFile(file), { code: "ENOENT" })
assert.deepEqual(await deliver(cutoffSeconds + 8), { ok: true, duplicate: true })
assert.deepEqual(JSON.parse(await readFile(file, "utf8")), { invalidBefore: latest })
const externalLatest = latest + 1
await writeFile(file, JSON.stringify({ invalidBefore: externalLatest }))
assert.deepEqual(await deliver(cutoffSeconds + 9), { ok: true, duplicate: true })
assert.deepEqual(JSON.parse(await readFile(file, "utf8")), { invalidBefore: externalLatest })
const { rows: [row] } = await pool.query<{ invalid_before: Date; audits: number }>(
`SELECT invalid_before, (SELECT count(*)::int FROM mcp_audit WHERE action='owner.revoke' AND payload->>'ownerId'=$1) AS audits
FROM mcp_owner_revocations WHERE owner_id=$1`, [f.actor.id])
assert.equal(row.invalid_before.getTime(), latest)
assert.equal(row.audits, 2)
})
await check("actual SQL numeric policy drift hidden by JS rounding refuses the SQL digest", async () => {
const f = await fixture()
await pool.query("UPDATE mcp_connections SET policy=jsonb_set(policy,'{limits,callsPerMinute}','50'::jsonb) WHERE id=$1", [f.principal.connectionId])
const observed = await refusalBetween(f, async writer => { await writer.query("UPDATE mcp_connections SET policy=jsonb_set(policy,'{limits,callsPerMinute}','50.000000000000000001'::jsonb) WHERE id=$1", [f.principal.connectionId]) }, "STATE_CONFLICT")
assert.deepEqual(observed.observedNumbers, [50, 50], "Actual driver JSON values round alike while the fixed SQL hashes must differ")
})
await check("oversized PRESENT grant preserves portal then principal then grant refusal order", async () => {
const valid = await fixture(); await grant(valid, true)
await assert.rejects(effectiveMcpConnectionSource(valid.principal), { code: "STATE_UNAVAILABLE" })
const invalid = await fixture(); await grant(invalid, true)
await pool.query("UPDATE mcp_credentials SET revoked_at=clock_timestamp() WHERE id=$1 AND connection_id=$2", [invalid.principal.credentialId, invalid.principal.connectionId])
await assert.rejects(effectiveMcpConnectionSource(invalid.principal), { code: "UNAUTHORIZED" })
const revoked = await fixture(); await grant(revoked, true)
await pool.query("INSERT INTO mcp_owner_revocations(owner_id,invalid_before) VALUES($1,clock_timestamp())", [revoked.actor.id])
await assert.rejects(effectiveMcpConnectionSource(revoked.principal), { code: "OWNER_CLAIMS_REVOKED" })
})
await check("actual SQL numeric grant drift also refuses despite equal JS numbers", async () => {
const f = await fixture(); await grant(f)
await pool.query("UPDATE mcp_grants SET payload=jsonb_set(payload,'{scope,serverIds}','[50]'::jsonb) WHERE connection_id=$1", [f.principal.connectionId])
const observed = await refusalBetween(f, async writer => {
await writer.query("UPDATE mcp_grants SET payload=jsonb_set(payload,'{scope,serverIds}','[50.000000000000000001]'::jsonb) WHERE connection_id=$1", [f.principal.connectionId])
}, "STATE_CONFLICT", true)
assert.deepEqual(observed.observedGrantNumbers, [50, 50])
})
await check("oversized PRESENT connection is refused before its opaque payload crosses the reader", async () => {
const f = await fixture(); let added = false
try {
await pool.query('ALTER TABLE mcp_connections ADD COLUMN owned_source_padding text'); added = true
await pool.query("UPDATE mcp_connections SET owned_source_padding=repeat('x',8388609) WHERE id=$1", [f.principal.connectionId])
await assert.rejects(validatePrincipal(f.principal), { code: "STATE_UNAVAILABLE" })
assert.equal((await pool.query("SELECT id FROM mcp_connections WHERE id=$1", [f.principal.connectionId])).rowCount, 1)
} finally { if (added) await pool.query('ALTER TABLE mcp_connections DROP COLUMN owned_source_padding') }
})
await check("bounded real driver reuses one protocol parse while binding different current principals and grants", async () => {
const f = await fixture(), other = await fixture(); await grant(f)
const lease = await connectProbeStorage({ deadlineAt: Date.now() + 30000 })
const client = { query: ((text: string, values?: unknown[]) => lease.query(text, values)) as PoolClient["query"] }
try {
assert.equal((await effectiveMcpConnectionSource(f.principal, client)).connection.policy.scope.allowGlobal, false)
assert.equal((await validatePrincipal(other.principal, client)).id, other.principal.connectionId)
await pool.query("UPDATE mcp_grants SET revoked_at=clock_timestamp() WHERE connection_id=$1", [f.principal.connectionId])
assert.equal((await effectiveMcpConnectionSource(f.principal, client)).connection.policy.scope.allowGlobal, true)
const prepared = (await lease.query("SELECT name,statement,from_sql,generic_plans,custom_plans FROM pg_prepared_statements WHERE name=$1", [principalSourceStatementName])).rows
assert.equal(prepared.length, 1); assert.equal(prepared[0].statement, principalSourceSql); assert.equal(prepared[0].from_sql, false)
assert(Number(prepared[0].generic_plans) + Number(prepared[0].custom_plans) >= 6)
await pool.query("UPDATE mcp_credentials SET revoked_at=clock_timestamp() WHERE id=$1", [other.principal.credentialId])
await assert.rejects(validatePrincipal(other.principal, client), { code: "UNAUTHORIZED" })
} finally { lease.release() }
})
await check("prepared source still rejects a real independent policy change BETWEEN captures", async () => {
const f = await fixture(), lease = await connectProbeStorage({ deadlineAt: Date.now() + 30000 })
let captures = 0
const client = { query: (async (text: string, values?: unknown[]) => {
const result = await lease.query(text, values)
if (text === principalSourceSql && ++captures === 1) await pool.query("UPDATE mcp_connections SET policy=jsonb_set(policy,'{limits,callsPerMinute}','41'::jsonb) WHERE id=$1", [f.principal.connectionId])
return result
}) as PoolClient["query"] }
try { await assert.rejects(validatePrincipal(f.principal, client), { code: "STATE_CONFLICT" }); assert.equal(captures, 2) }
finally { lease.release() }
})
await check("actual cached result-shape DDL failure destroys bounded owner with no fallback and fresh checkout succeeds", async () => {
const f = await fixture(), lease = await connectProbeStorage({ deadlineAt: Date.now() + 30000 })
const client = { query: ((text: string, values?: unknown[]) => lease.query(text, values)) as PoolClient["query"] }
let added = false
try {
await validatePrincipal(f.principal, client)
await pool.query('ALTER TABLE mcp_connections ADD COLUMN owned_prepared_shape text'); added = true
await assert.rejects(validatePrincipal(f.principal, client), error => error instanceof ProbeStorageUnknown)
assert.equal(lease.lifetimeSignal?.aborted, true)
await assert.rejects(lease.query(principalSourceSql, [f.principal.credentialId, f.principal.connectionId, false]), error => error instanceof ProbeStorageRefused)
const fresh = await connectProbeStorage({ deadlineAt: Date.now() + 30000 })
try {
const current = { query: ((text: string, values?: unknown[]) => fresh.query(text, values)) as PoolClient["query"] }
assert.equal((await validatePrincipal(f.principal, current)).id, f.principal.connectionId)
} finally { fresh.release(true) }
} finally { lease.release(true); if (added) await pool.query('ALTER TABLE mcp_connections DROP COLUMN owned_prepared_shape') }
})
console.log("Owned principal security source SQL:", JSON.stringify({ groups: groups.length, names: groups, currentMigrations: MIGRATION_MANIFEST.length,
actualConnectionAndTokenFactories: true, actualFixedSqlAndPrivateFilesystem: true, independentSqlWriterBetweenCaptures: true,
actualReservedAliasColumnRefused: true, sqlNumericDigestDriftRefused: true, oversizedPresentGrantPrecedence: true,
componentSqlOnly: true, actualReadonlyMetadataHandlerAccepted: false, actualFullMcpMutationAccepted: false, httpRequests: 0, nativeRequests: 0,
automaticReplay: false, productionDatabaseTouched: false }))
} finally {
try {
if (connectionIds.length) await pool.query("UPDATE mcp_connections SET policy=jsonb_set(policy,'{status}','\"revoked\"'::jsonb) WHERE id=ANY($1::uuid[])", [connectionIds])
if (priorEnabled !== undefined) await pool.query("UPDATE mcp_settings SET enabled=$1 WHERE id=1", [priorEnabled])
} finally { await closePool() }
}