789 lines
45 KiB
TypeScript
789 lines
45 KiB
TypeScript
import { getReadDbClient, getWriteDbClient, type DbClient } from "./client.server.js";
|
|
import { EXPECTED_RLS_RUNTIME_CONTRACT } from "./rls-runtime-contract.generated.js";
|
|
|
|
export const EXPECTED_RLS_ENABLED_TABLE_COUNT = EXPECTED_RLS_RUNTIME_CONTRACT.length;
|
|
export const EXPECTED_RLS_FORCED_TABLE_COUNT = EXPECTED_RLS_RUNTIME_CONTRACT.length;
|
|
export const EXPECTED_ADMIN_USER_POLICY_COUNT = 4;
|
|
/**
|
|
* Every SECURITY DEFINER capability the runtime contract knows about, with the
|
|
* EXECUTE grant each restricted role is expected to hold. The readiness probe
|
|
* counts how many of these satisfy the full contract (owner, secdef, config,
|
|
* exact ACL), so the expected count MUST be derived from this list rather than
|
|
* written out separately — a hand-maintained number silently drifts the moment
|
|
* a capability is added, and the probe then reports a mismatch that looks like
|
|
* a broken function instead of a stale constant.
|
|
*/
|
|
export const EXPECTED_RLS_DEFINER_FUNCTIONS = [
|
|
{ signature: "public.hivegrid_is_operator()", appExecute: true, workerExecute: true, authentikJitExecute: false },
|
|
{ signature: "public.hivegrid_reject_admin_audit_mutation()", appExecute: false, workerExecute: false, authentikJitExecute: false },
|
|
{ signature: "public.hivegrid_find_registration_by_email(text)", appExecute: true, workerExecute: false, authentikJitExecute: false },
|
|
{ signature: "public.hivegrid_find_registration_by_token(text)", appExecute: true, workerExecute: false, authentikJitExecute: false },
|
|
{ signature: "public.hivegrid_find_registration_billing_preference(text,text)", appExecute: true, workerExecute: false, authentikJitExecute: false },
|
|
{
|
|
signature: "public.hivegrid_create_registration(text,text,text,text,text,text,text,text,text,text,text,text)",
|
|
appExecute: true,
|
|
workerExecute: false,
|
|
authentikJitExecute: false,
|
|
},
|
|
{
|
|
signature: "public.hivegrid_create_registration_v2(text,text,text,text,text,text,text,integer,integer,text,text,text,text,text)",
|
|
appExecute: true,
|
|
workerExecute: false,
|
|
authentikJitExecute: false,
|
|
},
|
|
{ signature: "public.hivegrid_update_registration(text,text,text,jsonb)", appExecute: true, workerExecute: false, authentikJitExecute: false },
|
|
{ signature: "public.hivegrid_capture_marketing_lead(text,text,jsonb)", appExecute: false, workerExecute: false, authentikJitExecute: false },
|
|
{ signature: "public.hivegrid_find_lead_for_signed_conversion(text)", appExecute: true, workerExecute: false, authentikJitExecute: false },
|
|
{ signature: "public.hivegrid_convert_self_service_lead(text,text,jsonb)", appExecute: true, workerExecute: false, authentikJitExecute: false },
|
|
{ signature: "public.hivegrid_find_blacklist(text,text)", appExecute: true, workerExecute: false, authentikJitExecute: false },
|
|
{ signature: "public.hivegrid_add_blacklist(text,text,text)", appExecute: true, workerExecute: false, authentikJitExecute: false },
|
|
{ signature: "public.hivegrid_record_blacklist_attempt(text,text,text)", appExecute: true, workerExecute: false, authentikJitExecute: false },
|
|
{ signature: "public.hivegrid_find_ip_address(text)", appExecute: true, workerExecute: false, authentikJitExecute: false },
|
|
{
|
|
signature: "public.hivegrid_upsert_ip_address(text,text,text,text,text,text,text,text,text,text,numeric,numeric,text)",
|
|
appExecute: true,
|
|
workerExecute: false,
|
|
authentikJitExecute: false,
|
|
},
|
|
{
|
|
signature: "public.hivegrid_append_ip_address_log(text,text,text,text,text,boolean,text,text,text)",
|
|
appExecute: true,
|
|
workerExecute: false,
|
|
authentikJitExecute: false,
|
|
},
|
|
{
|
|
signature: "public.hivegrid_register_mcp_oauth_client(text,text,text,jsonb,jsonb,jsonb,jsonb,jsonb)",
|
|
appExecute: true,
|
|
workerExecute: false,
|
|
authentikJitExecute: false,
|
|
},
|
|
{ signature: "public.hivegrid_admin_has_permission(text)", appExecute: true, workerExecute: true, authentikJitExecute: false },
|
|
{
|
|
signature: "public.hivegrid_bind_prepared_authentik_admin_v3(text,text,boolean,text[],text,text,text,timestamp with time zone)",
|
|
appExecute: false,
|
|
workerExecute: false,
|
|
authentikJitExecute: true,
|
|
},
|
|
{ signature: "public.hivegrid_lock_admin_sso_audit_head()", appExecute: true, workerExecute: false, authentikJitExecute: false },
|
|
{ signature: "public.hivegrid_append_admin_sso_audit(jsonb,text,text,text)", appExecute: true, workerExecute: false, authentikJitExecute: false },
|
|
{ signature: "public.hivegrid_detach_default_tenant_users(text)", appExecute: false, workerExecute: true, authentikJitExecute: false },
|
|
{ signature: "public.hivegrid_purge_tenant_guarded_rows(text)", appExecute: false, workerExecute: true, authentikJitExecute: false },
|
|
{ signature: "public.hivegrid_minimize_tenant_support_pii(text)", appExecute: false, workerExecute: true, authentikJitExecute: false },
|
|
{ signature: "public.hivegrid_purge_tenant_retained_support(text)", appExecute: false, workerExecute: true, authentikJitExecute: false },
|
|
{ signature: "public.hivegrid_admin_outbox_counts()", appExecute: true, workerExecute: false, authentikJitExecute: false },
|
|
{ signature: "public.hivegrid_authenticate_admin_lead_source(text)", appExecute: true, workerExecute: false, authentikJitExecute: false },
|
|
{
|
|
signature: "public.hivegrid_enqueue_admin_lead_audit(text,text,text,text,text,text,text,text,text,text,jsonb,jsonb)",
|
|
appExecute: true,
|
|
workerExecute: false,
|
|
authentikJitExecute: false,
|
|
},
|
|
{ signature: "public.hivegrid_capture_admin_lead(text,text,text,text,text,text,jsonb)", appExecute: true, workerExecute: false, authentikJitExecute: false },
|
|
{ signature: "public.hivegrid_resolve_platform_lead_notification_recipient(text,text)", appExecute: false, workerExecute: true, authentikJitExecute: false },
|
|
{ signature: "public.hivegrid_resolve_admin_sso_identity_v2(text)", appExecute: true, workerExecute: false, authentikJitExecute: false },
|
|
{ signature: "public.hivegrid_resolve_admin_session_identity(text)", appExecute: true, workerExecute: false, authentikJitExecute: false },
|
|
{ signature: "public.hivegrid_resolve_user_email(text)", appExecute: true, workerExecute: false, authentikJitExecute: false },
|
|
{ signature: "public.hivegrid_resolve_user_session(text)", appExecute: true, workerExecute: false, authentikJitExecute: false },
|
|
{ signature: "public.hivegrid_resolve_trusted_device(text)", appExecute: true, workerExecute: false, authentikJitExecute: false },
|
|
{ signature: "public.hivegrid_resolve_public_form_key(text)", appExecute: true, workerExecute: false, authentikJitExecute: false },
|
|
{ signature: "public.hivegrid_resolve_public_form_slug(text,text)", appExecute: true, workerExecute: false, authentikJitExecute: false },
|
|
{ signature: "public.hivegrid_resolve_public_booking_page(text,text)", appExecute: true, workerExecute: false, authentikJitExecute: false },
|
|
{ signature: "public.hivegrid_resolve_admin_booking_page(text)", appExecute: true, workerExecute: false, authentikJitExecute: false },
|
|
{ signature: "public.hivegrid_resolve_calendar_webhook(text,text)", appExecute: true, workerExecute: false, authentikJitExecute: false },
|
|
{ signature: "public.hivegrid_resolve_aircall_webhook(text)", appExecute: true, workerExecute: false, authentikJitExecute: false },
|
|
{ signature: "public.hivegrid_resolve_hallopetra_webhook(text)", appExecute: true, workerExecute: false, authentikJitExecute: false },
|
|
{ signature: "public.hivegrid_resolve_admin_aircall_webhook(text)", appExecute: true, workerExecute: false, authentikJitExecute: false },
|
|
{ signature: "public.hivegrid_resolve_gmail_mailboxes(text,text)", appExecute: true, workerExecute: false, authentikJitExecute: false },
|
|
{ signature: "public.hivegrid_resolve_microsoft_mailbox(text,text)", appExecute: true, workerExecute: false, authentikJitExecute: false },
|
|
{ signature: "public.hivegrid_resolve_signature_signer(text)", appExecute: true, workerExecute: false, authentikJitExecute: false },
|
|
{ signature: "public.hivegrid_resolve_outbound_email_click(text)", appExecute: true, workerExecute: false, authentikJitExecute: false },
|
|
{ signature: "public.hivegrid_resolve_outbound_email_open(text,text)", appExecute: true, workerExecute: false, authentikJitExecute: false },
|
|
{ signature: "public.hivegrid_resolve_public_knowledge_base(text)", appExecute: true, workerExecute: false, authentikJitExecute: false },
|
|
{ signature: "public.hivegrid_resolve_workspace_invite(text)", appExecute: true, workerExecute: false, authentikJitExecute: false },
|
|
{ signature: "public.hivegrid_resolve_api_key(text,text)", appExecute: true, workerExecute: false, authentikJitExecute: false },
|
|
{ signature: "public.hivegrid_resolve_public_webhook(text,text)", appExecute: true, workerExecute: false, authentikJitExecute: false },
|
|
{ signature: "public.hivegrid_resolve_mcp_oauth_access_token(text)", appExecute: true, workerExecute: false, authentikJitExecute: false },
|
|
{ signature: "public.hivegrid_resolve_mcp_oauth_refresh_token(text)", appExecute: true, workerExecute: false, authentikJitExecute: false },
|
|
{ signature: "public.hivegrid_resolve_mcp_oauth_authorization_code(text)", appExecute: true, workerExecute: false, authentikJitExecute: false },
|
|
{ signature: "public.hivegrid_resolve_tenant_inbound_address(text[])", appExecute: true, workerExecute: false, authentikJitExecute: false },
|
|
{ signature: "public.hivegrid_resolve_email_sequence_provider_message(text)", appExecute: true, workerExecute: false, authentikJitExecute: false },
|
|
{ signature: "public.hivegrid_resolve_event_webhook_attempt(text)", appExecute: true, workerExecute: false, authentikJitExecute: false },
|
|
{ signature: "public.hivegrid_resolve_email_sequence_delivery(text)", appExecute: true, workerExecute: false, authentikJitExecute: false },
|
|
{ signature: "public.hivegrid_form_submission_actor_contract(text,text,text,text)", appExecute: true, workerExecute: true, authentikJitExecute: false },
|
|
] as const;
|
|
|
|
export const EXPECTED_RLS_DEFINER_FUNCTION_COUNT = EXPECTED_RLS_DEFINER_FUNCTIONS.length;
|
|
|
|
const EXPECTED_RLS_DEFINER_FUNCTION_VALUES_SQL = EXPECTED_RLS_DEFINER_FUNCTIONS.map(
|
|
(entry) => `('${entry.signature}', ${entry.appExecute}, ${entry.workerExecute}, ${entry.authentikJitExecute})`
|
|
).join(",\n ");
|
|
export const DEFAULT_RLS_RUNTIME_ROLE = "hivegrid_app";
|
|
export const RLS_RUNTIME_ROLES = ["hivegrid_app", "hivegrid_worker"] as const;
|
|
export type RlsRuntimeRole = (typeof RLS_RUNTIME_ROLES)[number];
|
|
|
|
export type RlsRuntimeMode = "off" | "audit" | "required";
|
|
|
|
export type RlsRuntimeProbe = {
|
|
sessionRoleName: string;
|
|
roleName: string;
|
|
isSuperuser: boolean;
|
|
bypassesRls: boolean;
|
|
enabledTableCount: number;
|
|
protectedTableCount: number;
|
|
expectedTableMismatchCount: number;
|
|
unexpectedRlsTableCount: number;
|
|
expectedForceMismatchCount: number;
|
|
expectedPolicyMismatchCount: number;
|
|
unexpectedPolicyCount: number;
|
|
expectedSequencePrivilegeMismatchCount: number;
|
|
adminUserRlsEnabled: boolean;
|
|
adminUserRlsForced: boolean;
|
|
adminUserPolicyCount: number;
|
|
adminUserOwner: string | null;
|
|
appRoleExists: boolean;
|
|
appRoleCanLogin: boolean;
|
|
appRoleIsSuperuser: boolean;
|
|
appRoleCanCreateDb: boolean;
|
|
appRoleCanCreateRole: boolean;
|
|
appRoleInherits: boolean;
|
|
appRoleReplicates: boolean;
|
|
appRoleBypassesRls: boolean;
|
|
appRoleHasPrivilegedMembership: boolean;
|
|
appRoleHasAnyMembership: boolean;
|
|
workerRoleExists: boolean;
|
|
workerRoleCanLogin: boolean;
|
|
workerRoleIsSuperuser: boolean;
|
|
workerRoleCanCreateDb: boolean;
|
|
workerRoleCanCreateRole: boolean;
|
|
workerRoleInherits: boolean;
|
|
workerRoleReplicates: boolean;
|
|
workerRoleBypassesRls: boolean;
|
|
workerRoleHasPrivilegedMembership: boolean;
|
|
workerRoleHasAnyMembership: boolean;
|
|
authentikJitRoleExists: boolean;
|
|
authentikJitRoleCanLogin: boolean;
|
|
authentikJitRoleIsSuperuser: boolean;
|
|
authentikJitRoleCanCreateDb: boolean;
|
|
authentikJitRoleCanCreateRole: boolean;
|
|
authentikJitRoleInherits: boolean;
|
|
authentikJitRoleReplicates: boolean;
|
|
authentikJitRoleBypassesRls: boolean;
|
|
authentikJitRoleHasPrivilegedMembership: boolean;
|
|
authentikJitRoleHasAnyMembership: boolean;
|
|
definerRoleExists: boolean;
|
|
definerRoleCanLogin: boolean;
|
|
definerRoleIsSuperuser: boolean;
|
|
definerRoleCanCreateDb: boolean;
|
|
definerRoleCanCreateRole: boolean;
|
|
definerRoleInherits: boolean;
|
|
definerRoleReplicates: boolean;
|
|
definerRoleBypassesRls: boolean;
|
|
definerFunctionCount: number;
|
|
definerUnexpectedFunctionCount: number;
|
|
appRoleIsDefinerMember: boolean;
|
|
workerRoleIsDefinerMember: boolean;
|
|
authentikJitRoleIsDefinerMember: boolean;
|
|
tenantContext: string | null;
|
|
userContext: string | null;
|
|
portalUserContext: string | null;
|
|
publicKnowledgeBaseContext: string | null;
|
|
platformAnalyticsContext: string | null;
|
|
};
|
|
|
|
export type RlsRuntimeReadiness = {
|
|
mode: RlsRuntimeMode;
|
|
ready: boolean;
|
|
diagnostics: string[];
|
|
probes: RlsRuntimeProbe[];
|
|
};
|
|
|
|
type RlsProbeClient = Pick<DbClient, "$queryRawUnsafe">;
|
|
|
|
function sqlLiteral(value: string): string {
|
|
return `'${value.replaceAll("'", "''")}'`;
|
|
}
|
|
|
|
const EXPECTED_RLS_TABLE_VALUES_SQL = EXPECTED_RLS_RUNTIME_CONTRACT.map(({ table }) => `(${sqlLiteral(table)})`).join(",\n ");
|
|
const EXPECTED_RLS_POLICY_VALUES_SQL = EXPECTED_RLS_RUNTIME_CONTRACT.flatMap(({ table, policies }) =>
|
|
policies.map(
|
|
({ name, command, roles }) => `(${sqlLiteral(table)}, ${sqlLiteral(name)}, ${sqlLiteral(command)}, ARRAY[${roles.map(sqlLiteral).join(", ")}]::text[])`
|
|
)
|
|
).join(",\n ");
|
|
const EXPECTED_RLS_SEQUENCE_VALUES_SQL = EXPECTED_RLS_RUNTIME_CONTRACT.flatMap((definition) =>
|
|
!("sequences" in definition)
|
|
? []
|
|
: definition.sequences.map(
|
|
({ name, privileges, roles }) =>
|
|
`(${sqlLiteral(name)}, ARRAY[${privileges.map(sqlLiteral).join(", ")}]::text[], ARRAY[${roles.map(sqlLiteral).join(", ")}]::text[])`
|
|
)
|
|
).join(",\n ");
|
|
|
|
/**
|
|
* Verifies the properties that make Postgres RLS effective at runtime. Static
|
|
* CI checks policy coverage; this probe catches a deployment that still uses
|
|
* an owner, superuser, BYPASSRLS role, stale replica, or leaked session GUC.
|
|
*/
|
|
export async function verifyRlsRuntimeReadiness(
|
|
clients: readonly RlsProbeClient[] = uniqueClients(getWriteDbClient(), getReadDbClient()),
|
|
env: NodeJS.ProcessEnv = process.env
|
|
): Promise<RlsRuntimeReadiness> {
|
|
const mode = resolveRlsRuntimeMode(env);
|
|
if (mode === "off") return { mode, ready: true, diagnostics: [], probes: [] };
|
|
|
|
const expectedRole = resolveRlsRuntimeRole(env);
|
|
const probes = await Promise.all(clients.map(readRlsRuntimeProbe));
|
|
const diagnostics = probes.flatMap((probe, index) => diagnoseProbe(probe, expectedRole, index));
|
|
return { mode, ready: diagnostics.length === 0, diagnostics, probes };
|
|
}
|
|
|
|
export async function assertRlsRuntimeReady(clients?: readonly RlsProbeClient[], env: NodeJS.ProcessEnv = process.env): Promise<RlsRuntimeReadiness> {
|
|
const result = await verifyRlsRuntimeReadiness(clients, env);
|
|
if (result.mode === "required" && !result.ready) {
|
|
throw new Error(`RLS runtime readiness failed: ${result.diagnostics.join(", ")}`);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
export function resolveRlsRuntimeMode(env: NodeJS.ProcessEnv = process.env): RlsRuntimeMode {
|
|
const configured = env.RLS_RUNTIME_MODE?.trim().toLowerCase();
|
|
if (!configured) return env.NODE_ENV === "production" ? "required" : "off";
|
|
if (configured !== "off" && configured !== "audit" && configured !== "required") {
|
|
throw new Error("RLS_RUNTIME_MODE must be off, audit, or required");
|
|
}
|
|
if (env.NODE_ENV === "production" && configured !== "required") {
|
|
throw new Error("RLS_RUNTIME_MODE must be required in production");
|
|
}
|
|
return configured;
|
|
}
|
|
|
|
export function resolveRlsRuntimeRole(env: NodeJS.ProcessEnv = process.env): RlsRuntimeRole {
|
|
const configured = env.DATABASE_RUNTIME_ROLE?.trim() || DEFAULT_RLS_RUNTIME_ROLE;
|
|
if (RLS_RUNTIME_ROLES.includes(configured as RlsRuntimeRole)) return configured as RlsRuntimeRole;
|
|
throw new Error(`DATABASE_RUNTIME_ROLE must be one of: ${RLS_RUNTIME_ROLES.join(", ")}`);
|
|
}
|
|
|
|
async function readRlsRuntimeProbe(client: RlsProbeClient): Promise<RlsRuntimeProbe> {
|
|
const rows = await client.$queryRawUnsafe<
|
|
Array<{
|
|
session_role_name: string;
|
|
role_name: string;
|
|
is_superuser: boolean;
|
|
bypasses_rls: boolean;
|
|
enabled_table_count: number;
|
|
protected_table_count: number;
|
|
expected_table_mismatch_count: number;
|
|
unexpected_rls_table_count: number;
|
|
expected_force_mismatch_count: number;
|
|
expected_policy_mismatch_count: number;
|
|
unexpected_policy_count: number;
|
|
expected_sequence_privilege_mismatch_count: number;
|
|
admin_user_rls_enabled: boolean;
|
|
admin_user_rls_forced: boolean;
|
|
admin_user_policy_count: number;
|
|
admin_user_owner: string | null;
|
|
app_role_exists: boolean;
|
|
app_role_can_login: boolean;
|
|
app_role_is_superuser: boolean;
|
|
app_role_can_create_db: boolean;
|
|
app_role_can_create_role: boolean;
|
|
app_role_inherits: boolean;
|
|
app_role_replicates: boolean;
|
|
app_role_bypasses_rls: boolean;
|
|
app_role_has_privileged_membership: boolean;
|
|
app_role_has_any_membership: boolean;
|
|
worker_role_exists: boolean;
|
|
worker_role_can_login: boolean;
|
|
worker_role_is_superuser: boolean;
|
|
worker_role_can_create_db: boolean;
|
|
worker_role_can_create_role: boolean;
|
|
worker_role_inherits: boolean;
|
|
worker_role_replicates: boolean;
|
|
worker_role_bypasses_rls: boolean;
|
|
worker_role_has_privileged_membership: boolean;
|
|
worker_role_has_any_membership: boolean;
|
|
authentik_jit_role_exists: boolean;
|
|
authentik_jit_role_can_login: boolean;
|
|
authentik_jit_role_is_superuser: boolean;
|
|
authentik_jit_role_can_create_db: boolean;
|
|
authentik_jit_role_can_create_role: boolean;
|
|
authentik_jit_role_inherits: boolean;
|
|
authentik_jit_role_replicates: boolean;
|
|
authentik_jit_role_bypasses_rls: boolean;
|
|
authentik_jit_role_has_privileged_membership: boolean;
|
|
authentik_jit_role_has_any_membership: boolean;
|
|
definer_role_exists: boolean;
|
|
definer_role_can_login: boolean;
|
|
definer_role_is_superuser: boolean;
|
|
definer_role_can_create_db: boolean;
|
|
definer_role_can_create_role: boolean;
|
|
definer_role_inherits: boolean;
|
|
definer_role_replicates: boolean;
|
|
definer_role_bypasses_rls: boolean;
|
|
definer_function_count: number;
|
|
definer_unexpected_function_count: number;
|
|
app_role_is_definer_member: boolean;
|
|
worker_role_is_definer_member: boolean;
|
|
authentik_jit_role_is_definer_member: boolean;
|
|
tenant_context: string | null;
|
|
user_context: string | null;
|
|
portal_user_context: string | null;
|
|
public_knowledge_base_context: string | null;
|
|
platform_analytics_context: string | null;
|
|
}>
|
|
>(`
|
|
WITH expected_rls_table(table_name) AS (
|
|
VALUES
|
|
${EXPECTED_RLS_TABLE_VALUES_SQL}
|
|
),
|
|
expected_rls_policy(table_name, policy_name, command, roles) AS (
|
|
VALUES
|
|
${EXPECTED_RLS_POLICY_VALUES_SQL}
|
|
),
|
|
expected_rls_sequence(sequence_name, privileges, roles) AS (
|
|
VALUES
|
|
${EXPECTED_RLS_SEQUENCE_VALUES_SQL}
|
|
),
|
|
expected_definer_function(signature, app_execute, worker_execute, authentik_jit_execute) AS (
|
|
VALUES
|
|
${EXPECTED_RLS_DEFINER_FUNCTION_VALUES_SQL}
|
|
)
|
|
SELECT
|
|
session_user::text AS session_role_name,
|
|
current_user::text AS role_name,
|
|
role.rolsuper AS is_superuser,
|
|
role.rolbypassrls AS bypasses_rls,
|
|
(
|
|
SELECT COUNT(DISTINCT class.oid)::int
|
|
FROM pg_class AS class
|
|
JOIN pg_namespace AS namespace ON namespace.oid = class.relnamespace
|
|
WHERE namespace.nspname = 'public'
|
|
AND class.relkind IN ('r', 'p')
|
|
AND class.relrowsecurity = true
|
|
) AS enabled_table_count,
|
|
(
|
|
SELECT COUNT(DISTINCT class.oid)::int
|
|
FROM pg_class AS class
|
|
JOIN pg_namespace AS namespace ON namespace.oid = class.relnamespace
|
|
WHERE namespace.nspname = 'public'
|
|
AND class.relkind IN ('r', 'p')
|
|
AND class.relrowsecurity = true
|
|
AND class.relforcerowsecurity = true
|
|
) AS protected_table_count,
|
|
(
|
|
SELECT COUNT(*)::int
|
|
FROM expected_rls_table AS expected
|
|
LEFT JOIN pg_class AS class
|
|
ON class.relname = expected.table_name
|
|
AND class.relnamespace = 'public'::regnamespace
|
|
AND class.relkind IN ('r', 'p')
|
|
WHERE class.oid IS NULL OR class.relrowsecurity IS DISTINCT FROM true
|
|
) AS expected_table_mismatch_count,
|
|
(
|
|
SELECT COUNT(*)::int
|
|
FROM pg_class AS class
|
|
JOIN pg_namespace AS namespace ON namespace.oid = class.relnamespace
|
|
WHERE namespace.nspname = 'public'
|
|
AND class.relkind IN ('r', 'p')
|
|
AND class.relrowsecurity = true
|
|
AND NOT EXISTS (
|
|
SELECT 1 FROM expected_rls_table AS expected WHERE expected.table_name = class.relname
|
|
)
|
|
) AS unexpected_rls_table_count,
|
|
(
|
|
SELECT COUNT(*)::int
|
|
FROM expected_rls_table AS expected
|
|
LEFT JOIN pg_class AS class
|
|
ON class.relname = expected.table_name
|
|
AND class.relnamespace = 'public'::regnamespace
|
|
AND class.relkind IN ('r', 'p')
|
|
WHERE class.oid IS NULL OR class.relforcerowsecurity IS DISTINCT FROM true
|
|
) AS expected_force_mismatch_count,
|
|
(
|
|
SELECT COUNT(*)::int
|
|
FROM expected_rls_policy AS expected
|
|
LEFT JOIN pg_class AS class
|
|
ON class.relname = expected.table_name
|
|
AND class.relnamespace = 'public'::regnamespace
|
|
LEFT JOIN pg_policy AS policy
|
|
ON policy.polrelid = class.oid
|
|
AND policy.polname = expected.policy_name
|
|
AND policy.polcmd::text = expected.command
|
|
WHERE policy.polname IS NULL
|
|
OR policy.polpermissive IS DISTINCT FROM true
|
|
OR ARRAY(
|
|
SELECT role.rolname::text
|
|
FROM unnest(policy.polroles) AS policy_role(role_oid)
|
|
JOIN pg_roles AS role ON role.oid = policy_role.role_oid
|
|
ORDER BY role.rolname
|
|
) IS DISTINCT FROM expected.roles
|
|
) AS expected_policy_mismatch_count,
|
|
(
|
|
SELECT COUNT(*)::int
|
|
FROM pg_policy AS policy
|
|
JOIN pg_class AS class ON class.oid = policy.polrelid
|
|
JOIN expected_rls_table AS expected_table ON expected_table.table_name = class.relname
|
|
WHERE class.relnamespace = 'public'::regnamespace
|
|
AND NOT EXISTS (
|
|
SELECT 1
|
|
FROM expected_rls_policy AS expected
|
|
WHERE expected.table_name = class.relname
|
|
AND expected.policy_name = policy.polname
|
|
AND expected.command = policy.polcmd::text
|
|
AND policy.polpermissive = true
|
|
AND ARRAY(
|
|
SELECT role.rolname::text
|
|
FROM unnest(policy.polroles) AS policy_role(role_oid)
|
|
JOIN pg_roles AS role ON role.oid = policy_role.role_oid
|
|
ORDER BY role.rolname
|
|
) = expected.roles
|
|
)
|
|
AND NOT (
|
|
policy.polname LIKE 'hg_portal_%'
|
|
AND ARRAY(
|
|
SELECT role.rolname::text
|
|
FROM unnest(policy.polroles) AS policy_role(role_oid)
|
|
JOIN pg_roles AS role ON role.oid = policy_role.role_oid
|
|
ORDER BY role.rolname
|
|
) = ARRAY['hivegrid_portal']::text[]
|
|
)
|
|
) AS unexpected_policy_count,
|
|
(
|
|
SELECT COUNT(*)::int
|
|
FROM expected_rls_sequence AS expected
|
|
LEFT JOIN pg_class AS class
|
|
ON class.relname = expected.sequence_name
|
|
AND class.relnamespace = 'public'::regnamespace
|
|
AND class.relkind = 'S'
|
|
WHERE class.oid IS NULL
|
|
OR EXISTS (
|
|
SELECT 1
|
|
FROM unnest(expected.roles) AS expected_role(role_name)
|
|
WHERE ARRAY(
|
|
SELECT privilege
|
|
FROM unnest(ARRAY['SELECT', 'UPDATE', 'USAGE']::text[]) AS candidate(privilege)
|
|
WHERE has_sequence_privilege(expected_role.role_name, class.oid, candidate.privilege)
|
|
ORDER BY privilege
|
|
) IS DISTINCT FROM expected.privileges
|
|
)
|
|
OR EXISTS (
|
|
SELECT 1
|
|
FROM aclexplode(COALESCE(class.relacl, acldefault('S', class.relowner))) AS access
|
|
LEFT JOIN pg_roles AS grantee ON grantee.oid = access.grantee
|
|
WHERE access.privilege_type IN ('SELECT', 'UPDATE', 'USAGE')
|
|
AND (
|
|
access.grantee = 0
|
|
OR (
|
|
access.grantee <> class.relowner
|
|
AND NOT (grantee.rolname = ANY(expected.roles))
|
|
)
|
|
)
|
|
)
|
|
) AS expected_sequence_privilege_mismatch_count,
|
|
COALESCE((
|
|
SELECT class.relrowsecurity
|
|
FROM pg_class AS class
|
|
JOIN pg_namespace AS namespace ON namespace.oid = class.relnamespace
|
|
WHERE namespace.nspname = 'public' AND class.relname = 'AdminUser'
|
|
), false) AS admin_user_rls_enabled,
|
|
COALESCE((
|
|
SELECT class.relforcerowsecurity
|
|
FROM pg_class AS class
|
|
JOIN pg_namespace AS namespace ON namespace.oid = class.relnamespace
|
|
WHERE namespace.nspname = 'public' AND class.relname = 'AdminUser'
|
|
), false) AS admin_user_rls_forced,
|
|
(
|
|
SELECT COUNT(*)::int
|
|
FROM pg_policy AS policy
|
|
JOIN pg_class AS class ON class.oid = policy.polrelid
|
|
JOIN pg_namespace AS namespace ON namespace.oid = class.relnamespace
|
|
WHERE namespace.nspname = 'public' AND class.relname = 'AdminUser'
|
|
) AS admin_user_policy_count,
|
|
(
|
|
SELECT owner.rolname::text
|
|
FROM pg_class AS class
|
|
JOIN pg_namespace AS namespace ON namespace.oid = class.relnamespace
|
|
JOIN pg_roles AS owner ON owner.oid = class.relowner
|
|
WHERE namespace.nspname = 'public' AND class.relname = 'AdminUser'
|
|
) AS admin_user_owner,
|
|
EXISTS (SELECT 1 FROM pg_roles WHERE rolname = 'hivegrid_app') AS app_role_exists,
|
|
COALESCE((SELECT rolcanlogin FROM pg_roles WHERE rolname = 'hivegrid_app'), false) AS app_role_can_login,
|
|
COALESCE((SELECT rolsuper FROM pg_roles WHERE rolname = 'hivegrid_app'), false) AS app_role_is_superuser,
|
|
COALESCE((SELECT rolcreatedb FROM pg_roles WHERE rolname = 'hivegrid_app'), false) AS app_role_can_create_db,
|
|
COALESCE((SELECT rolcreaterole FROM pg_roles WHERE rolname = 'hivegrid_app'), false) AS app_role_can_create_role,
|
|
COALESCE((SELECT rolinherit FROM pg_roles WHERE rolname = 'hivegrid_app'), false) AS app_role_inherits,
|
|
COALESCE((SELECT rolreplication FROM pg_roles WHERE rolname = 'hivegrid_app'), false) AS app_role_replicates,
|
|
COALESCE((SELECT rolbypassrls FROM pg_roles WHERE rolname = 'hivegrid_app'), false) AS app_role_bypasses_rls,
|
|
EXISTS (
|
|
SELECT 1 FROM pg_roles AS privileged
|
|
WHERE privileged.rolname <> 'hivegrid_rls_definer'
|
|
AND (privileged.rolsuper OR privileged.rolcreatedb OR privileged.rolcreaterole OR privileged.rolreplication OR privileged.rolbypassrls)
|
|
AND pg_has_role('hivegrid_app', privileged.rolname, 'MEMBER')
|
|
) AS app_role_has_privileged_membership,
|
|
EXISTS (
|
|
SELECT 1 FROM pg_roles AS granted_role
|
|
WHERE granted_role.rolname <> 'hivegrid_app'
|
|
AND pg_has_role('hivegrid_app', granted_role.oid, 'MEMBER')
|
|
) AS app_role_has_any_membership,
|
|
EXISTS (SELECT 1 FROM pg_roles WHERE rolname = 'hivegrid_worker') AS worker_role_exists,
|
|
COALESCE((SELECT rolcanlogin FROM pg_roles WHERE rolname = 'hivegrid_worker'), false) AS worker_role_can_login,
|
|
COALESCE((SELECT rolsuper FROM pg_roles WHERE rolname = 'hivegrid_worker'), false) AS worker_role_is_superuser,
|
|
COALESCE((SELECT rolcreatedb FROM pg_roles WHERE rolname = 'hivegrid_worker'), false) AS worker_role_can_create_db,
|
|
COALESCE((SELECT rolcreaterole FROM pg_roles WHERE rolname = 'hivegrid_worker'), false) AS worker_role_can_create_role,
|
|
COALESCE((SELECT rolinherit FROM pg_roles WHERE rolname = 'hivegrid_worker'), false) AS worker_role_inherits,
|
|
COALESCE((SELECT rolreplication FROM pg_roles WHERE rolname = 'hivegrid_worker'), false) AS worker_role_replicates,
|
|
COALESCE((SELECT rolbypassrls FROM pg_roles WHERE rolname = 'hivegrid_worker'), false) AS worker_role_bypasses_rls,
|
|
EXISTS (
|
|
SELECT 1 FROM pg_roles AS privileged
|
|
WHERE privileged.rolname <> 'hivegrid_rls_definer'
|
|
AND (privileged.rolsuper OR privileged.rolcreatedb OR privileged.rolcreaterole OR privileged.rolreplication OR privileged.rolbypassrls)
|
|
AND pg_has_role('hivegrid_worker', privileged.rolname, 'MEMBER')
|
|
) AS worker_role_has_privileged_membership,
|
|
EXISTS (
|
|
SELECT 1 FROM pg_roles AS granted_role
|
|
WHERE granted_role.rolname <> 'hivegrid_worker'
|
|
AND pg_has_role('hivegrid_worker', granted_role.oid, 'MEMBER')
|
|
) AS worker_role_has_any_membership,
|
|
EXISTS (SELECT 1 FROM pg_roles WHERE rolname = 'hivegrid_authentik_jit') AS authentik_jit_role_exists,
|
|
COALESCE((SELECT rolcanlogin FROM pg_roles WHERE rolname = 'hivegrid_authentik_jit'), false) AS authentik_jit_role_can_login,
|
|
COALESCE((SELECT rolsuper FROM pg_roles WHERE rolname = 'hivegrid_authentik_jit'), false) AS authentik_jit_role_is_superuser,
|
|
COALESCE((SELECT rolcreatedb FROM pg_roles WHERE rolname = 'hivegrid_authentik_jit'), false) AS authentik_jit_role_can_create_db,
|
|
COALESCE((SELECT rolcreaterole FROM pg_roles WHERE rolname = 'hivegrid_authentik_jit'), false) AS authentik_jit_role_can_create_role,
|
|
COALESCE((SELECT rolinherit FROM pg_roles WHERE rolname = 'hivegrid_authentik_jit'), false) AS authentik_jit_role_inherits,
|
|
COALESCE((SELECT rolreplication FROM pg_roles WHERE rolname = 'hivegrid_authentik_jit'), false) AS authentik_jit_role_replicates,
|
|
COALESCE((SELECT rolbypassrls FROM pg_roles WHERE rolname = 'hivegrid_authentik_jit'), false) AS authentik_jit_role_bypasses_rls,
|
|
EXISTS (
|
|
SELECT 1 FROM pg_roles AS privileged
|
|
WHERE privileged.rolname <> 'hivegrid_rls_definer'
|
|
AND (privileged.rolsuper OR privileged.rolcreatedb OR privileged.rolcreaterole OR privileged.rolreplication OR privileged.rolbypassrls)
|
|
AND pg_has_role('hivegrid_authentik_jit', privileged.rolname, 'MEMBER')
|
|
) AS authentik_jit_role_has_privileged_membership,
|
|
EXISTS (
|
|
SELECT 1 FROM pg_roles AS granted_role
|
|
WHERE granted_role.rolname <> 'hivegrid_authentik_jit'
|
|
AND pg_has_role('hivegrid_authentik_jit', granted_role.oid, 'MEMBER')
|
|
) AS authentik_jit_role_has_any_membership,
|
|
EXISTS (SELECT 1 FROM pg_roles WHERE rolname = 'hivegrid_rls_definer') AS definer_role_exists,
|
|
COALESCE((SELECT rolcanlogin FROM pg_roles WHERE rolname = 'hivegrid_rls_definer'), false) AS definer_role_can_login,
|
|
COALESCE((SELECT rolsuper FROM pg_roles WHERE rolname = 'hivegrid_rls_definer'), false) AS definer_role_is_superuser,
|
|
COALESCE((SELECT rolcreatedb FROM pg_roles WHERE rolname = 'hivegrid_rls_definer'), false) AS definer_role_can_create_db,
|
|
COALESCE((SELECT rolcreaterole FROM pg_roles WHERE rolname = 'hivegrid_rls_definer'), false) AS definer_role_can_create_role,
|
|
COALESCE((SELECT rolinherit FROM pg_roles WHERE rolname = 'hivegrid_rls_definer'), false) AS definer_role_inherits,
|
|
COALESCE((SELECT rolreplication FROM pg_roles WHERE rolname = 'hivegrid_rls_definer'), false) AS definer_role_replicates,
|
|
COALESCE((SELECT rolbypassrls FROM pg_roles WHERE rolname = 'hivegrid_rls_definer'), false) AS definer_role_bypasses_rls,
|
|
(
|
|
SELECT COUNT(*)::int
|
|
FROM expected_definer_function AS expected
|
|
JOIN pg_proc AS procedure ON procedure.oid = to_regprocedure(expected.signature)
|
|
JOIN pg_namespace AS namespace ON namespace.oid = procedure.pronamespace
|
|
JOIN pg_roles AS owner ON owner.oid = procedure.proowner
|
|
WHERE namespace.nspname = 'public'
|
|
AND owner.rolname = 'hivegrid_rls_definer'
|
|
AND procedure.prokind = 'f'
|
|
AND procedure.prosecdef = true
|
|
AND procedure.proconfig @> ARRAY['search_path=pg_catalog, public', 'row_security=off']::text[]
|
|
AND has_function_privilege('hivegrid_app', procedure.oid, 'EXECUTE') = expected.app_execute
|
|
AND has_function_privilege('hivegrid_worker', procedure.oid, 'EXECUTE') = expected.worker_execute
|
|
AND has_function_privilege('hivegrid_authentik_jit', procedure.oid, 'EXECUTE') = expected.authentik_jit_execute
|
|
AND NOT EXISTS (
|
|
SELECT 1
|
|
FROM aclexplode(COALESCE(procedure.proacl, acldefault('f', procedure.proowner))) AS access
|
|
LEFT JOIN pg_roles AS grantee ON grantee.oid = access.grantee
|
|
WHERE access.privilege_type = 'EXECUTE'
|
|
AND (
|
|
access.grantee = 0
|
|
OR (
|
|
access.grantee <> procedure.proowner
|
|
AND NOT (expected.app_execute AND grantee.rolname = 'hivegrid_app')
|
|
AND NOT (expected.worker_execute AND grantee.rolname = 'hivegrid_worker')
|
|
AND NOT (expected.authentik_jit_execute AND grantee.rolname = 'hivegrid_authentik_jit')
|
|
)
|
|
)
|
|
)
|
|
) AS definer_function_count,
|
|
(
|
|
SELECT COUNT(*)::int
|
|
FROM pg_proc AS procedure
|
|
JOIN pg_roles AS owner ON owner.oid = procedure.proowner
|
|
WHERE owner.rolname = 'hivegrid_rls_definer'
|
|
AND procedure.proname NOT LIKE 'hivegrid_portal_%'
|
|
AND NOT EXISTS (
|
|
SELECT 1
|
|
FROM expected_definer_function AS expected
|
|
WHERE procedure.oid = to_regprocedure(expected.signature)
|
|
)
|
|
) AS definer_unexpected_function_count,
|
|
pg_has_role('hivegrid_app', 'hivegrid_rls_definer', 'MEMBER') AS app_role_is_definer_member,
|
|
pg_has_role('hivegrid_worker', 'hivegrid_rls_definer', 'MEMBER') AS worker_role_is_definer_member,
|
|
pg_has_role('hivegrid_authentik_jit', 'hivegrid_rls_definer', 'MEMBER') AS authentik_jit_role_is_definer_member,
|
|
NULLIF(current_setting('app.tenant_id', true), '') AS tenant_context,
|
|
NULLIF(current_setting('app.user_id', true), '') AS user_context,
|
|
NULLIF(current_setting('app.portal_user_id', true), '') AS portal_user_context,
|
|
NULLIF(current_setting('app.public_knowledge_base_id', true), '') AS public_knowledge_base_context,
|
|
NULLIF(current_setting('app.platform_analytics', true), '') AS platform_analytics_context
|
|
FROM pg_roles AS role
|
|
WHERE role.rolname = current_user
|
|
`);
|
|
const row = rows[0];
|
|
if (
|
|
!row ||
|
|
typeof row.session_role_name !== "string" ||
|
|
typeof row.role_name !== "string" ||
|
|
!Number.isInteger(row.enabled_table_count) ||
|
|
!Number.isInteger(row.protected_table_count) ||
|
|
!Number.isInteger(row.expected_table_mismatch_count) ||
|
|
!Number.isInteger(row.unexpected_rls_table_count) ||
|
|
!Number.isInteger(row.expected_force_mismatch_count) ||
|
|
!Number.isInteger(row.expected_policy_mismatch_count) ||
|
|
!Number.isInteger(row.unexpected_policy_count) ||
|
|
!Number.isInteger(row.expected_sequence_privilege_mismatch_count) ||
|
|
!Number.isInteger(row.admin_user_policy_count) ||
|
|
!Number.isInteger(row.definer_function_count) ||
|
|
!Number.isInteger(row.definer_unexpected_function_count)
|
|
) {
|
|
throw new Error("RLS runtime readiness returned an invalid database probe");
|
|
}
|
|
return {
|
|
sessionRoleName: row.session_role_name,
|
|
roleName: row.role_name,
|
|
isSuperuser: row.is_superuser,
|
|
bypassesRls: row.bypasses_rls,
|
|
enabledTableCount: row.enabled_table_count,
|
|
protectedTableCount: row.protected_table_count,
|
|
expectedTableMismatchCount: row.expected_table_mismatch_count,
|
|
unexpectedRlsTableCount: row.unexpected_rls_table_count,
|
|
expectedForceMismatchCount: row.expected_force_mismatch_count,
|
|
expectedPolicyMismatchCount: row.expected_policy_mismatch_count,
|
|
unexpectedPolicyCount: row.unexpected_policy_count,
|
|
expectedSequencePrivilegeMismatchCount: row.expected_sequence_privilege_mismatch_count,
|
|
adminUserRlsEnabled: row.admin_user_rls_enabled,
|
|
adminUserRlsForced: row.admin_user_rls_forced,
|
|
adminUserPolicyCount: row.admin_user_policy_count,
|
|
adminUserOwner: row.admin_user_owner,
|
|
appRoleExists: row.app_role_exists,
|
|
appRoleCanLogin: row.app_role_can_login,
|
|
appRoleIsSuperuser: row.app_role_is_superuser,
|
|
appRoleCanCreateDb: row.app_role_can_create_db,
|
|
appRoleCanCreateRole: row.app_role_can_create_role,
|
|
appRoleInherits: row.app_role_inherits,
|
|
appRoleReplicates: row.app_role_replicates,
|
|
appRoleBypassesRls: row.app_role_bypasses_rls,
|
|
appRoleHasPrivilegedMembership: row.app_role_has_privileged_membership,
|
|
appRoleHasAnyMembership: row.app_role_has_any_membership,
|
|
workerRoleExists: row.worker_role_exists,
|
|
workerRoleCanLogin: row.worker_role_can_login,
|
|
workerRoleIsSuperuser: row.worker_role_is_superuser,
|
|
workerRoleCanCreateDb: row.worker_role_can_create_db,
|
|
workerRoleCanCreateRole: row.worker_role_can_create_role,
|
|
workerRoleInherits: row.worker_role_inherits,
|
|
workerRoleReplicates: row.worker_role_replicates,
|
|
workerRoleBypassesRls: row.worker_role_bypasses_rls,
|
|
workerRoleHasPrivilegedMembership: row.worker_role_has_privileged_membership,
|
|
workerRoleHasAnyMembership: row.worker_role_has_any_membership,
|
|
authentikJitRoleExists: row.authentik_jit_role_exists,
|
|
authentikJitRoleCanLogin: row.authentik_jit_role_can_login,
|
|
authentikJitRoleIsSuperuser: row.authentik_jit_role_is_superuser,
|
|
authentikJitRoleCanCreateDb: row.authentik_jit_role_can_create_db,
|
|
authentikJitRoleCanCreateRole: row.authentik_jit_role_can_create_role,
|
|
authentikJitRoleInherits: row.authentik_jit_role_inherits,
|
|
authentikJitRoleReplicates: row.authentik_jit_role_replicates,
|
|
authentikJitRoleBypassesRls: row.authentik_jit_role_bypasses_rls,
|
|
authentikJitRoleHasPrivilegedMembership: row.authentik_jit_role_has_privileged_membership,
|
|
authentikJitRoleHasAnyMembership: row.authentik_jit_role_has_any_membership,
|
|
definerRoleExists: row.definer_role_exists,
|
|
definerRoleCanLogin: row.definer_role_can_login,
|
|
definerRoleIsSuperuser: row.definer_role_is_superuser,
|
|
definerRoleCanCreateDb: row.definer_role_can_create_db,
|
|
definerRoleCanCreateRole: row.definer_role_can_create_role,
|
|
definerRoleInherits: row.definer_role_inherits,
|
|
definerRoleReplicates: row.definer_role_replicates,
|
|
definerRoleBypassesRls: row.definer_role_bypasses_rls,
|
|
definerFunctionCount: row.definer_function_count,
|
|
definerUnexpectedFunctionCount: row.definer_unexpected_function_count,
|
|
appRoleIsDefinerMember: row.app_role_is_definer_member,
|
|
workerRoleIsDefinerMember: row.worker_role_is_definer_member,
|
|
authentikJitRoleIsDefinerMember: row.authentik_jit_role_is_definer_member,
|
|
tenantContext: row.tenant_context,
|
|
userContext: row.user_context,
|
|
portalUserContext: row.portal_user_context,
|
|
publicKnowledgeBaseContext: row.public_knowledge_base_context,
|
|
platformAnalyticsContext: row.platform_analytics_context,
|
|
};
|
|
}
|
|
|
|
function diagnoseProbe(probe: RlsRuntimeProbe, expectedRole: string, index: number): string[] {
|
|
const prefix = `database_${index + 1}`;
|
|
return [
|
|
...(probe.sessionRoleName === expectedRole ? [] : [`${prefix}:runtime_session_role_mismatch`]),
|
|
...(probe.roleName === expectedRole ? [] : [`${prefix}:runtime_role_mismatch`]),
|
|
...(probe.sessionRoleName === probe.roleName ? [] : [`${prefix}:runtime_role_switch_detected`]),
|
|
...(!probe.isSuperuser ? [] : [`${prefix}:runtime_role_superuser`]),
|
|
...(!probe.bypassesRls ? [] : [`${prefix}:runtime_role_bypassrls`]),
|
|
...(probe.appRoleExists ? [] : [`${prefix}:app_role_missing`]),
|
|
...(!probe.appRoleExists || probe.appRoleCanLogin ? [] : [`${prefix}:app_role_no_login`]),
|
|
...(!probe.appRoleIsSuperuser ? [] : [`${prefix}:app_role_superuser`]),
|
|
...(!probe.appRoleCanCreateDb ? [] : [`${prefix}:app_role_createdb`]),
|
|
...(!probe.appRoleCanCreateRole ? [] : [`${prefix}:app_role_createrole`]),
|
|
...(!probe.appRoleInherits ? [] : [`${prefix}:app_role_inherit`]),
|
|
...(!probe.appRoleReplicates ? [] : [`${prefix}:app_role_replication`]),
|
|
...(!probe.appRoleBypassesRls ? [] : [`${prefix}:app_role_bypassrls`]),
|
|
...(!probe.appRoleHasPrivilegedMembership ? [] : [`${prefix}:app_role_privileged_membership`]),
|
|
...(!probe.appRoleHasAnyMembership ? [] : [`${prefix}:app_role_unexpected_membership`]),
|
|
...(probe.workerRoleExists ? [] : [`${prefix}:worker_role_missing`]),
|
|
...(!probe.workerRoleExists || probe.workerRoleCanLogin ? [] : [`${prefix}:worker_role_no_login`]),
|
|
...(!probe.workerRoleIsSuperuser ? [] : [`${prefix}:worker_role_superuser`]),
|
|
...(!probe.workerRoleCanCreateDb ? [] : [`${prefix}:worker_role_createdb`]),
|
|
...(!probe.workerRoleCanCreateRole ? [] : [`${prefix}:worker_role_createrole`]),
|
|
...(!probe.workerRoleInherits ? [] : [`${prefix}:worker_role_inherit`]),
|
|
...(!probe.workerRoleReplicates ? [] : [`${prefix}:worker_role_replication`]),
|
|
...(!probe.workerRoleBypassesRls ? [] : [`${prefix}:worker_role_bypassrls`]),
|
|
...(!probe.workerRoleHasPrivilegedMembership ? [] : [`${prefix}:worker_role_privileged_membership`]),
|
|
...(!probe.workerRoleHasAnyMembership ? [] : [`${prefix}:worker_role_unexpected_membership`]),
|
|
...(probe.authentikJitRoleExists ? [] : [`${prefix}:authentik_jit_role_missing`]),
|
|
...(!probe.authentikJitRoleExists || probe.authentikJitRoleCanLogin ? [] : [`${prefix}:authentik_jit_role_no_login`]),
|
|
...(!probe.authentikJitRoleIsSuperuser ? [] : [`${prefix}:authentik_jit_role_superuser`]),
|
|
...(!probe.authentikJitRoleCanCreateDb ? [] : [`${prefix}:authentik_jit_role_createdb`]),
|
|
...(!probe.authentikJitRoleCanCreateRole ? [] : [`${prefix}:authentik_jit_role_createrole`]),
|
|
...(!probe.authentikJitRoleInherits ? [] : [`${prefix}:authentik_jit_role_inherit`]),
|
|
...(!probe.authentikJitRoleReplicates ? [] : [`${prefix}:authentik_jit_role_replication`]),
|
|
...(!probe.authentikJitRoleBypassesRls ? [] : [`${prefix}:authentik_jit_role_bypassrls`]),
|
|
...(!probe.authentikJitRoleHasPrivilegedMembership ? [] : [`${prefix}:authentik_jit_role_privileged_membership`]),
|
|
...(!probe.authentikJitRoleHasAnyMembership ? [] : [`${prefix}:authentik_jit_role_unexpected_membership`]),
|
|
...(probe.definerRoleExists ? [] : [`${prefix}:definer_role_missing`]),
|
|
...(!probe.definerRoleCanLogin ? [] : [`${prefix}:definer_role_must_not_login`]),
|
|
...(!probe.definerRoleIsSuperuser ? [] : [`${prefix}:definer_role_superuser`]),
|
|
...(!probe.definerRoleCanCreateDb ? [] : [`${prefix}:definer_role_createdb`]),
|
|
...(!probe.definerRoleCanCreateRole ? [] : [`${prefix}:definer_role_createrole`]),
|
|
...(!probe.definerRoleInherits ? [] : [`${prefix}:definer_role_inherit`]),
|
|
...(!probe.definerRoleReplicates ? [] : [`${prefix}:definer_role_replication`]),
|
|
...(probe.definerRoleBypassesRls ? [] : [`${prefix}:definer_role_missing_bypassrls`]),
|
|
...(probe.definerFunctionCount === EXPECTED_RLS_DEFINER_FUNCTION_COUNT ? [] : [`${prefix}:definer_function_owner_mismatch`]),
|
|
...(probe.definerUnexpectedFunctionCount === 0 ? [] : [`${prefix}:definer_unexpected_function_owner`]),
|
|
...(!probe.appRoleIsDefinerMember ? [] : [`${prefix}:app_role_is_definer_member`]),
|
|
...(!probe.workerRoleIsDefinerMember ? [] : [`${prefix}:worker_role_is_definer_member`]),
|
|
...(!probe.authentikJitRoleIsDefinerMember ? [] : [`${prefix}:authentik_jit_role_is_definer_member`]),
|
|
...(probe.enabledTableCount === EXPECTED_RLS_ENABLED_TABLE_COUNT ? [] : [`${prefix}:rls_enabled_table_count_mismatch`]),
|
|
...(probe.protectedTableCount === EXPECTED_RLS_FORCED_TABLE_COUNT ? [] : [`${prefix}:rls_forced_table_count_mismatch`]),
|
|
...(probe.expectedTableMismatchCount === 0 ? [] : [`${prefix}:rls_expected_table_mismatch`]),
|
|
...(probe.unexpectedRlsTableCount === 0 ? [] : [`${prefix}:rls_unexpected_table`]),
|
|
...(probe.expectedForceMismatchCount === 0 ? [] : [`${prefix}:rls_expected_force_mismatch`]),
|
|
...(probe.expectedPolicyMismatchCount === 0 ? [] : [`${prefix}:rls_expected_policy_mismatch`]),
|
|
...(probe.unexpectedPolicyCount === 0 ? [] : [`${prefix}:rls_unexpected_policy`]),
|
|
...(probe.expectedSequencePrivilegeMismatchCount === 0 ? [] : [`${prefix}:rls_expected_sequence_privilege_mismatch`]),
|
|
...(probe.adminUserRlsEnabled ? [] : [`${prefix}:admin_user_rls_disabled`]),
|
|
...(probe.adminUserRlsForced ? [] : [`${prefix}:admin_user_rls_not_forced`]),
|
|
...(probe.adminUserPolicyCount === EXPECTED_ADMIN_USER_POLICY_COUNT ? [] : [`${prefix}:admin_user_policy_count_mismatch`]),
|
|
...(!probe.adminUserOwner || !RLS_RUNTIME_ROLES.includes(probe.adminUserOwner as RlsRuntimeRole) ? [] : [`${prefix}:admin_user_owned_by_runtime_role`]),
|
|
...(probe.tenantContext === null &&
|
|
probe.userContext === null &&
|
|
probe.portalUserContext === null &&
|
|
probe.publicKnowledgeBaseContext === null &&
|
|
probe.platformAnalyticsContext === null
|
|
? []
|
|
: [`${prefix}:leaked_rls_context`]),
|
|
];
|
|
}
|
|
|
|
function uniqueClients(...clients: RlsProbeClient[]): RlsProbeClient[] {
|
|
return [...new Set(clients)];
|
|
}
|