Files
MikrotikManager/backend/src/services/bandwidth-control-identity.ts
T

101 lines
6.9 KiB
TypeScript

/** One bounded, read-only MVCC snapshot of the five existing core identity
* observations. This does not cache authority or replace a dispatch fence. */
import { z } from "zod"
import { BANDWIDTH_CONTROL_ROLE_SQL, captureBandwidthControlRoleExpected, validateBandwidthControlRuntimeRoleRows } from "./bandwidth-control-role.js"
import { BANDWIDTH_CONTROL_CATALOG_SQL, validateBandwidthControlCatalogRows } from "./bandwidth-control-catalog.js"
export interface BandwidthControlIdentitySql {
query(text: string, values?: unknown[]): Promise<{ rows: Record<string, unknown>[] }>
}
const label = z.string().min(1).max(63).refine(value => value.trim() === value && Buffer.byteLength(value) <= 63 && !/[\x00-\x1f\x7f]/.test(value))
const hash = z.string().regex(/^[a-f0-9]{64}$/)
const expectedSchema = z.object({ databaseName: label, runtimeRole: label, ownerRole: label, applicationRole: label,
databaseOid: z.number().int().min(1).max(4294967295), installationId: z.string().uuid(), controlGeneration: z.string().uuid(),
sourceRecordSha256: hash, eventKeySha256: hash, catalogSha256: hash }).strict()
export type BandwidthControlIdentityExpected = z.infer<typeof expectedSchema>
export class BandwidthControlIdentityRefused extends Error {
readonly code = "BANDWIDTH_CONTROL_IDENTITY_REFUSED"
constructor() { super("Bandwidth control identity refused") }
}
function refuse(): never { throw new BandwidthControlIdentityRefused() }
const plain = (value: unknown): value is Record<string, unknown> => !!value && typeof value === "object" && Object.getPrototypeOf(value) === Object.prototype
type Kind = "role" | "database" | "isolation" | "source" | "catalog"
// The embedded role/catalog statements are the SAME fixed statements used by
// their standalone observers. No provider/caller can supply a SQL fragment.
const OBSERVE = `/* bandwidth-control:identity */ WITH
core_role AS MATERIALIZED (${BANDWIDTH_CONTROL_ROLE_SQL}),
core_database AS MATERIALIZED (
SELECT d.oid::pg_catalog.int8 AS oid,r.rolname AS owner
FROM pg_catalog.pg_database d JOIN pg_catalog.pg_roles r ON r.oid=d.datdba
WHERE d.datname=pg_catalog.current_database() LIMIT 2),
core_isolation AS MATERIALIZED (
SELECT EXISTS(SELECT 1 FROM pg_catalog.pg_roles r WHERE r.rolname=$4 AND
(r.rolsuper OR r.rolcreaterole OR r.rolreplication OR r.rolbypassrls
OR EXISTS(SELECT 1 FROM pg_catalog.pg_roles target WHERE target.rolname=ANY(ARRAY[$2,$3]::pg_catalog.text[]) AND pg_catalog.pg_has_role(r.oid,target.oid,'MEMBER'))
OR pg_catalog.has_schema_privilege(r.oid,'mmapp_control','USAGE') OR pg_catalog.has_schema_privilege(r.oid,'mmapp_control','CREATE'))) AS unsafe),
core_source AS MATERIALIZED (
SELECT installation_id::pg_catalog.text,control_generation::pg_catalog.text,attestation_sha256,event_key_sha256,status
FROM mmapp_control.bandwidth_source_identity WHERE id=1 LIMIT 2),
core_catalog AS MATERIALIZED (${BANDWIDTH_CONTROL_CATALOG_SQL}),
bundled AS (
SELECT 'role'::pg_catalog.text AS kind,pg_catalog.to_jsonb(r)::pg_catalog.text AS raw_json FROM core_role r
UNION ALL SELECT 'database',pg_catalog.to_jsonb(r)::pg_catalog.text FROM core_database r
UNION ALL SELECT 'isolation',pg_catalog.to_jsonb(r)::pg_catalog.text FROM core_isolation r
UNION ALL SELECT 'source',pg_catalog.to_jsonb(r)::pg_catalog.text FROM core_source r
UNION ALL SELECT 'catalog',pg_catalog.to_jsonb(r)::pg_catalog.text FROM core_catalog r),
metered AS (
SELECT kind,raw_json,pg_catalog.row_number() OVER(ORDER BY kind COLLATE "C",raw_json COLLATE "C") AS row_order,
pg_catalog.count(*) OVER() AS row_count,pg_catalog.sum(pg_catalog.octet_length(raw_json)) OVER() AS total_bytes
FROM bundled)
SELECT kind,row_order::pg_catalog.text AS row_order,
CASE WHEN row_count<=234 AND total_bytes<=4194304 AND pg_catalog.octet_length(raw_json)<=131200 THEN raw_json END AS raw_json
FROM metered ORDER BY metered.row_order LIMIT 235`
export const BANDWIDTH_CONTROL_IDENTITY_SQL = OBSERVE
export async function assertBandwidthControlIdentity(sql: BandwidthControlIdentitySql, expected: BandwidthControlIdentityExpected, live: () => void): Promise<void> {
// Capture immutable expectations before awaiting the driver. No new source
// generation, owner, source hash or catalog digest may be adopted from rows.
const captured = Object.freeze(expectedSchema.parse(expected))
captureBandwidthControlRoleExpected({ databaseName: captured.databaseName, runtimeRole: captured.runtimeRole, ownerRole: captured.ownerRole })
live()
let result: { rows: Record<string, unknown>[] }
try { result = await sql.query(OBSERVE, [captured.databaseName, captured.runtimeRole, captured.ownerRole, captured.applicationRole]) }
catch { live(); refuse() }
live()
validateBandwidthControlIdentityRows(result?.rows,captured)
live()
}
/** Pure exact counterpart of the existing five-observation validator. */
export function validateBandwidthControlIdentityRows(rows:unknown,expected:BandwidthControlIdentityExpected):void {
const captured=Object.freeze(expectedSchema.parse(expected))
const role=captureBandwidthControlRoleExpected({databaseName:captured.databaseName,runtimeRole:captured.runtimeRole,ownerRole:captured.ownerRole})
if (!Array.isArray(rows) || rows.length > 234) refuse()
const found: Record<Kind, Record<string, unknown>[]> = { role: [], database: [], isolation: [], source: [], catalog: [] }
const ordinals = new Set<number>()
let bytes = 0
for (const row of rows) {
if (!plain(row) || Object.keys(row).sort().join(",") !== "kind,raw_json,row_order" || typeof row.kind !== "string" || !Object.hasOwn(found, row.kind)
|| typeof row.row_order !== "string" || !/^[1-9][0-9]{0,2}$/.test(row.row_order) || typeof row.raw_json !== "string") refuse()
const ordinal = Number(row.row_order)
if (ordinal > rows.length || ordinals.has(ordinal)) refuse()
ordinals.add(ordinal)
const size = Buffer.byteLength(row.raw_json); bytes += size
if (size > 131200 || bytes > 4194304) refuse()
let value: unknown
try { value = JSON.parse(row.raw_json) } catch { refuse() }
if (!plain(value)) refuse()
const kind = row.kind as Kind
found[kind].push(value)
if (found[kind].length > (kind === "catalog" ? 230 : 1)) refuse()
}
validateBandwidthControlRuntimeRoleRows(found.role, role)
const facts = found.database, isolation = found.isolation, source = found.source
if (facts.length !== 1 || Number(facts[0].oid) !== captured.databaseOid || facts[0].owner !== captured.ownerRole) refuse()
if (isolation.length !== 1 || isolation[0].unsafe !== false) refuse()
if (source.length !== 1 || source[0].installation_id !== captured.installationId || source[0].control_generation !== captured.controlGeneration
|| source[0].attestation_sha256 !== captured.sourceRecordSha256 || source[0].event_key_sha256 !== captured.eventKeySha256 || source[0].status !== "active") refuse()
if (validateBandwidthControlCatalogRows(found.catalog) !== captured.catalogSha256) refuse()
}