diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 34a67eb0..92768ad5 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -4,7 +4,7 @@ Thanks for considering a contribution. This repository contains the public Rust ## Before you start -- Search [existing issues](https://github.com/Agata-Proxima/proxima-engine/issues) before opening a new one. +- Search [existing issues](https://github.com/Proxima-Engine/proxima-engine/issues) before opening a new one. - For a vulnerability, follow [SECURITY.md](SECURITY.md); do not publish exploit details in a public issue. - For meaningful behavior changes, open an issue first so the expected behavior can be agreed. diff --git a/README.md b/README.md index 109bef08..f72583db 100644 --- a/README.md +++ b/README.md @@ -3,11 +3,11 @@

Agata Proxima

-

Security infrastructure for multi-tenant PostgreSQL applications.

-

Proxima Engine is a Rust PostgreSQL-protocol gateway that verifies signed tenant context and routes each database session to its tenant-specific PostgreSQL role.

+

Database-independent tenant-security infrastructure.

+

Agata Proxima defines a common tenant-security contract. Proxima Engine currently implements its PostgreSQL wire-protocol runtime, review-only native policy-plan compilers for SQL Server, MySQL, MariaDB, MongoDB and Redis, and read-only native discovery adapters for those databases plus CockroachDB, SQLite and Elasticsearch/OpenSearch. Every non-PostgreSQL adapter remains in development and is not production-supported.

- Continuous integration · + Continuous integration · MIT license for covered Engine source · Website · Discord · @@ -17,7 +17,7 @@ **Start:** [What is Agata Proxima?](#what-is-agata-proxima) · [Customer Docker install](docs/NODE_ENROLLMENT.md#2-one-command-docker-installation-hosted-cloud) · [Guided customer install (Windows/Linux)](docs/CUSTOMER_DEPLOYMENT_EXECUTOR.md#install-the-engine-customer-node) · [Deployment executor](docs/CUSTOMER_DEPLOYMENT_EXECUTOR.md) · [Launch evaluation](docs/LAUNCH.md) · [Quickstart](docs/QUICKSTART.md) · [Local developer mode](docs/LOCAL_DEVELOPMENT.md) · [Engine CLI](docs/CLI.md) · [Documentation index](docs/README.md) -**Technical guides:** [Architecture](docs/ARCHITECTURE.md) · [Tenant isolation](docs/TENANT_ISOLATION.md) · [Driver integrations](docs/INTEGRATIONS.md) · [API and metrics](docs/API.md) · [Security](docs/SECURITY.md) · [Deployment](docs/DEPLOYMENT.md) · [Verification](docs/VERIFICATION.md) +**Technical guides:** [Architecture](docs/ARCHITECTURE.md) · [Security Core and database adapters](docs/SECURITY_CORE.md) · [Tenant isolation](docs/TENANT_ISOLATION.md) · [Driver integrations](docs/INTEGRATIONS.md) · [API and metrics](docs/API.md) · [Security](docs/SECURITY.md) · [Deployment](docs/DEPLOYMENT.md) · [Verification](docs/VERIFICATION.md) @@ -37,25 +37,25 @@ https://github.com/user-attachments/assets/bca488eb-829c-4672-bbe9-b25878e5401c ## What is Agata Proxima? -Agata Proxima provides security infrastructure for applications that serve multiple customers from a shared PostgreSQL environment. Its core job is to make tenant identity part of the database connection boundary and route each verified tenant session to a dedicated PostgreSQL role. +Agata Proxima is designed as an independent tenant-security platform. Proxima Security Core defines a database-neutral contract for tenant identity, protected resources, policy requirements, verification posture and fail-closed decisions. Database-specific adapters translate that contract into native controls. PostgreSQL is the first runtime integration. Review-only native policy-plan compilers exist for SQL Server, MySQL, MariaDB, MongoDB and Redis. Native catalog discovery and drift-inspection adapters now exist for SQL Server, MySQL/MariaDB, MongoDB, Redis, CockroachDB, SQLite and Elasticsearch/OpenSearch. These non-PostgreSQL adapters remain in development: controlled policy deployment, independently executed tenant-isolation probes, tenant-principal binding, runtime fail-closed admission and signed data-plane evidence are not complete. Oracle, DynamoDB, Cassandra and VAULTDB remain planned. VAULTDB is an Agata-owned embedded-engine research project without a Proxima tenant-security implementation. The product has two cooperating components: -### Proxima Engine — public, open-source data plane +### Proxima Engine — public, open-source enforcement runtime Proxima Engine is a Rust service that sits between an application's existing PostgreSQL driver and PostgreSQL. It speaks the PostgreSQL wire protocol, so applications keep their existing database drivers and connect to the Engine endpoint. -The Engine provides: +The current PostgreSQL Engine adapter provides: - **Signed tenant-context verification.** Validates tenant tokens using HMAC-SHA256, including token format, tenant identifier, expiry, and signature. Missing or invalid context is rejected when tenant enforcement is enabled. -- **Tenant-to-role routing.** Maps the verified tenant identity to a configured PostgreSQL role and establishes a tenant-bound upstream database session. +- **Tenant-to-role routing.** Maps the verified tenant identity to a PostgreSQL role derived from one configured global `PROXIMA_TENANT_ROLE_PREFIX` plus the normalized tenant ID, then establishes a tenant-bound upstream database session. - **PostgreSQL-native enforcement.** Works with database roles, grants, and Row-Level Security (RLS), keeping data authorization inside PostgreSQL. - **Protocol and connection controls.** Handles PostgreSQL startup and authentication negotiation, connection limits, upstream timeouts, and configurable client/upstream TLS. - **Security operations.** Includes a peer-scoped violation breaker, short-lived break-glass tokens with replay protection, and a local signed attestation ledger. - **Operational visibility.** Exposes local health and status routes plus Prometheus metrics. - **Developer tooling.** Includes a Python standard-library CLI, local identity bootstrap, tenant-token generation, integration examples, and repeatable PostgreSQL tests. -### Agata Proxima Cloud — hosted management product +### Agata Proxima Cloud — hosted security management product Agata Proxima Cloud is the separate hosted control plane for organization workflows, teams, plans, billing, registered nodes, and hosted management. It coordinates authorized Engine nodes while database traffic remains in the customer environment. @@ -80,7 +80,7 @@ Proxima Engine extends an existing PostgreSQL deployment: it verifies tenant con Requirements: Git and Docker with Compose. ```bash -git clone https://github.com/Agata-Proxima/proxima-engine.git +git clone https://github.com/Proxima-Engine/proxima-engine.git cd proxima-engine docker compose -f compose.dev.yaml up --build -d ``` diff --git a/compose.customer.yaml b/compose.customer.yaml index 174fa358..d91a4dd5 100644 --- a/compose.customer.yaml +++ b/compose.customer.yaml @@ -10,6 +10,9 @@ services: PROXIMA_NODE_IDENTITY_PATH: /var/lib/proxima/node-identity.json PROXIMA_NODE_ENROLLMENT_URL: ${PROXIMA_NODE_ENROLLMENT_URL:-https://api.agataproxima.com/api/v1/nodes/enroll} PROXIMA_NODE_HEARTBEAT_URL: ${PROXIMA_NODE_HEARTBEAT_URL:-https://api.agataproxima.com/api/v1/nodes/heartbeat} + PROXIMA_NODE_POLICY_STATUS_URL: ${PROXIMA_NODE_POLICY_STATUS_URL:-} + PROXIMA_DATABASE_TARGET_ID: ${PROXIMA_DATABASE_TARGET_ID:-} + PROXIMA_POLICY_ADMISSION_REQUIRED: ${PROXIMA_POLICY_ADMISSION_REQUIRED:-false} PROXIMA_NODE_ENROLLMENT_TOKEN_FILE: /run/secrets/node_enrollment_token PROXIMA_ENVIRONMENT: ${PROXIMA_ENVIRONMENT:-production} PROXIMA_LISTEN_ADDR: ${PROXIMA_LISTEN_ADDR:-0.0.0.0:6432} diff --git a/crates/proxima-engine/Cargo.toml b/crates/proxima-engine/Cargo.toml index cd0303e5..99f4bc8d 100644 --- a/crates/proxima-engine/Cargo.toml +++ b/crates/proxima-engine/Cargo.toml @@ -4,9 +4,10 @@ version = "0.1.0" edition = "2021" license = "MIT" description = "Agata Proxima security infrastructure engine" -repository = "https://github.com/Agata-Proxima/proxima-engine" +repository = "https://github.com/Proxima-Engine/proxima-engine" [dependencies] +serde = { version = "1", features = ["derive"] } serde_json = "1" hex = "0.4" bytes = "1" @@ -19,7 +20,16 @@ rustls = { version = "0.23", features = ["ring"] } rustls-pemfile = "2.2" tokio-rustls = "0.26" reqwest = { version = "0.12", default-features = false, features = ["json", "rustls-tls"] } -tokio-postgres = "0.7" +tokio-postgres = { version = "0.7", features = ["with-serde_json-1"] } +sqlx = { version = "0.8", default-features = false, features = ["runtime-tokio-rustls", "mysql", "sqlite"] } +tiberius = { version = "0.12", default-features = false, features = ["rustls", "tds73"] } +tokio-util = { version = "0.7", features = ["compat"] } +mongodb = "3" +chrono = { version = "0.4", features = ["serde"] } +redis = { version = "0.27", default-features = false, features = ["tokio-rustls-comp"] } +tokio-postgres-rustls = { version = "0.14", features = ["aws-lc-rs", "webpki-roots"] } +sqlparser = "0.64" +webpki-roots = "1" uuid = { version = "1", features = ["v4"] } [dev-dependencies] diff --git a/crates/proxima-engine/src/bin/proxima-policy-guard.rs b/crates/proxima-engine/src/bin/proxima-policy-guard.rs new file mode 100644 index 00000000..1bef5be2 --- /dev/null +++ b/crates/proxima-engine/src/bin/proxima-policy-guard.rs @@ -0,0 +1,951 @@ +use serde_json::{json, Value}; +use proxima_engine::security_core::{adapter_catalog, AccessDecision, TenantSecurityPolicy, SECURITY_MODEL_VERSION}; +use proxima_engine::database_adapter::{AdapterError, AdapterFuture, AdapterTarget, DatabaseAdapter, DiscoveryRequest, InspectionRequest}; +use proxima_engine::postgres_adapter::{PostgresCatalogAdapter, PostgresConnector}; +use proxima_engine::mysql_adapter::MySqlCatalogAdapter; +use proxima_engine::mongodb_adapter::MongoCatalogAdapter; +use proxima_engine::redis_adapter::RedisCatalogAdapter; +use proxima_engine::sql_server_adapter::SqlServerCatalogAdapter; +use proxima_engine::cockroach_adapter::{CockroachCatalogAdapter, CockroachConnector}; +use proxima_engine::sqlite_adapter::SqliteCatalogAdapter; +use proxima_engine::elasticsearch_adapter::ElasticsearchCatalogAdapter; +use proxima_engine::native_policy_plans::{compile_mongodb_database_boundary, compile_mysql_database_boundary, compile_oracle_vpd, compile_redis_acl, compile_sql_server}; +use std::{collections::HashSet, env, error::Error, fs, io::BufReader, path::Path, str::FromStr, time::Duration}; +use tokio_postgres::config::SslMode; +use tokio_postgres_rustls::MakeRustlsConnect; + +struct TableFinding { + schema: String, table: String, owner: String, + rls_enabled: bool, rls_forced: bool, owner_has_elevated_privileges: bool, + public_select: bool, public_write_or_truncate: bool, truncate_grant: bool, bypass_role_grant: bool, + policy_count: i64, permissive_policy_count: i64, security_definer_routines: i64, +} +fn ident(v: &str) -> String { format!("\"{}\"", v.replace('"', "\"\"")) } +fn literal(v: &str) -> String { format!("'{}'", v.replace('\'', "''")) } +fn validate_ident(v: &str, label: &str) -> Result<(), Box> { + if v.is_empty() || v.as_bytes().len() > 63 || v.contains('\0') { + return Err(format!("{label} must contain 1–63 UTF-8 bytes and no NUL byte").into()); + } + Ok(()) +} +fn valid_role_name(v: &str) -> bool { + if v.is_empty() || v.len()>63 { return false; } + let mut chars=v.chars(); + matches!(chars.next(),Some(c) if c.is_ascii_alphabetic()||c=='_') + && chars.all(|c|c.is_ascii_alphanumeric()||c=='_') +} + +fn audit_tls_connector() -> Result> { + let _ = rustls::crypto::aws_lc_rs::default_provider().install_default(); + let mut roots = rustls::RootCertStore::empty(); + roots.extend(webpki_roots::TLS_SERVER_ROOTS.iter().cloned()); + if let Ok(path) = env::var("PROXIMA_POLICY_AUDIT_TLS_CA_FILE") { + let file = fs::File::open(path)?; + let mut reader = BufReader::new(file); + let certificates = rustls_pemfile::certs(&mut reader).collect::, _>>()?; + if certificates.is_empty() { return Err("custom TLS CA file contains no certificates".into()); } + for certificate in certificates { roots.add(certificate)?; } + } + let config = rustls::ClientConfig::builder() + .with_root_certificates(roots) + .with_no_client_auth(); + Ok(MakeRustlsConnect::new(config)) +} + +async fn inspect(url: &str) -> Result, Box> { + let mut config = tokio_postgres::Config::from_str(url)?; + config.ssl_mode(SslMode::Require); + let tls = audit_tls_connector()?; + let (client, connection) = tokio::time::timeout(Duration::from_secs(10), config.connect(tls)).await??; + tokio::spawn(async move { if let Err(e) = connection.await { eprintln!("audit connection ended: {e}"); } }); + client.batch_execute("SET default_transaction_read_only = on; SET statement_timeout = '10s'; SET lock_timeout = '2s'; SET search_path = pg_catalog, pg_temp;").await?; + let unsafe_inspector: bool = client.query_one(r#" + WITH RECURSIVE member_roles(role_oid) AS ( + SELECT oid FROM pg_roles WHERE rolname=current_user + UNION + SELECT am.roleid FROM pg_auth_members am JOIN member_roles mr ON am.member=mr.role_oid + ) + SELECT EXISTS(SELECT 1 FROM member_roles mr JOIN pg_roles r ON r.oid=mr.role_oid WHERE r.rolsuper OR r.rolbypassrls OR r.rolcreaterole OR r.rolcreatedb OR r.rolreplication) + OR EXISTS(SELECT 1 FROM pg_class c JOIN pg_namespace n ON n.oid=c.relnamespace + WHERE c.relkind IN ('r','p','v','m') AND n.nspname NOT IN ('pg_catalog','information_schema') + AND (has_table_privilege(current_user,c.oid,'INSERT') + OR has_table_privilege(current_user,c.oid,'UPDATE') + OR has_table_privilege(current_user,c.oid,'DELETE') + OR has_table_privilege(current_user,c.oid,'TRUNCATE'))) + OR has_database_privilege(current_user,current_database(),'CREATE') + OR EXISTS(SELECT 1 FROM pg_namespace n + WHERE n.nspname NOT IN ('pg_catalog','information_schema') AND n.nspname NOT LIKE 'pg_%' + AND has_schema_privilege(current_user,n.oid,'CREATE')) + "#, &[]).await?.get(0); + if unsafe_inspector { return Err("audit login must be read-only and must not be SUPERUSER or BYPASSRLS".into()); } + let rows = client.query(r#" + SELECT n.nspname, c.relname, pg_get_userbyid(c.relowner), + c.relrowsecurity, c.relforcerowsecurity, + (COALESCE(r.rolsuper OR r.rolbypassrls,false) OR EXISTS( + WITH RECURSIVE owner_roles(role_oid) AS ( + SELECT c.relowner UNION SELECT am.roleid FROM pg_auth_members am JOIN owner_roles o ON am.member=o.role_oid + ) + SELECT 1 FROM owner_roles o JOIN pg_roles owner_member ON owner_member.oid=o.role_oid + WHERE owner_member.rolsuper OR owner_member.rolbypassrls OR owner_member.rolcreaterole OR owner_member.rolcreatedb OR owner_member.rolreplication + )), + EXISTS (SELECT 1 FROM aclexplode(COALESCE(c.relacl, acldefault('r', c.relowner))) a + WHERE a.grantee = 0 AND a.privilege_type = 'SELECT'), + EXISTS (SELECT 1 FROM aclexplode(COALESCE(c.relacl, acldefault('r', c.relowner))) a + WHERE a.grantee = 0 AND a.privilege_type IN ('INSERT','UPDATE','DELETE','TRUNCATE')), + (EXISTS (SELECT 1 FROM pg_roles grantee WHERE grantee.rolname<>pg_get_userbyid(c.relowner) AND has_table_privilege(grantee.rolname,c.oid,'TRUNCATE')) OR EXISTS (SELECT 1 FROM aclexplode(COALESCE(c.relacl,acldefault('r',c.relowner))) acl WHERE acl.grantee=0 AND acl.privilege_type='TRUNCATE')), + EXISTS (SELECT 1 FROM aclexplode(COALESCE(c.relacl, acldefault('r', c.relowner))) a + WHERE a.grantee<>0 AND EXISTS( + WITH RECURSIVE granted_roles(role_oid) AS ( + SELECT a.grantee UNION SELECT am.roleid FROM pg_auth_members am JOIN granted_roles g ON am.member=g.role_oid + ) + SELECT 1 FROM granted_roles g JOIN pg_roles gr ON gr.oid=g.role_oid WHERE gr.rolsuper OR gr.rolbypassrls + )), + (SELECT count(*) FROM pg_policy p WHERE p.polrelid = c.oid), + (SELECT count(*) FROM pg_policy p WHERE p.polrelid = c.oid AND p.polpermissive), + (SELECT count(*) FROM pg_proc routine JOIN pg_namespace routine_schema ON routine_schema.oid=routine.pronamespace + WHERE routine.prosecdef AND routine.prokind IN ('f','p') + AND routine_schema.nspname NOT IN ('pg_catalog','information_schema') + AND routine_schema.nspname NOT LIKE 'pg_%') + FROM pg_class c JOIN pg_namespace n ON n.oid = c.relnamespace + LEFT JOIN pg_roles r ON r.rolname = pg_get_userbyid(c.relowner) + WHERE c.relkind IN ('r','p') + AND n.nspname NOT IN ('pg_catalog','information_schema') + AND n.nspname NOT LIKE 'pg_toast%' AND n.nspname NOT LIKE 'pg_temp_%' + ORDER BY n.nspname,c.relname + "#, &[]).await?; + Ok(rows.into_iter().map(|r| TableFinding { + schema:r.get(0), table:r.get(1), owner:r.get(2), rls_enabled:r.get(3), + rls_forced:r.get(4), owner_has_elevated_privileges:r.get(5), public_select:r.get(6), + public_write_or_truncate:r.get(7), truncate_grant:r.get(8), bypass_role_grant:r.get(9), + policy_count:r.get(10), permissive_policy_count:r.get(11), security_definer_routines:r.get(12) + }).collect()) +} +fn report(rows: &[TableFinding]) -> Value { + let tables: Vec = rows.iter().map(|f| { + let mut issues: Vec<&str> = Vec::new(); + if !f.rls_enabled { issues.push("rls_disabled"); } + if f.rls_enabled && !f.rls_forced { issues.push("rls_not_forced"); } + if !f.rls_forced || f.owner_has_elevated_privileges { issues.push("table_owner_has_elevated_privileges"); } + if f.public_select { issues.push("public_select_grant"); } + if f.public_write_or_truncate { issues.push("public_write_or_truncate_grant"); } + if f.truncate_grant { issues.push("non_owner_truncate_grant"); } + if f.bypass_role_grant { issues.push("bypassrls_or_superuser_role_has_table_grant"); } + if f.rls_enabled && f.policy_count == 0 { issues.push("no_rls_policies"); } + if f.permissive_policy_count > 1 { issues.push("multiple_permissive_policies_require_review"); } + if f.security_definer_routines > 0 { issues.push("security_definer_routines_require_review"); } + json!({"schema":f.schema,"table":f.table,"owner":f.owner, + "rls_enabled":f.rls_enabled,"rls_forced":f.rls_forced, + "owner_has_elevated_privileges":f.owner_has_elevated_privileges,"public_select":f.public_select, + "public_write_or_truncate":f.public_write_or_truncate,"truncate_grant":f.truncate_grant,"bypass_role_grant":f.bypass_role_grant, + "policy_count":f.policy_count,"permissive_policy_count":f.permissive_policy_count, + "security_definer_routines":f.security_definer_routines,"findings":issues}) + }).collect(); + let count: usize = tables.iter().map(|t| t["findings"].as_array().map_or(0, Vec::len)).sum(); + json!({"schema":"agata-proxima.postgresql-posture.v1", + "security_model_version":SECURITY_MODEL_VERSION, + "database_kind":"postgresql", + "adapter_maturity":"in_development", + "inspection_status":"inspection_only", + "security_posture":"unknown", + "access_decision":"deny", + "scope":"non-system ordinary and partitioned tables visible to the audit role", + "table_count":tables.len(),"finding_count":count, + "status":if count==0 {"no_catalog_findings"} else {"attention_required"}, + "limitations":[ + "Catalog inspection cannot prove an arbitrary policy implements the intended tenant boundary.", + "Views, functions, dynamic SQL and application authorization require separate review.", + "A clean report is not a security certification." + ],"tables":tables}) +} +fn generate(spec: &Value) -> Result> { + let tables=spec.get("tables").and_then(Value::as_array).ok_or("policy spec requires tables array")?; + if tables.is_empty() { return Err("tables array cannot be empty".into()); } + if tables.len()>100 { return Err("at most 100 tables may be generated in one policy spec".into()); } + let mut seen_tables=HashSet::new(); + let mut required_role_prefix:Option=None; + let mut out=String::from("-- Agata Proxima generated SQL. Review and apply through migrations.\n-- Tenant identity is bound to current_user, not a client-writable GUC.\n-- All role mappings must use one Engine prefix plus the normalized verified tenant ID.\nBEGIN;\nSET LOCAL search_path = pg_catalog, pg_temp;\n"); + for t in tables { + let schema=t["schema"].as_str().ok_or("schema required")?; + let name=t["table"].as_str().ok_or("table required")?; + let column=t["tenant_column"].as_str().ok_or("tenant_column required")?; + let policy=t["policy_name"].as_str().unwrap_or("proxima_tenant_isolation"); + for (value,label) in [(schema,"schema"),(name,"table"),(column,"tenant column"),(policy,"policy name")] { + validate_ident(value,label)?; + } + if schema=="pg_catalog" || schema=="information_schema" || schema.starts_with("pg_toast") || schema.starts_with("pg_temp") { + return Err(format!("{schema}.{name}: system and temporary schemas cannot be managed").into()); + } + if !seen_tables.insert((schema.to_owned(),name.to_owned())) { + return Err(format!("{schema}.{name}: duplicate table mapping in policy spec").into()); + } + let tenants=t["tenants"].as_array().ok_or("tenants array required")?; + if tenants.is_empty() || tenants.len()>100 { return Err(format!("{schema}.{name}: tenant mappings must contain 1-100 entries").into()); } + let mut predicates=Vec::new(); let mut roles=Vec::new(); + let mut tenant_ids=std::collections::HashSet::new(); + let mut role_names=std::collections::HashSet::new(); + for tenant in tenants { + let id=tenant["tenant_id"].as_str().ok_or("tenant_id required")?; + let role=tenant["role"].as_str().ok_or("role required")?; + if id.is_empty()||id.len()>128||!id.bytes().all(|byte|byte.is_ascii_alphanumeric()||byte==b'-'||byte==b'_')||!valid_role_name(role) + || !tenant_ids.insert(id)||!role_names.insert(role) { + return Err(format!("{schema}.{name}: invalid or duplicate tenant-to-role mapping").into()); + } + let normalized_id=id.replace('-', "_"); + if !role.ends_with(&normalized_id) { + return Err(format!("{schema}.{name}: role {role} does not match the Engine prefix-plus-tenant-ID contract").into()); + } + let prefix_length=role.len().saturating_sub(normalized_id.len()); + let role_prefix=&role[..prefix_length]; + if role_prefix.is_empty()||!role_prefix.bytes().all(|byte|byte.is_ascii_alphanumeric()||byte==b'_') { + return Err(format!("{schema}.{name}: role {role} has an invalid Engine prefix").into()); + } + if required_role_prefix.as_deref().is_some_and(|expected|expected!=role_prefix) { + return Err(format!("{schema}.{name}: all tenant roles must use one shared PROXIMA_TENANT_ROLE_PREFIX").into()); + } + required_role_prefix=Some(role_prefix.to_owned()); + predicates.push(format!("({} = {} AND current_user = {})",ident(column),literal(id),literal(role))); + roles.push(ident(role)); + } + let target=format!("{}.{}",ident(schema),ident(name)); + let predicate=predicates.join(" OR "); + let role_values=tenants.iter().map(|tenant|literal(tenant["role"].as_str().unwrap())).collect::>().join(", "); + let role_array=format!("ARRAY[{role_values}]::name[]"); + let preflight=format!(r#" +DO $agata_proxima_preflight$ +DECLARE owner_name name; +BEGIN + SELECT pg_get_userbyid(c.relowner) INTO owner_name + FROM pg_class c JOIN pg_namespace n ON n.oid=c.relnamespace + WHERE n.nspname={schema_literal} AND c.relname={table_literal} AND c.relkind IN ('r','p'); + IF owner_name IS NULL THEN RAISE EXCEPTION 'Agata Proxima: target table does not exist'; END IF; + IF NOT EXISTS (SELECT 1 FROM pg_attribute a JOIN pg_class c ON c.oid=a.attrelid JOIN pg_namespace n ON n.oid=c.relnamespace + WHERE n.nspname={schema_literal} AND c.relname={table_literal} AND a.attname={column_literal} + AND a.attnum>0 AND NOT a.attisdropped) + THEN RAISE EXCEPTION 'Agata Proxima: tenant key column does not exist'; END IF; + IF EXISTS (SELECT 1 FROM pg_attribute a JOIN pg_class c ON c.oid=a.attrelid JOIN pg_namespace n ON n.oid=c.relnamespace + WHERE n.nspname={schema_literal} AND c.relname={table_literal} AND a.attname={column_literal} + AND a.attnum>0 AND NOT a.attisdropped AND NOT a.attnotnull) + THEN RAISE EXCEPTION 'Agata Proxima: tenant key column must be NOT NULL'; END IF; + IF EXISTS (SELECT 1 FROM pg_attribute a JOIN pg_class c ON c.oid=a.attrelid JOIN pg_namespace n ON n.oid=c.relnamespace + WHERE n.nspname={schema_literal} AND c.relname={table_literal} AND a.attname={column_literal} + AND a.attnum>0 AND NOT a.attisdropped + AND format_type(a.atttypid,a.atttypmod) NOT IN ('text','uuid','integer','bigint','smallint','numeric','citext') + AND format_type(a.atttypid,a.atttypmod) NOT LIKE 'character varying%' + AND format_type(a.atttypid,a.atttypmod) NOT LIKE 'character(%') + THEN RAISE EXCEPTION 'Agata Proxima: tenant key type is unsupported'; END IF; + IF owner_name = ANY({role_array}) THEN RAISE EXCEPTION 'Agata Proxima: tenant runtime roles must not own the protected table'; END IF; + IF EXISTS (SELECT 1 FROM pg_inherits partition_edge + WHERE partition_edge.inhrelid=(SELECT c.oid FROM pg_class c JOIN pg_namespace n ON n.oid=c.relnamespace WHERE n.nspname={schema_literal} AND c.relname={table_literal}) + OR partition_edge.inhparent=(SELECT c.oid FROM pg_class c JOIN pg_namespace n ON n.oid=c.relnamespace WHERE n.nspname={schema_literal} AND c.relname={table_literal})) + THEN RAISE EXCEPTION 'Agata Proxima: partitioned relations require native child-partition verification before policy generation'; END IF; + IF EXISTS ( + WITH RECURSIVE dependent_views(view_oid) AS ( + SELECT rewrite.ev_class FROM pg_depend dependency + JOIN pg_rewrite rewrite ON dependency.classid='pg_rewrite'::regclass AND dependency.objid=rewrite.oid + WHERE dependency.refclassid='pg_class'::regclass + AND dependency.refobjid=(SELECT c.oid FROM pg_class c JOIN pg_namespace n ON n.oid=c.relnamespace WHERE n.nspname={schema_literal} AND c.relname={table_literal}) + UNION + SELECT rewrite.ev_class FROM pg_depend dependency + JOIN pg_rewrite rewrite ON dependency.classid='pg_rewrite'::regclass AND dependency.objid=rewrite.oid + JOIN dependent_views parent_view ON dependency.refobjid=parent_view.view_oid + WHERE dependency.refclassid='pg_class'::regclass + ) + SELECT 1 FROM dependent_views dependency + JOIN pg_class view_relation ON view_relation.oid=dependency.view_oid + JOIN pg_namespace view_namespace ON view_namespace.oid=view_relation.relnamespace + WHERE view_relation.relkind IN ('v','m') + AND view_namespace.nspname NOT IN ('pg_catalog','information_schema') + AND (view_relation.relkind='m' OR NOT COALESCE(view_relation.reloptions @> ARRAY['security_invoker=true'],false)) + ) + THEN RAISE EXCEPTION 'Agata Proxima: dependent views must use security_invoker=true and materialized views require separate protection'; END IF; + IF EXISTS (SELECT 1 FROM pg_roles tenant_role WHERE tenant_role.rolname=ANY({role_array}) + AND (has_database_privilege(tenant_role.rolname,current_database(),'CREATE') + OR EXISTS(SELECT 1 FROM pg_namespace ns + WHERE ns.nspname NOT IN ('pg_catalog','information_schema') AND ns.nspname NOT LIKE 'pg_%' + AND has_schema_privilege(tenant_role.rolname,ns.oid,'CREATE')))) + THEN RAISE EXCEPTION 'Agata Proxima: tenant runtime roles must not have database or schema CREATE privileges'; END IF; + IF EXISTS (SELECT 1 FROM pg_roles WHERE rolname=ANY({role_array}) AND (rolsuper OR rolbypassrls OR rolcreaterole OR rolcreatedb OR rolreplication OR NOT rolcanlogin)) + OR (WITH RECURSIVE member_roles(role_oid) AS ( + SELECT oid FROM pg_roles WHERE rolname=ANY({role_array}) + UNION SELECT am.roleid FROM pg_auth_members am JOIN member_roles mr ON am.member=mr.role_oid + ) SELECT EXISTS(SELECT 1 FROM member_roles mr JOIN pg_roles r ON r.oid=mr.role_oid WHERE r.rolsuper OR r.rolbypassrls)) + OR EXISTS (SELECT 1 FROM pg_auth_members am JOIN pg_roles r ON r.oid=am.roleid OR r.oid=am.member WHERE r.rolname=ANY({role_array})) + THEN RAISE EXCEPTION 'Agata Proxima: tenant roles must exist, have no role memberships, and must not bypass RLS'; END IF; + IF (SELECT count(*) FROM pg_roles WHERE rolname=ANY({role_array})) <> {role_count} + THEN RAISE EXCEPTION 'Agata Proxima: one or more tenant roles do not exist'; END IF; + IF EXISTS (SELECT 1 FROM pg_db_role_setting s LEFT JOIN pg_roles r ON r.oid=s.setrole + WHERE (s.setrole=0 OR r.rolname=ANY({role_array})) + AND (s.setdatabase=0 OR s.setdatabase=(SELECT oid FROM pg_database WHERE datname=current_database())) + AND EXISTS(SELECT 1 FROM unnest(s.setconfig) setting + WHERE lower(setting) LIKE 'role=%' + OR lower(setting) LIKE 'session_authorization=%' + OR lower(setting) LIKE 'row_security=off%' + OR lower(setting) LIKE 'row_security=false%' + OR lower(setting) LIKE 'row_security=0%' + OR lower(setting) LIKE 'row_security=no%' + OR lower(setting) LIKE 'search_path=%' + OR lower(setting) LIKE 'session_replication_role=replica%')) + THEN RAISE EXCEPTION 'Agata Proxima: tenant role/database defaults can change security state'; END IF; + IF EXISTS (SELECT 1 FROM pg_roles WHERE rolname=owner_name AND (rolsuper OR rolbypassrls OR rolcreaterole OR rolcreatedb OR rolreplication)) + THEN RAISE EXCEPTION 'Agata Proxima: table owner bypasses row security'; END IF; + IF EXISTS (WITH RECURSIVE owner_roles(role_oid) AS ( + SELECT oid FROM pg_roles WHERE rolname=owner_name + UNION SELECT am.roleid FROM pg_auth_members am JOIN owner_roles o ON am.member=o.role_oid + ) SELECT 1 FROM owner_roles o JOIN pg_roles r ON r.oid=o.role_oid WHERE r.rolsuper OR r.rolbypassrls) + THEN RAISE EXCEPTION 'Agata Proxima: table owner membership bypasses row security'; END IF; + IF EXISTS (SELECT 1 FROM pg_policies WHERE schemaname={schema_literal} AND tablename={table_literal} + AND permissive='PERMISSIVE' AND policyname<>{policy_literal}) + THEN RAISE EXCEPTION 'Agata Proxima: other permissive RLS policies must be reconciled first'; END IF; + IF EXISTS (SELECT 1 FROM pg_proc routine JOIN pg_namespace routine_schema ON routine_schema.oid=routine.pronamespace + WHERE routine.prosecdef AND routine.prokind IN ('f','p') + AND routine_schema.nspname NOT IN ('pg_catalog','information_schema') + AND routine_schema.nspname NOT LIKE 'pg_%') + THEN RAISE EXCEPTION 'Agata Proxima: SECURITY DEFINER routines require separate review before claiming tenant isolation'; END IF; + IF EXISTS (SELECT 1 FROM pg_class c JOIN pg_namespace n ON n.oid=c.relnamespace + WHERE n.nspname={schema_literal} AND c.relname={table_literal} + AND EXISTS (SELECT 1 FROM pg_roles grantee + WHERE grantee.rolname<>owner_name AND has_table_privilege(grantee.rolname,c.oid,'TRUNCATE'))) + THEN RAISE EXCEPTION 'Agata Proxima: non-owner TRUNCATE grants bypass RLS'; END IF; + IF EXISTS (SELECT 1 FROM pg_class c JOIN pg_namespace n ON n.oid=c.relnamespace + WHERE n.nspname={schema_literal} AND c.relname={table_literal} + AND EXISTS (SELECT 1 FROM aclexplode(COALESCE(c.relacl,acldefault('r',c.relowner))) acl + WHERE acl.grantee=0 AND acl.privilege_type IN ('SELECT','INSERT','UPDATE','DELETE','TRUNCATE'))) + THEN RAISE EXCEPTION 'Agata Proxima: PUBLIC has table privileges; reconcile PUBLIC grants before policy generation'; END IF; + IF EXISTS (SELECT 1 FROM pg_policy p JOIN pg_class c ON c.oid=p.polrelid + JOIN pg_namespace n ON n.oid=c.relnamespace + WHERE n.nspname={schema_literal} AND c.relname={table_literal} AND p.polname={policy_literal}) + THEN RAISE EXCEPTION 'Agata Proxima: policy name already exists; review the existing policy before replacement'; END IF; + IF EXISTS (SELECT 1 FROM pg_class c JOIN pg_namespace n ON n.oid=c.relnamespace + WHERE n.nspname={schema_literal} AND c.relname={table_literal} + AND EXISTS (SELECT 1 FROM aclexplode(COALESCE(c.relacl,acldefault('r',c.relowner))) acl + WHERE acl.grantee<>0 AND acl.grantee<>c.relowner AND EXISTS( + WITH RECURSIVE granted_roles(role_oid) AS ( + SELECT acl.grantee UNION SELECT am.roleid FROM pg_auth_members am JOIN granted_roles g ON am.member=g.role_oid + ) + SELECT 1 FROM granted_roles g JOIN pg_roles r ON r.oid=g.role_oid WHERE r.rolsuper OR r.rolbypassrls + ))) + THEN RAISE EXCEPTION 'Agata Proxima: a table grantee can bypass row security'; END IF; +END; +$agata_proxima_preflight$; +"#,schema_literal=literal(schema),table_literal=literal(name),column_literal=literal(column),policy_literal=literal(policy),role_array=role_array,role_count=tenants.len()); + out.push_str(&preflight); + out.push_str(&format!("\nALTER TABLE {target} ENABLE ROW LEVEL SECURITY;\nALTER TABLE {target} FORCE ROW LEVEL SECURITY;\nCREATE POLICY {} ON {target} FOR ALL TO {} USING ({predicate}) WITH CHECK ({predicate});\n",ident(policy),roles.join(", "))); + } + let prefix=required_role_prefix.ok_or("policy spec did not define an Engine role prefix")?; + out.push_str(&format!("\n-- Required PROXIMA_TENANT_ROLE_PREFIX: {prefix}\n")); + out.push_str("\nCOMMIT;\n"); + Ok(out) +} +#[tokio::main] +async fn main() -> Result<(),Box> { + let mut args=env::args().skip(1); + match args.next().as_deref() { + Some("validate-policy") => { + let path=args.next().ok_or("usage: proxima-policy-guard validate-policy ")?; + let source=fs::read_to_string(&path)?; + let policy:TenantSecurityPolicy=serde_json::from_str(&source)?; + match policy.validate() { + Ok(()) => println!("{}",serde_json::to_string_pretty(&json!({ + "valid":true, + "schema_version":policy.schema_version, + "policy_id":policy.policy_id, + "revision":policy.revision, + "resource_count":policy.resources.len() + }))?), + Err(error) => { + println!("{}",serde_json::to_string_pretty(&json!({"valid":false,"error":format!("{error:?}")}))?); + std::process::exit(2); + } + } + }, + Some("compile-plan") => { + let database = args.next().ok_or("usage: proxima-policy-guard compile-plan ")?; + let path = args.next().ok_or("usage: proxima-policy-guard compile-plan ")?; + let source = fs::read_to_string(&path)?; + let policy: TenantSecurityPolicy = serde_json::from_str(&source)?; + let compiled = match database.as_str() { + "postgresql" => { + let connector: PostgresConnector = std::sync::Arc::new(|| Box::pin(async { + Err(AdapterError { code: "compile_only_connector".into(), detail: "PostgreSQL plan compilation does not connect to a database.".into(), retryable: false }) + })); + let tenant_role_prefix = env::var("PROXIMA_TENANT_ROLE_PREFIX") + .map_err(|_| "set PROXIMA_TENANT_ROLE_PREFIX to compile a role-bound PostgreSQL policy")?; + let adapter = PostgresCatalogAdapter::new("compile-only", "compile-only", tenant_role_prefix, connector)?; + adapter.compile_policy(&policy)? + }, + "sql_server" => compile_sql_server(&policy)?, + "mysql" => compile_mysql_database_boundary(&policy, proxima_engine::security_core::DatabaseKind::MySql)?, + "mariadb" => compile_mysql_database_boundary(&policy, proxima_engine::security_core::DatabaseKind::MariaDb)?, + "mongodb" => compile_mongodb_database_boundary(&policy)?, + "redis" => compile_redis_acl(&policy)?, + "oracle" => compile_oracle_vpd(&policy)?, + _ => return Err("unsupported compile-plan database; choose postgresql, sql_server, mysql, mariadb, mongodb, redis, or oracle".into()) + }; + println!("{}", serde_json::to_string_pretty(&compiled)?); + eprintln!("Review-only policy plan generated. No database connection or DDL/ACL change was made."); + }, + Some("adapters") => { + let value=json!({"schema_version":SECURITY_MODEL_VERSION,"scope":"engine_runtime","adapter_contract":"database_adapter::DatabaseAdapter","adapters":adapter_catalog()}); + println!("{}",serde_json::to_string_pretty(&value)?); + }, + Some("discover-postgres") => { + let namespace = args.next(); + if args.next().is_some() { return Err("usage: proxima-policy-guard discover-postgres [schema]".into()); } + let url = env::var("PROXIMA_POSTGRES_ADAPTER_DATABASE_URL") + .map_err(|_| "set PROXIMA_POSTGRES_ADAPTER_DATABASE_URL to a TLS-verified PostgreSQL URL")?; + let target_id = env::var("PROXIMA_POSTGRES_ADAPTER_TARGET_ID") + .map_err(|_| "set PROXIMA_POSTGRES_ADAPTER_TARGET_ID to the registered non-secret target ID")?; + let database_name = env::var("PROXIMA_POSTGRES_ADAPTER_DATABASE_NAME") + .map_err(|_| "set PROXIMA_POSTGRES_ADAPTER_DATABASE_NAME to the expected database name")?; + let tenant_role_prefix = env::var("PROXIMA_TENANT_ROLE_PREFIX") + .map_err(|_| "set PROXIMA_TENANT_ROLE_PREFIX to the Engine's tenant role prefix")?; + let connector_url = url.clone(); + let connector: PostgresConnector = std::sync::Arc::new(move || { + let connector_url = connector_url.clone(); + Box::pin(async move { + let mut config = tokio_postgres::Config::from_str(&connector_url) + .map_err(|error| AdapterError { code: "invalid_postgres_connection_config".into(), detail: error.to_string(), retryable: false })?; + config.ssl_mode(SslMode::Require); + let tls = audit_tls_connector() + .map_err(|error| AdapterError { code: "postgres_tls_configuration_failed".into(), detail: error.to_string(), retryable: false })?; + let (client, connection) = tokio::time::timeout(Duration::from_secs(10), config.connect(tls)) + .await + .map_err(|error| AdapterError { code: "postgres_connection_timeout".into(), detail: error.to_string(), retryable: true })? + .map_err(|error| AdapterError { code: "postgres_connection_failed".into(), detail: error.to_string(), retryable: error.is_closed() })?; + tokio::spawn(async move { + if let Err(error) = connection.await { + eprintln!("PostgreSQL discovery connection ended: {error}"); + } + }); + Ok(client) + }) as AdapterFuture<'static, Result> + }); + let adapter = PostgresCatalogAdapter::new(target_id.clone(), database_name.clone(), tenant_role_prefix, connector)?; + let snapshot = adapter.discover(&DiscoveryRequest { + target: AdapterTarget { target_id, database_name, namespace: None }, + namespace, + }).await?; + println!("{}", serde_json::to_string_pretty(&json!({ + "adapter": adapter.descriptor(), + "discovery": snapshot, + "access_decision": "deny", + "note": "Discovery inventories native resources. It does not certify tenant isolation or authorize traffic." + }))?); + }, + Some("discover-mysql") | Some("discover-mariadb") => { + let command = env::args().nth(1).unwrap_or_default(); + let namespace = args.next(); + if args.next().is_some() { return Err("usage: proxima-policy-guard discover-mysql [database] | discover-mariadb [database]".into()); } + let kind = if command == "discover-mariadb" { proxima_engine::security_core::DatabaseKind::MariaDb } else { proxima_engine::security_core::DatabaseKind::MySql }; + let url = env::var("PROXIMA_MYSQL_ADAPTER_DATABASE_URL") + .map_err(|_| "set PROXIMA_MYSQL_ADAPTER_DATABASE_URL to a MySQL/MariaDB URL with TLS identity verification")?; + let target_id = env::var("PROXIMA_MYSQL_ADAPTER_TARGET_ID") + .map_err(|_| "set PROXIMA_MYSQL_ADAPTER_TARGET_ID to the registered non-secret target ID")?; + let database_name = env::var("PROXIMA_MYSQL_ADAPTER_DATABASE_NAME") + .map_err(|_| "set PROXIMA_MYSQL_ADAPTER_DATABASE_NAME to the expected database name")?; + let adapter = MySqlCatalogAdapter::new(target_id.clone(), database_name.clone(), url, kind)?; + let snapshot = adapter.discover(&DiscoveryRequest { + target: AdapterTarget { target_id, database_name, namespace: None }, + namespace, + }).await?; + println!("{}", serde_json::to_string_pretty(&json!({ + "adapter": adapter.descriptor(), + "discovery": snapshot, + "access_decision": "deny", + "note": "MySQL/MariaDB discovery is a privilege-filtered native inventory. It does not establish complete catalog visibility, tenant isolation or runtime admission." + }))?); + }, + Some("inspect-mysql-policy") | Some("inspect-mariadb-policy") => { + let command = env::args().nth(1).unwrap_or_default(); + let path = args.next().ok_or("usage: proxima-policy-guard inspect-mysql-policy | inspect-mariadb-policy ")?; + if args.next().is_some() { return Err("only one policy file may be supplied".into()); } + let policy: TenantSecurityPolicy = serde_json::from_slice(&fs::read(&path)?)?; + policy.validate().map_err(|error| format!("invalid policy: {error:?}"))?; + let kind = if command == "inspect-mariadb-policy" { proxima_engine::security_core::DatabaseKind::MariaDb } else { proxima_engine::security_core::DatabaseKind::MySql }; + let url = env::var("PROXIMA_MYSQL_ADAPTER_DATABASE_URL") + .map_err(|_| "set PROXIMA_MYSQL_ADAPTER_DATABASE_URL to a MySQL/MariaDB URL with TLS identity verification")?; + let target_id = env::var("PROXIMA_MYSQL_ADAPTER_TARGET_ID") + .map_err(|_| "set PROXIMA_MYSQL_ADAPTER_TARGET_ID to the registered non-secret target ID")?; + let database_name = env::var("PROXIMA_MYSQL_ADAPTER_DATABASE_NAME") + .map_err(|_| "set PROXIMA_MYSQL_ADAPTER_DATABASE_NAME to the expected database name")?; + let adapter = MySqlCatalogAdapter::new(target_id.clone(), database_name.clone(), url, kind)?; + let request = InspectionRequest { + target: AdapterTarget { target_id, database_name, namespace: None }, + policy, + }; + let snapshot = adapter.inspect(&request).await?; + let verification = adapter.verify(&request.policy, &snapshot).await?; + let decision = verification.access_decision(); + println!("{}", serde_json::to_string_pretty(&json!({ + "adapter": adapter.descriptor(), + "snapshot": snapshot, + "verification": verification, + "access_decision": decision + }))?); + if decision != AccessDecision::Allow { std::process::exit(2); } + }, + Some("discover-mongodb") => { + if args.next().is_some() { return Err("usage: proxima-policy-guard discover-mongodb".into()); } + let uri = env::var("PROXIMA_MONGODB_ADAPTER_URI") + .map_err(|_| "set PROXIMA_MONGODB_ADAPTER_URI to a MongoDB URI with verified TLS")?; + let target_id = env::var("PROXIMA_MONGODB_ADAPTER_TARGET_ID") + .map_err(|_| "set PROXIMA_MONGODB_ADAPTER_TARGET_ID to the registered non-secret target ID")?; + let database_name = env::var("PROXIMA_MONGODB_ADAPTER_DATABASE_NAME") + .map_err(|_| "set PROXIMA_MONGODB_ADAPTER_DATABASE_NAME to the expected database name")?; + let adapter = MongoCatalogAdapter::new(target_id.clone(), database_name.clone(), uri)?; + let snapshot = adapter.discover(&DiscoveryRequest { + target: AdapterTarget { target_id, database_name, namespace: None }, + namespace: None, + }).await?; + println!("{}", serde_json::to_string_pretty(&json!({ + "adapter": adapter.descriptor(), + "discovery": snapshot, + "access_decision": "deny", + "note": "MongoDB collection and effective privilege discovery is visibility-scoped. It does not prove document-level tenant isolation or authorize traffic." + }))?); + }, + Some("inspect-mongodb-policy") => { + let path = args.next().ok_or("usage: proxima-policy-guard inspect-mongodb-policy ")?; + if args.next().is_some() { return Err("only one policy file may be supplied".into()); } + let policy: TenantSecurityPolicy = serde_json::from_slice(&fs::read(&path)?)?; + policy.validate().map_err(|error| format!("invalid policy: {error:?}"))?; + let uri = env::var("PROXIMA_MONGODB_ADAPTER_URI") + .map_err(|_| "set PROXIMA_MONGODB_ADAPTER_URI to a MongoDB URI with verified TLS")?; + let target_id = env::var("PROXIMA_MONGODB_ADAPTER_TARGET_ID") + .map_err(|_| "set PROXIMA_MONGODB_ADAPTER_TARGET_ID to the registered non-secret target ID")?; + let database_name = env::var("PROXIMA_MONGODB_ADAPTER_DATABASE_NAME") + .map_err(|_| "set PROXIMA_MONGODB_ADAPTER_DATABASE_NAME to the expected database name")?; + let adapter = MongoCatalogAdapter::new(target_id.clone(), database_name.clone(), uri)?; + let request = InspectionRequest { + target: AdapterTarget { target_id, database_name, namespace: None }, + policy, + }; + let snapshot = adapter.inspect(&request).await?; + let verification = adapter.verify(&request.policy, &snapshot).await?; + let decision = verification.access_decision(); + println!("{}", serde_json::to_string_pretty(&json!({ + "adapter": adapter.descriptor(), + "snapshot": snapshot, + "verification": verification, + "access_decision": decision + }))?); + if decision != AccessDecision::Allow { std::process::exit(2); } + }, + Some("discover-redis") => { + if args.next().is_some() { return Err("usage: proxima-policy-guard discover-redis".into()); } + let uri = env::var("PROXIMA_REDIS_ADAPTER_URI") + .map_err(|_| "set PROXIMA_REDIS_ADAPTER_URI to a rediss:// URI with verified TLS")?; + let target_id = env::var("PROXIMA_REDIS_ADAPTER_TARGET_ID") + .map_err(|_| "set PROXIMA_REDIS_ADAPTER_TARGET_ID to the registered non-secret target ID")?; + let database_index = env::var("PROXIMA_REDIS_ADAPTER_DATABASE_INDEX") + .map_err(|_| "set PROXIMA_REDIS_ADAPTER_DATABASE_INDEX to the expected Redis logical database number")? + .parse::().map_err(|_| "PROXIMA_REDIS_ADAPTER_DATABASE_INDEX must be a non-negative integer")?; + let adapter = RedisCatalogAdapter::new(target_id.clone(), database_index, uri)?; + let snapshot = adapter.discover(&DiscoveryRequest { + target: AdapterTarget { target_id, database_name: database_index.to_string(), namespace: None }, + namespace: None, + }).await?; + println!("{}", serde_json::to_string_pretty(&json!({ + "adapter": adapter.descriptor(), + "discovery": snapshot, + "access_decision": "deny", + "note": "Redis ACL discovery inventories command and key-pattern rules. It does not prove application tenant binding or authorize traffic." + }))?); + }, + Some("inspect-redis-policy") => { + let path = args.next().ok_or("usage: proxima-policy-guard inspect-redis-policy ")?; + if args.next().is_some() { return Err("only one policy file may be supplied".into()); } + let policy: TenantSecurityPolicy = serde_json::from_slice(&fs::read(&path)?)?; + policy.validate().map_err(|error| format!("invalid policy: {error:?}"))?; + let uri = env::var("PROXIMA_REDIS_ADAPTER_URI") + .map_err(|_| "set PROXIMA_REDIS_ADAPTER_URI to a rediss:// URI with verified TLS")?; + let target_id = env::var("PROXIMA_REDIS_ADAPTER_TARGET_ID") + .map_err(|_| "set PROXIMA_REDIS_ADAPTER_TARGET_ID to the registered non-secret target ID")?; + let database_index = env::var("PROXIMA_REDIS_ADAPTER_DATABASE_INDEX") + .map_err(|_| "set PROXIMA_REDIS_ADAPTER_DATABASE_INDEX to the expected Redis logical database number")? + .parse::().map_err(|_| "PROXIMA_REDIS_ADAPTER_DATABASE_INDEX must be a non-negative integer")?; + let adapter = RedisCatalogAdapter::new(target_id.clone(), database_index, uri)?; + let request = InspectionRequest { + target: AdapterTarget { target_id, database_name: database_index.to_string(), namespace: None }, + policy, + }; + let snapshot = adapter.inspect(&request).await?; + let verification = adapter.verify(&request.policy, &snapshot).await?; + let decision = verification.access_decision(); + println!("{}", serde_json::to_string_pretty(&json!({ + "adapter": adapter.descriptor(), + "snapshot": snapshot, + "verification": verification, + "access_decision": decision + }))?); + if decision != AccessDecision::Allow { std::process::exit(2); } + }, + + + + Some("discover-elasticsearch") => { + if args.next().is_some() { return Err("usage: proxima-policy-guard discover-elasticsearch".into()); } + let endpoint = env::var("PROXIMA_ELASTICSEARCH_ADAPTER_ENDPOINT") + .map_err(|_| "set PROXIMA_ELASTICSEARCH_ADAPTER_ENDPOINT to the HTTPS cluster endpoint")?; + let index_pattern = env::var("PROXIMA_ELASTICSEARCH_ADAPTER_INDEX_PATTERN") + .map_err(|_| "set PROXIMA_ELASTICSEARCH_ADAPTER_INDEX_PATTERN to the registered index pattern")?; + let target_id = env::var("PROXIMA_ELASTICSEARCH_ADAPTER_TARGET_ID") + .map_err(|_| "set PROXIMA_ELASTICSEARCH_ADAPTER_TARGET_ID to the registered non-secret target ID")?; + let authorization = env::var("PROXIMA_ELASTICSEARCH_ADAPTER_AUTHORIZATION") + .map_err(|_| "set PROXIMA_ELASTICSEARCH_ADAPTER_AUTHORIZATION to an ApiKey, Bearer or Basic Authorization value")?; + let adapter = ElasticsearchCatalogAdapter::new(target_id.clone(), index_pattern.clone(), endpoint, authorization)?; + let snapshot = adapter.discover(&DiscoveryRequest { + target: AdapterTarget { target_id, database_name: index_pattern, namespace: None }, + namespace: None, + }).await?; + println!("{}", serde_json::to_string_pretty(&json!({ + "adapter": adapter.descriptor(), + "discovery": snapshot, + "access_decision": "deny", + "note": "Index and security-role discovery is not document-level tenant enforcement; no application traffic is authorized." + }))?); + }, + Some("inspect-elasticsearch-policy") => { + let path = args.next().ok_or("usage: proxima-policy-guard inspect-elasticsearch-policy ")?; + if args.next().is_some() { return Err("only one policy file may be supplied".into()); } + let policy: TenantSecurityPolicy = serde_json::from_slice(&fs::read(&path)?)?; + policy.validate().map_err(|error| format!("invalid policy: {error:?}"))?; + let endpoint = env::var("PROXIMA_ELASTICSEARCH_ADAPTER_ENDPOINT") + .map_err(|_| "set PROXIMA_ELASTICSEARCH_ADAPTER_ENDPOINT to the HTTPS cluster endpoint")?; + let index_pattern = env::var("PROXIMA_ELASTICSEARCH_ADAPTER_INDEX_PATTERN") + .map_err(|_| "set PROXIMA_ELASTICSEARCH_ADAPTER_INDEX_PATTERN to the registered index pattern")?; + let target_id = env::var("PROXIMA_ELASTICSEARCH_ADAPTER_TARGET_ID") + .map_err(|_| "set PROXIMA_ELASTICSEARCH_ADAPTER_TARGET_ID to the registered non-secret target ID")?; + let authorization = env::var("PROXIMA_ELASTICSEARCH_ADAPTER_AUTHORIZATION") + .map_err(|_| "set PROXIMA_ELASTICSEARCH_ADAPTER_AUTHORIZATION to an ApiKey, Bearer or Basic Authorization value")?; + let adapter = ElasticsearchCatalogAdapter::new(target_id.clone(), index_pattern.clone(), endpoint, authorization)?; + let request = InspectionRequest { + target: AdapterTarget { target_id, database_name: index_pattern, namespace: None }, + policy, + }; + let snapshot = adapter.inspect(&request).await?; + let verification = adapter.verify(&request.policy, &snapshot).await?; + let decision = verification.access_decision(); + println!("{}", serde_json::to_string_pretty(&json!({ + "adapter": adapter.descriptor(), + "snapshot": snapshot, + "verification": verification, + "access_decision": decision + }))?); + if decision != AccessDecision::Allow { std::process::exit(2); } + }, + Some("discover-sqlite") => { + if args.next().is_some() { return Err("usage: proxima-policy-guard discover-sqlite".into()); } + let database_path = env::var("PROXIMA_SQLITE_ADAPTER_DATABASE_PATH") + .map_err(|_| "set PROXIMA_SQLITE_ADAPTER_DATABASE_PATH to the absolute registered SQLite file path")?; + let uri = env::var("PROXIMA_SQLITE_ADAPTER_DATABASE_URI") + .map_err(|_| "set PROXIMA_SQLITE_ADAPTER_DATABASE_URI to a sqlite:// URI for the same file")?; + let target_id = env::var("PROXIMA_SQLITE_ADAPTER_TARGET_ID") + .map_err(|_| "set PROXIMA_SQLITE_ADAPTER_TARGET_ID to the registered non-secret target ID")?; + let adapter = SqliteCatalogAdapter::new(target_id.clone(), database_path.clone(), uri)?; + let snapshot = adapter.discover(&DiscoveryRequest { + target: AdapterTarget { target_id, database_name: database_path, namespace: None }, + namespace: None, + }).await?; + println!("{}", serde_json::to_string_pretty(&json!({ + "adapter": adapter.descriptor(), + "discovery": snapshot, + "access_decision": "deny", + "note": "SQLite discovery is read-only schema and filesystem inventory. SQLite has no native row-level security or tenant users; no traffic is authorized." + }))?); + }, + Some("inspect-sqlite-policy") => { + let path = args.next().ok_or("usage: proxima-policy-guard inspect-sqlite-policy ")?; + if args.next().is_some() { return Err("only one policy file may be supplied".into()); } + let policy: TenantSecurityPolicy = serde_json::from_slice(&fs::read(&path)?)?; + policy.validate().map_err(|error| format!("invalid policy: {error:?}"))?; + let database_path = env::var("PROXIMA_SQLITE_ADAPTER_DATABASE_PATH") + .map_err(|_| "set PROXIMA_SQLITE_ADAPTER_DATABASE_PATH to the absolute registered SQLite file path")?; + let uri = env::var("PROXIMA_SQLITE_ADAPTER_DATABASE_URI") + .map_err(|_| "set PROXIMA_SQLITE_ADAPTER_DATABASE_URI to a sqlite:// URI for the same file")?; + let target_id = env::var("PROXIMA_SQLITE_ADAPTER_TARGET_ID") + .map_err(|_| "set PROXIMA_SQLITE_ADAPTER_TARGET_ID to the registered non-secret target ID")?; + let adapter = SqliteCatalogAdapter::new(target_id.clone(), database_path.clone(), uri)?; + let request = InspectionRequest { + target: AdapterTarget { target_id, database_name: database_path, namespace: None }, + policy, + }; + let snapshot = adapter.inspect(&request).await?; + let verification = adapter.verify(&request.policy, &snapshot).await?; + let decision = verification.access_decision(); + println!("{}", serde_json::to_string_pretty(&json!({ + "adapter": adapter.descriptor(), + "snapshot": snapshot, + "verification": verification, + "access_decision": decision + }))?); + if decision != AccessDecision::Allow { std::process::exit(2); } + }, + Some("discover-cockroachdb") => { + let namespace = args.next(); + if args.next().is_some() { return Err("usage: proxima-policy-guard discover-cockroachdb [schema]".into()); } + let url = env::var("PROXIMA_COCKROACH_ADAPTER_DATABASE_URL") + .map_err(|_| "set PROXIMA_COCKROACH_ADAPTER_DATABASE_URL to a CockroachDB PostgreSQL-wire URL with verified TLS")?; + let target_id = env::var("PROXIMA_COCKROACH_ADAPTER_TARGET_ID") + .map_err(|_| "set PROXIMA_COCKROACH_ADAPTER_TARGET_ID to the registered non-secret target ID")?; + let database_name = env::var("PROXIMA_COCKROACH_ADAPTER_DATABASE_NAME") + .map_err(|_| "set PROXIMA_COCKROACH_ADAPTER_DATABASE_NAME to the expected database name")?; + let connector_url = url.clone(); + let connector: CockroachConnector = std::sync::Arc::new(move || { + let connector_url = connector_url.clone(); + Box::pin(async move { + let mut config = tokio_postgres::Config::from_str(&connector_url) + .map_err(|error| AdapterError { code: "invalid_cockroach_connection_config".into(), detail: error.to_string(), retryable: false })?; + config.ssl_mode(SslMode::Require); + let tls = audit_tls_connector() + .map_err(|error| AdapterError { code: "cockroach_tls_configuration_failed".into(), detail: error.to_string(), retryable: false })?; + let (client, connection) = tokio::time::timeout(Duration::from_secs(10), config.connect(tls)) + .await + .map_err(|error| AdapterError { code: "cockroach_connection_timeout".into(), detail: error.to_string(), retryable: true })? + .map_err(|error| AdapterError { code: "cockroach_connection_failed".into(), detail: error.to_string(), retryable: error.is_closed() })?; + tokio::spawn(async move { + if let Err(error) = connection.await { + eprintln!("CockroachDB discovery connection ended: {error}"); + } + }); + Ok(client) + }) as AdapterFuture<'static, Result> + }); + let adapter = CockroachCatalogAdapter::new(target_id.clone(), database_name.clone(), connector)?; + let snapshot = adapter.discover(&DiscoveryRequest { + target: AdapterTarget { target_id, database_name, namespace: None }, + namespace, + }).await?; + println!("{}", serde_json::to_string_pretty(&json!({ + "adapter": adapter.descriptor(), + "discovery": snapshot, + "access_decision": "deny", + "note": "CockroachDB discovery is read-only inventory. PostgreSQL RLS semantics are not assumed; tenant isolation is not certified and traffic is not authorized." + }))?); + }, + + Some("inspect-cockroach-policy") => { + let path = args.next().ok_or("usage: proxima-policy-guard inspect-cockroach-policy ")?; + if args.next().is_some() { return Err("only one policy file may be supplied".into()); } + let policy: TenantSecurityPolicy = serde_json::from_slice(&fs::read(&path)?)?; + policy.validate().map_err(|error| format!("invalid policy: {error:?}"))?; + let url = env::var("PROXIMA_COCKROACH_ADAPTER_DATABASE_URL") + .map_err(|_| "set PROXIMA_COCKROACH_ADAPTER_DATABASE_URL to a CockroachDB PostgreSQL-wire URL with verified TLS")?; + let target_id = env::var("PROXIMA_COCKROACH_ADAPTER_TARGET_ID") + .map_err(|_| "set PROXIMA_COCKROACH_ADAPTER_TARGET_ID to the registered non-secret target ID")?; + let database_name = env::var("PROXIMA_COCKROACH_ADAPTER_DATABASE_NAME") + .map_err(|_| "set PROXIMA_COCKROACH_ADAPTER_DATABASE_NAME to the expected database name")?; + let connector_url = url.clone(); + let connector: CockroachConnector = std::sync::Arc::new(move || { + let connector_url = connector_url.clone(); + Box::pin(async move { + let mut config = tokio_postgres::Config::from_str(&connector_url) + .map_err(|error| AdapterError { code: "invalid_cockroach_connection_config".into(), detail: error.to_string(), retryable: false })?; + config.ssl_mode(SslMode::Require); + let tls = audit_tls_connector() + .map_err(|error| AdapterError { code: "cockroach_tls_configuration_failed".into(), detail: error.to_string(), retryable: false })?; + let (client, connection) = tokio::time::timeout(Duration::from_secs(10), config.connect(tls)) + .await + .map_err(|error| AdapterError { code: "cockroach_connection_timeout".into(), detail: error.to_string(), retryable: true })? + .map_err(|error| AdapterError { code: "cockroach_connection_failed".into(), detail: error.to_string(), retryable: error.is_closed() })?; + tokio::spawn(async move { + if let Err(error) = connection.await { + eprintln!("CockroachDB inspection connection ended: {error}"); + } + }); + Ok(client) + }) as AdapterFuture<'static, Result> + }); + let adapter = CockroachCatalogAdapter::new(target_id.clone(), database_name.clone(), connector)?; + let request = InspectionRequest { + target: AdapterTarget { target_id, database_name, namespace: None }, + policy, + }; + let snapshot = adapter.inspect(&request).await?; + let verification = adapter.verify(&request.policy, &snapshot).await?; + let decision = verification.access_decision(); + println!("{}", serde_json::to_string_pretty(&json!({ + "adapter": adapter.descriptor(), + "snapshot": snapshot, + "verification": verification, + "access_decision": decision + }))?); + if decision != AccessDecision::Allow { std::process::exit(2); } + }, + Some("discover-sql-server") => { + if args.next().is_some() { return Err("usage: proxima-policy-guard discover-sql-server".into()); } + let connection_string = env::var("PROXIMA_SQL_SERVER_ADAPTER_CONNECTION_STRING") + .map_err(|_| "set PROXIMA_SQL_SERVER_ADAPTER_CONNECTION_STRING to an encrypted SQL Server connection string")?; + let target_id = env::var("PROXIMA_SQL_SERVER_ADAPTER_TARGET_ID") + .map_err(|_| "set PROXIMA_SQL_SERVER_ADAPTER_TARGET_ID to the registered non-secret target ID")?; + let database_name = env::var("PROXIMA_SQL_SERVER_ADAPTER_DATABASE_NAME") + .map_err(|_| "set PROXIMA_SQL_SERVER_ADAPTER_DATABASE_NAME to the expected database name")?; + let adapter = SqlServerCatalogAdapter::new(target_id.clone(), database_name.clone(), connection_string)?; + let snapshot = adapter.discover(&DiscoveryRequest { + target: AdapterTarget { target_id, database_name, namespace: None }, + namespace: None, + }).await?; + println!("{}", serde_json::to_string_pretty(&json!({ + "adapter": adapter.descriptor(), + "discovery": snapshot, + "access_decision": "deny", + "note": "SQL Server discovery inventories native authorization and RLS state. It does not establish trusted SESSION_CONTEXT binding or authorize traffic." + }))?); + }, + Some("inspect-sql-server-policy") => { + let path = args.next().ok_or("usage: proxima-policy-guard inspect-sql-server-policy ")?; + if args.next().is_some() { return Err("only one policy file may be supplied".into()); } + let policy: TenantSecurityPolicy = serde_json::from_slice(&fs::read(&path)?)?; + policy.validate().map_err(|error| format!("invalid policy: {error:?}"))?; + let connection_string = env::var("PROXIMA_SQL_SERVER_ADAPTER_CONNECTION_STRING") + .map_err(|_| "set PROXIMA_SQL_SERVER_ADAPTER_CONNECTION_STRING to an encrypted SQL Server connection string")?; + let target_id = env::var("PROXIMA_SQL_SERVER_ADAPTER_TARGET_ID") + .map_err(|_| "set PROXIMA_SQL_SERVER_ADAPTER_TARGET_ID to the registered non-secret target ID")?; + let database_name = env::var("PROXIMA_SQL_SERVER_ADAPTER_DATABASE_NAME") + .map_err(|_| "set PROXIMA_SQL_SERVER_ADAPTER_DATABASE_NAME to the expected database name")?; + let adapter = SqlServerCatalogAdapter::new(target_id.clone(), database_name.clone(), connection_string)?; + let request = InspectionRequest { + target: AdapterTarget { target_id, database_name, namespace: None }, + policy, + }; + let snapshot = adapter.inspect(&request).await?; + let verification = adapter.verify(&request.policy, &snapshot).await?; + let decision = verification.access_decision(); + println!("{}", serde_json::to_string_pretty(&json!({ + "adapter": adapter.descriptor(), + "snapshot": snapshot, + "verification": verification, + "access_decision": decision + }))?); + if decision != AccessDecision::Allow { std::process::exit(2); } + }, + Some("inspect-policy") => { + let path = args.next().ok_or("usage: proxima-policy-guard inspect-policy ")?; + let policy: TenantSecurityPolicy = serde_json::from_slice(&fs::read(&path)?)?; + policy.validate().map_err(|error| format!("invalid policy: {error:?}"))?; + let url = env::var("PROXIMA_POSTGRES_ADAPTER_DATABASE_URL") + .map_err(|_| "set PROXIMA_POSTGRES_ADAPTER_DATABASE_URL to a TLS-verified PostgreSQL URL")?; + let target_id = env::var("PROXIMA_POSTGRES_ADAPTER_TARGET_ID") + .map_err(|_| "set PROXIMA_POSTGRES_ADAPTER_TARGET_ID to the registered non-secret target ID")?; + let database_name = env::var("PROXIMA_POSTGRES_ADAPTER_DATABASE_NAME") + .map_err(|_| "set PROXIMA_POSTGRES_ADAPTER_DATABASE_NAME to the expected database name")?; + let tenant_role_prefix = env::var("PROXIMA_TENANT_ROLE_PREFIX") + .map_err(|_| "set PROXIMA_TENANT_ROLE_PREFIX to the Engine's tenant role prefix")?; + let connector_url = url.clone(); + let connector: PostgresConnector = std::sync::Arc::new(move || { + let connector_url = connector_url.clone(); + Box::pin(async move { + let mut config = tokio_postgres::Config::from_str(&connector_url) + .map_err(|error| AdapterError { code: "invalid_postgres_connection_config".into(), detail: error.to_string(), retryable: false })?; + config.ssl_mode(SslMode::Require); + let tls = audit_tls_connector() + .map_err(|error| AdapterError { code: "postgres_tls_configuration_failed".into(), detail: error.to_string(), retryable: false })?; + let (client, connection) = tokio::time::timeout(Duration::from_secs(10), config.connect(tls)) + .await + .map_err(|error| AdapterError { code: "postgres_connection_timeout".into(), detail: error.to_string(), retryable: true })? + .map_err(|error| AdapterError { code: "postgres_connection_failed".into(), detail: error.to_string(), retryable: error.is_closed() })?; + tokio::spawn(async move { + if let Err(error) = connection.await { + eprintln!("PostgreSQL adapter connection ended: {error}"); + } + }); + Ok(client) + }) as AdapterFuture<'static, Result> + }); + let adapter = PostgresCatalogAdapter::new(target_id.clone(), database_name.clone(), tenant_role_prefix, connector)?; + let request = InspectionRequest { + target: AdapterTarget { + target_id, + database_name, + namespace: None, + }, + policy, + }; + let snapshot = adapter.inspect(&request).await?; + let verification = adapter.verify(&request.policy, &snapshot).await?; + let decision = verification.access_decision(); + println!("{}", serde_json::to_string_pretty(&json!({ + "adapter": adapter.descriptor(), + "snapshot": snapshot, + "verification": verification, + "access_decision": decision + }))?); + if decision != AccessDecision::Allow { std::process::exit(2); } + }, + Some("audit") => { + let url=env::var("PROXIMA_POLICY_AUDIT_DATABASE_URL").map_err(|_|"set PROXIMA_POLICY_AUDIT_DATABASE_URL to a read-only inspection URL")?; + let value=report(&inspect(&url).await?); + println!("{}",serde_json::to_string_pretty(&value)?); + if value["finding_count"].as_u64().unwrap_or(0)>0 { std::process::exit(2); } + }, + Some("generate") => { + let path=args.next().ok_or("usage: proxima-policy-guard generate ")?; + let spec:Value=serde_json::from_slice(&fs::read(Path::new(&path))?)?; + print!("{}",generate(&spec)?); + }, + _ => return Err("usage: proxima-policy-guard ".into()) + } + Ok(()) +} +#[cfg(test)] +mod tests { + use super::*; + #[test] fn catalog_audit_never_claims_verified_posture() { + let value=report(&[]); + assert_eq!(value["security_posture"],"unknown"); + assert_eq!(value["access_decision"],"deny"); + assert_eq!(value["inspection_status"],"inspection_only"); + } + #[test] fn escapes_sql_names_and_values() { + assert_eq!(ident("a\"b"),"\"a\"\"b\""); + assert_eq!(literal("a'b"),"'a''b'"); + } + #[test] fn generator_uses_role_bound_identity() { + let spec=json!({"tables":[{"schema":"public","table":"orders","tenant_column":"tenant_id","tenants":[ + {"tenant_id":"tenant-a","role":"proxima_tenant_tenant_a"},{"tenant_id":"tenant-b","role":"proxima_tenant_tenant_b"}]}]}); + let sql=generate(&spec).unwrap(); + assert!(sql.contains("current_user = 'proxima_tenant_tenant_a'")); + assert!(sql.contains("\"tenant_id\" = 'tenant-b'")); + assert!(sql.contains("FORCE ROW LEVEL SECURITY")); + assert!(sql.contains("other permissive RLS policies must be reconciled first")); + assert!(sql.contains("BEGIN;")); + assert!(sql.contains("COMMIT;")); + assert!(sql.contains("Required PROXIMA_TENANT_ROLE_PREFIX: proxima_tenant_")); + assert!(!sql.contains("current_setting")); + assert!(!sql.contains("DROP POLICY")); + assert!(sql.contains("policy name already exists")); + } + #[test] fn flags_non_forced_rls_and_owner_privileges() { + let rows=vec![TableFinding{schema:"public".into(),table:"orders".into(),owner:"app_owner".into(),rls_enabled:true,rls_forced:false,owner_has_elevated_privileges:false,public_select:false,public_write_or_truncate:false,truncate_grant:false,bypass_role_grant:false,policy_count:1,permissive_policy_count:1,security_definer_routines:0}]; + let value=report(&rows); + assert!(value["tables"][0]["findings"].as_array().unwrap().iter().any(|v|v=="table_owner_has_elevated_privileges")); + } + #[test] fn rejects_empty_mapping() { + let spec=json!({"tables":[{"schema":"public","table":"orders","tenant_column":"tenant_id","tenants":[]}]}); + assert!(generate(&spec).is_err()); + } + #[test] fn rejects_overlong_postgres_identifiers() { + let spec=json!({"tables":[{"schema":"public","table":"x".repeat(64),"tenant_column":"tenant_id","tenants":[{"tenant_id":"a","role":"proxima_a"}]}]}); + assert!(generate(&spec).is_err()); + } + #[test] fn rejects_duplicate_tenant_roles() { + let spec=json!({"tables":[{"schema":"public","table":"orders","tenant_column":"tenant_id","tenants":[ + {"tenant_id":"tenant-a","role":"proxima_shared"},{"tenant_id":"tenant-b","role":"proxima_shared"}]}]}); + assert!(generate(&spec).is_err()); + } + #[test] fn rejects_duplicate_table_mappings() { + let spec=json!({"tables":[ + {"schema":"public","table":"orders","tenant_column":"tenant_id","tenants":[{"tenant_id":"a","role":"proxima_a"}]}, + {"schema":"public","table":"orders","tenant_column":"tenant_id","tenants":[{"tenant_id":"b","role":"proxima_b"}]} + ]}); + assert!(generate(&spec).is_err()); + } + #[test] fn rejects_nul_and_unsafe_role_identifiers() { + let nul_identifier=json!({"tables":[{"schema":format!("public{}", '\0'),"table":"orders","tenant_column":"tenant_id","tenants":[{"tenant_id":"a","role":"proxima_a"}]}]}); + let nul_tenant=json!({"tables":[{"schema":"public","table":"orders","tenant_column":"tenant_id","tenants":[{"tenant_id":format!("a{}b", '\0'),"role":"proxima_a"}]}]}); + let invalid_role=json!({"tables":[{"schema":"public","table":"orders","tenant_column":"tenant_id","tenants":[{"tenant_id":"a","role":"proxima-a"}]}]}); + assert!(generate(&nul_identifier).is_err()); + assert!(generate(&nul_tenant).is_err()); + assert!(generate(&invalid_role).is_err()); + } +} diff --git a/crates/proxima-engine/src/cockroach_adapter.rs b/crates/proxima-engine/src/cockroach_adapter.rs new file mode 100644 index 00000000..0678ed1c --- /dev/null +++ b/crates/proxima-engine/src/cockroach_adapter.rs @@ -0,0 +1,394 @@ +//! CockroachDB native catalog discovery adapter. +//! +//! CockroachDB speaks the PostgreSQL wire protocol but has distinct authorization +//! and feature semantics. This module intentionally performs discovery only; +//! it does not reuse PostgreSQL RLS assumptions or claim tenant isolation. +use crate::database_adapter::{ + AdapterError, AdapterFuture, AdapterTarget, CompiledPolicy, DatabaseAdapter, + DiscoveryRequest, DiscoverySnapshot, DiscoveredResource, DriftReport, + InspectionRequest, InspectionSnapshot, ResourceInspection, +}; +use crate::security_core::{ + AdapterCapabilities, AdapterDescriptor, AdapterMaturity, DatabaseKind, + InspectionCompleteness, ResourceKind, ResourceRef, SecurityFinding, + SecurityPosture, TenantSecurityPolicy, VerificationReport, SECURITY_MODEL_VERSION, +}; +use serde_json::json; +use sha2::{Digest, Sha256}; +use std::sync::Arc; +use tokio_postgres::Client; + +pub type CockroachConnector = + Arc AdapterFuture<'static, Result> + Send + Sync>; + +pub struct CockroachCatalogAdapter { + target_id: String, + database_name: String, + connect: CockroachConnector, +} + +impl CockroachCatalogAdapter { + pub fn new( + target_id: impl Into, + database_name: impl Into, + connect: CockroachConnector, + ) -> Result { + let target_id = target_id.into(); + let database_name = database_name.into(); + if target_id.trim().is_empty() || target_id.len() > 256 || target_id.contains('\0') + || database_name.trim().is_empty() || database_name.len() > 63 + || database_name.contains('\0') + { + return Err(error("invalid_cockroach_target", "A bounded target ID and database name are required.")); + } + Ok(Self { target_id, database_name, connect }) + } + + fn validate_target(&self, target: &AdapterTarget) -> Result<(), AdapterError> { + if target.target_id != self.target_id || target.database_name != self.database_name { + return Err(error("cockroach_target_mismatch", "The request does not match this registered CockroachDB target.")); + } + Ok(()) + } + + async fn connect_checked(&self) -> Result { + let client = (self.connect)().await?; + client.batch_execute( + "SET default_transaction_read_only = on; SET statement_timeout = '10s'; SET search_path = pg_catalog, public" + ).await.map_err(db_error)?; + let row = client.query_one( + "SELECT current_database(), current_user, version()", &[] + ).await.map_err(db_error)?; + let database: String = row.get(0); + let user: String = row.get(1); + let version: String = row.get(2); + if database != self.database_name { + return Err(error("cockroach_database_mismatch", "The authenticated connection reached a different database.")); + } + if !version.to_ascii_lowercase().contains("cockroach") { + return Err(error("cockroach_server_identity_mismatch", "The endpoint did not identify itself as CockroachDB.")); + } + if user.trim().is_empty() { + return Err(error("cockroach_authenticated_identity_missing", "The server did not expose an authenticated principal.")); + } + Ok(client) + } + + async fn discover_inner(&self, request: &DiscoveryRequest) -> Result { + self.validate_target(&request.target)?; + if request.namespace.as_ref().is_some_and(|schema| { + schema.trim().is_empty() || schema.len() > 63 || schema.contains('\0') + }) { + return Err(error("invalid_cockroach_namespace", "The requested schema name is empty or exceeds the identifier limit.")); + } + let client = self.connect_checked().await?; + let rows = client.query( + "SELECT table_schema, table_name, table_type FROM information_schema.tables \ + WHERE table_catalog = current_database() \ + AND table_schema NOT IN ('information_schema', 'pg_catalog', 'crdb_internal', 'pg_extension') \ + AND ($1::STRING IS NULL OR table_schema = $1) \ + ORDER BY table_schema, table_name LIMIT 10001", + &[&request.namespace], + ).await.map_err(db_error)?; + let truncated = rows.len() > 10_000; + let mut resources = Vec::with_capacity(rows.len().min(10_000)); + let mut findings = Vec::new(); + let mut state = Vec::new(); + for row in rows.into_iter().take(10_000) { + let schema: String = row.get(0); + let name: String = row.get(1); + let table_type: String = row.get(2); + let columns = client.query( + "SELECT column_name, data_type, is_nullable, column_default \ + FROM information_schema.columns \ + WHERE table_catalog=current_database() AND table_schema=$1 AND table_name=$2 \ + ORDER BY ordinal_position", + &[&schema, &name], + ).await.map_err(db_error)?; + let privileges = client.query( + "SELECT grantee, privilege_type, is_grantable \ + FROM information_schema.table_privileges \ + WHERE table_catalog=current_database() AND table_schema=$1 AND table_name=$2 \ + ORDER BY grantee, privilege_type", + &[&schema, &name], + ).await.map_err(db_error)?; + let column_state: Vec<_> = columns.iter().map(|column| json!({ + "name": column.get::<_, String>(0), + "data_type": column.get::<_, String>(1), + "nullable": column.get::<_, String>(2) == "YES", + "default": column.get::<_, Option>(3), + })).collect(); + let privilege_state: Vec<_> = privileges.iter().map(|grant| json!({ + "grantee": grant.get::<_, String>(0), + "privilege": grant.get::<_, String>(1), + "grantable": grant.get::<_, String>(2) == "YES", + })).collect(); + let kind = if table_type.eq_ignore_ascii_case("VIEW") { ResourceKind::View } else { ResourceKind::Table }; + let reference = ResourceRef { namespace: Some(schema.clone()), name: name.clone(), kind }; + if kind == ResourceKind::View { + findings.push(SecurityFinding { + code: "cockroach_view_requires_dependency_review".into(), + resource: Some(reference.clone()), + detail: "View dependencies and invoker/definer behavior require separate review before tenant protection can be asserted.".into(), + }); + } + resources.push(DiscoveredResource { + namespace: Some(schema.clone()), + name: name.clone(), + kind, + owner: None, + attributes: json!({ + "table_type": table_type, + "columns": column_state.clone(), + "privileges": privilege_state.clone(), + }), + }); + state.push(json!({ + "schema": schema, "name": name, "kind": table_type, + "columns": column_state, "privileges": privilege_state, + })); + } + // This adapter does not yet enumerate database/schema ACLs, role memberships, + // ownership or effective inherited privileges, so its security inventory is + // incomplete even when every relation fits within the relation-count bound. + let completeness = InspectionCompleteness::Incomplete; + findings.push(SecurityFinding { + code: "cockroach_security_catalog_scope_incomplete".into(), + resource: None, + detail: "Discovery currently captures visible table grants only. Database/schema privileges, role memberships, relation ownership and effective inherited privileges are not yet inventoried.".into(), + }); + if truncated { + findings.push(SecurityFinding { + code: "cockroach_discovery_limit_reached".into(), + resource: None, + detail: "The inventory exceeded 10,000 relations; discovery is incomplete and cannot be used as a clean baseline.".into(), + }); + } + let server_version: String = client.query_one("SELECT version()", &[]).await.map_err(db_error)?.get(0); + let fingerprint = digest(&serde_json::to_vec(&json!({ + "target_id": self.target_id, + "database_name": self.database_name, + "server_version": server_version, + "resources": state + })).map_err(|_| error("cockroach_fingerprint_failed", "Catalog state could not be serialized."))?); + let observed_at: String = client.query_one( + "SELECT to_char(now() AT TIME ZONE 'UTC', 'YYYY-MM-DD\"T\"HH24:MI:SS.US\"Z\"')", &[] + ).await.map_err(db_error)?.get(0); + Ok(DiscoverySnapshot { + database_kind: DatabaseKind::CockroachDb, + target: request.target.clone(), + completeness, + target_attributes: json!({ "server_version": server_version }), + resources, + findings, + fingerprint: Some(fingerprint), + observed_at, + }) + } + + async fn discover_bounded(&self, request: &DiscoveryRequest) -> Result { + tokio::time::timeout(std::time::Duration::from_secs(60), self.discover_inner(request)) + .await + .map_err(|_| AdapterError { + code: "cockroach_catalog_timeout".into(), + detail: "CockroachDB catalog discovery exceeded the sixty-second operation deadline.".into(), + retryable: true, + })? + } + +} + +impl DatabaseAdapter for CockroachCatalogAdapter { + fn descriptor(&self) -> AdapterDescriptor { + AdapterDescriptor { + kind: DatabaseKind::CockroachDb, + name: "CockroachDB catalog adapter", + maturity: AdapterMaturity::InDevelopment, + capabilities: AdapterCapabilities { schema_inspection: true, drift_detection: true, ..AdapterCapabilities::default() }, + status_note: "TLS-verified PostgreSQL-wire catalog discovery covers non-system tables, views, columns and visible table grants with bounded fingerprints. CockroachDB-native tenant enforcement, policy deployment, independent semantic probes and runtime admission are not implemented; PostgreSQL RLS behavior is not assumed.", + } + } + + fn discover<'a>(&'a self, request: &'a DiscoveryRequest) -> AdapterFuture<'a, Result> { + Box::pin(async move { self.discover_bounded(request).await }) + } + + fn inspect<'a>(&'a self, request: &'a InspectionRequest) -> AdapterFuture<'a, Result> { + Box::pin(async move { + request.policy.validate().map_err(|_| error("invalid_policy", "The canonical tenant policy failed validation."))?; + let discovery = self.discover_bounded(&DiscoveryRequest { target: request.target.clone(), namespace: None }).await?; + let mut findings = discovery.findings.clone(); + let mut inspected = Vec::new(); + for required in &request.policy.resources { + let discovered = discovery.resources.iter().find(|resource| { + resource.namespace == required.resource.namespace + && resource.name == required.resource.name + && resource.kind == required.resource.kind + }); + let Some(resource) = discovered else { + findings.push(SecurityFinding { + code: "cockroach_required_resource_missing".into(), + resource: Some(required.resource.clone()), + detail: "The policy resource was not present in the complete native catalog inventory.".into(), + }); + continue; + }; + let columns = resource.attributes.get("columns").and_then(|value| value.as_array()).cloned().unwrap_or_default(); + let tenant_column = columns.iter().find(|column| column.get("name").and_then(|value| value.as_str()) == Some(required.tenant_key.as_str())); + let mut resource_findings = Vec::new(); + if tenant_column.is_none() { + resource_findings.push(SecurityFinding { + code: "cockroach_tenant_key_missing".into(), + resource: Some(required.resource.clone()), + detail: "The declared tenant ownership column does not exist in the native table metadata.".into(), + }); + } else if tenant_column.and_then(|column| column.get("nullable")).and_then(|value| value.as_bool()) == Some(true) { + resource_findings.push(SecurityFinding { + code: "cockroach_tenant_key_nullable".into(), + resource: Some(required.resource.clone()), + detail: "The declared tenant ownership column permits NULL values; rows without a tenant owner cannot be assigned safely.".into(), + }); + } + findings.extend(resource_findings.iter().cloned()); + inspected.push(ResourceInspection { + resource: required.clone(), + completeness: discovery.completeness, + posture: SecurityPosture::NeedsAttention, + verified_operations: Vec::new(), + findings: resource_findings, + fingerprint: discovery.fingerprint.clone(), + }); + } + findings.push(SecurityFinding { + code: "cockroach_native_enforcement_not_implemented".into(), + resource: None, + detail: "Catalog discovery does not prove tenant isolation. A CockroachDB-specific authorization model, trusted tenant binding and independent cross-tenant probes are required.".into(), + }); + Ok(InspectionSnapshot { + database_kind: DatabaseKind::CockroachDb, + target: discovery.target, + completeness: discovery.completeness, + posture: SecurityPosture::NeedsAttention, + resources: inspected, + findings, + fingerprint: discovery.fingerprint, + observed_at: discovery.observed_at, + }) + }) + } + + fn compile_policy(&self, _policy: &TenantSecurityPolicy) -> Result { + Err(error("cockroach_policy_compilation_unavailable", "CockroachDB policy compilation is disabled until its native authorization semantics and deployment safety are implemented.")) + } + + fn verify<'a>(&'a self, _policy: &'a TenantSecurityPolicy, snapshot: &'a InspectionSnapshot) -> AdapterFuture<'a, Result> { + Box::pin(async move { + if snapshot.database_kind != DatabaseKind::CockroachDb || snapshot.target.target_id != self.target_id || snapshot.target.database_name != self.database_name { + return Err(error("cockroach_snapshot_target_mismatch", "The inspection snapshot belongs to a different database target.")); + } + let mut findings = snapshot.findings.clone(); + findings.push(SecurityFinding { + code: "cockroach_semantic_verification_unavailable".into(), + resource: None, + detail: "CockroachDB isolation has not been proven with independent authenticated positive and cross-tenant negative probes.".into(), + }); + Ok(VerificationReport { model_version: SECURITY_MODEL_VERSION.into(), posture: SecurityPosture::Blocked, inspection: snapshot.completeness, findings }) + }) + } + + fn detect_drift<'a>(&'a self, target: &'a AdapterTarget, previous_fingerprint: Option<&'a str>) -> AdapterFuture<'a, Result> { + Box::pin(async move { + self.validate_target(target)?; + if previous_fingerprint.is_some_and(|value| value.len() != 64 || hex::decode(value).map_or(true, |decoded| decoded.len() != 32)) { + return Err(error("invalid_previous_fingerprint", "The previous fingerprint must be a 32-byte hexadecimal SHA-256 digest.")); + } + let snapshot = self.discover_bounded(&DiscoveryRequest { target: target.clone(), namespace: None }).await?; + let detected = previous_fingerprint.is_some_and(|previous| Some(previous) != snapshot.fingerprint.as_deref()); + Ok(DriftReport { + database_kind: DatabaseKind::CockroachDb, + target: target.clone(), + detected, + completeness: snapshot.completeness, + previous_fingerprint: previous_fingerprint.map(str::to_owned), + observed_fingerprint: snapshot.fingerprint, + findings: if detected { vec![SecurityFinding { + code: "cockroach_catalog_fingerprint_changed".into(), + resource: None, + detail: "CockroachDB schema or table grants differ from the previously accepted catalog fingerprint.".into(), + }] } else { snapshot.findings }, + observed_at: snapshot.observed_at, + }) + }) + } +} + +fn digest(bytes: &[u8]) -> String { hex::encode(Sha256::digest(bytes)) } +fn error(code: &str, detail: &str) -> AdapterError { AdapterError { code: code.into(), detail: detail.into(), retryable: false } } +fn db_error(error: tokio_postgres::Error) -> AdapterError { + AdapterError { code: "cockroach_catalog_query_failed".into(), detail: error.to_string(), retryable: error.is_closed() } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn rejects_empty_or_unbounded_target_configuration() { + let connector: CockroachConnector = Arc::new(|| Box::pin(async { + Err(error("not_connected", "test connector")) + })); + assert!(CockroachCatalogAdapter::new("", "app", connector.clone()).is_err()); + assert!(CockroachCatalogAdapter::new("target", "", connector).is_err()); + } + + #[tokio::test] + async fn rejects_a_different_registered_target_before_connecting() { + let connector: CockroachConnector = Arc::new(|| Box::pin(async { + Err(error("connector_must_not_run", "target validation should fail first")) + })); + let adapter = CockroachCatalogAdapter::new("target-a", "app", connector).unwrap(); + let request = DiscoveryRequest { + target: AdapterTarget { target_id: "target-b".into(), database_name: "app".into(), namespace: None }, + namespace: None, + }; + assert_eq!(adapter.discover(&request).await.unwrap_err().code, "cockroach_target_mismatch"); + } + + #[test] + fn policy_compilation_is_disabled_until_native_controls_exist() { + let connector: CockroachConnector = Arc::new(|| Box::pin(async { + Err(error("not_connected", "test connector")) + })); + let adapter = CockroachCatalogAdapter::new("target", "app", connector).unwrap(); + let policy = TenantSecurityPolicy { + schema_version: SECURITY_MODEL_VERSION.into(), + policy_id: "policy".into(), + revision: 1, + tenant_identity_claim: "tenant_id".into(), + resources: vec![crate::security_core::ProtectedResource { + resource: ResourceRef { namespace: Some("public".into()), name: "records".into(), kind: ResourceKind::Table }, + tenant_key: "tenant_id".into(), + operations: vec![crate::security_core::Operation::Read], + }], + }; + assert_eq!(adapter.compile_policy(&policy).unwrap_err().code, "cockroach_policy_compilation_unavailable"); + } + + #[test] + fn descriptor_claims_discovery_only() { + let connector: CockroachConnector = Arc::new(|| Box::pin(async { + Err(error("not_connected", "test connector")) + })); + let adapter = CockroachCatalogAdapter::new("target", "app", connector).unwrap(); + let descriptor = adapter.descriptor(); + assert_eq!(descriptor.maturity, AdapterMaturity::InDevelopment); + assert!(descriptor.capabilities.schema_inspection); + assert!(descriptor.capabilities.drift_detection); + assert!(!descriptor.capabilities.tenant_identity_enforcement); + assert!(!descriptor.capabilities.policy_semantic_verification); + assert!(!descriptor.capabilities.policy_generation); + assert!(!descriptor.capabilities.controlled_policy_deployment); + assert!(!descriptor.capabilities.runtime_fail_closed_admission); + assert!(!descriptor.capabilities.signed_security_evidence); + } +} diff --git a/crates/proxima-engine/src/config.rs b/crates/proxima-engine/src/config.rs index 730b4c54..21bee144 100644 --- a/crates/proxima-engine/src/config.rs +++ b/crates/proxima-engine/src/config.rs @@ -69,13 +69,14 @@ impl Config { let tenant_role_prefix = env::var("PROXIMA_TENANT_ROLE_PREFIX") .unwrap_or_else(|_| "proxima_tenant_".to_string()); if tenant_role_prefix.is_empty() + || tenant_role_prefix.len() > 27 || !tenant_role_prefix .bytes() .all(|byte| byte.is_ascii_alphanumeric() || byte == b'_') { return Err(io::Error::new( io::ErrorKind::InvalidInput, - "PROXIMA_TENANT_ROLE_PREFIX must contain only ASCII letters, digits, and underscores", + "PROXIMA_TENANT_ROLE_PREFIX must contain only ASCII letters, digits, and underscores and be at most 27 bytes", )); } @@ -291,6 +292,19 @@ mod tests { assert!(config.dashboard_enabled); } + #[test] + #[serial] + fn rejects_role_prefix_longer_than_control_plane_limit() { + let previous = std::env::var_os("PROXIMA_TENANT_ROLE_PREFIX"); + std::env::set_var("PROXIMA_TENANT_ROLE_PREFIX", "x".repeat(28)); + let error = Config::from_env().unwrap_err(); + assert_eq!(error.kind(), io::ErrorKind::InvalidInput); + match previous { + Some(value) => std::env::set_var("PROXIMA_TENANT_ROLE_PREFIX", value), + None => std::env::remove_var("PROXIMA_TENANT_ROLE_PREFIX"), + } + } + #[test] #[serial] fn tls_cert_and_key_are_a_pair() { diff --git a/crates/proxima-engine/src/connection_admission.rs b/crates/proxima-engine/src/connection_admission.rs new file mode 100644 index 00000000..6a0cc8c7 --- /dev/null +++ b/crates/proxima-engine/src/connection_admission.rs @@ -0,0 +1,331 @@ +//! One-use, connection-bound policy admission replay protection. +//! +//! The protocol listener must call `consume_for_connection` before admitting a +//! tenant session. A valid signed envelope is accepted by at most one connection +//! per process. Reconnects require fresh evidence and a fresh envelope. + +use crate::policy_evidence::{ + AdmissionExpectation, EvidenceError, PolicyEvidenceAuthority, + SignedPolicyAdmission, SignedPolicyEvidence, +}; +use crate::security_core::AccessDecision; +use crate::tenant_identity::VerifiedTenantIdentity; +use std::collections::HashMap; +use std::sync::Mutex; + +fn validate_connection_id(connection_id: &str) -> Result<(), EvidenceError> { + if connection_id.trim().is_empty() || connection_id.len() > 256 || connection_id.contains('\0') { + return Err(EvidenceError { + code: "invalid_connection_id", + detail: "A non-empty, bounded protocol connection identifier is required.", + }); + } + Ok(()) +} + +#[derive(Default)] +pub struct ConnectionAdmissionGate { + consumed: Mutex>, +} + +impl ConnectionAdmissionGate { + pub fn new() -> Self { + Self::default() + } + + /// Verify all signed claims and atomically bind this admission to one + /// connection identifier. Reuse by the same connection is also rejected: + /// admission is a one-shot transition, not a reusable bearer credential. + pub fn consume_for_connection( + &self, + authority: &PolicyEvidenceAuthority, + admission: &SignedPolicyAdmission, + evidence: &SignedPolicyEvidence, + expected: AdmissionExpectation<'_>, + connection_id: &str, + now_unix: i64, + ) -> Result { + validate_connection_id(connection_id)?; + // Cryptographic, freshness, target, revision and tenant checks happen + // before consuming the replay slot. Invalid attempts cannot burn a + // legitimate admission belonging to a valid connection. + authority.verify_admission(admission, evidence, expected, now_unix)?; + self.consume_verified(admission, None, connection_id, now_unix) + } + + /// Consume both a verified tenant identity request ID and its matching + /// policy admission in one critical section. This prevents a caller from + /// reusing one scoped identity to obtain multiple connection admissions. + pub fn consume_for_identity( + &self, + authority: &PolicyEvidenceAuthority, + admission: &SignedPolicyAdmission, + evidence: &SignedPolicyEvidence, + identity: &VerifiedTenantIdentity, + connection_id: &str, + now_unix: i64, + ) -> Result { + validate_connection_id(connection_id)?; + if identity.issued_at_unix() > now_unix || identity.expires_at_unix() <= now_unix { + return Err(EvidenceError { + code: "tenant_identity_expired", + detail: "The verified tenant identity is not currently valid.", + }); + } + authority.verify_admission( + admission, + evidence, + identity.admission_expectation(), + now_unix, + )?; + self.consume_verified( + admission, + Some((identity.request_id(), identity.expires_at_unix())), + connection_id, + now_unix, + ) + } + + fn consume_verified( + &self, + admission: &SignedPolicyAdmission, + identity_request: Option<(&str, i64)>, + connection_id: &str, + now_unix: i64, + ) -> Result { + let mut consumed = self.consumed.lock().map_err(|_| EvidenceError { + code: "admission_gate_unavailable", + detail: "The in-process admission replay registry is unavailable; access is denied.", + })?; + consumed.retain(|_, (_, expires_at)| *expires_at > now_unix); + + // Never evict live entries: eviction would make a still-valid signed + // admission or identity request replayable. + const MAX_ACTIVE_ADMISSIONS: usize = 100_000; + let needed = if identity_request.is_some() { 2 } else { 1 }; + if consumed.len().saturating_add(needed) > MAX_ACTIVE_ADMISSIONS { + return Err(EvidenceError { + code: "admission_capacity_exceeded", + detail: "The replay registry reached its safety limit; new admissions are denied until entries expire.", + }); + } + + let admission_key = format!("admission:{}", admission.signature); + let identity_key = identity_request.map(|(request_id, _)| format!("identity:{request_id}")); + if consumed.contains_key(&admission_key) + || identity_key.as_ref().is_some_and(|key| consumed.contains_key(key)) + { + return Err(EvidenceError { + code: "admission_replay_detected", + detail: "This signed admission or tenant identity request has already been consumed.", + }); + } + + consumed.insert( + admission_key, + (connection_id.to_owned(), admission.expires_at_unix), + ); + if let (Some(identity_key), Some((_, identity_expiry))) = (identity_key, identity_request) { + consumed.insert(identity_key, (connection_id.to_owned(), identity_expiry)); + } + Ok(AccessDecision::Allow) + } + + /// Number of unexpired admissions currently held by this process. + /// Exposed for health/diagnostic tests, never as an authorization decision. + pub fn active_consumptions(&self, now_unix: i64) -> Result { + let mut consumed = self.consumed.lock().map_err(|_| EvidenceError { + code: "admission_gate_unavailable", + detail: "The in-process admission replay registry is unavailable.", + })?; + consumed.retain(|_, (_, expires_at)| *expires_at > now_unix); + Ok(consumed.len()) + } +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::policy_evidence::{EvidenceCheck, EvidenceCheckKind, PolicyEvidenceAuthority, PolicyEvidencePayload}; + use crate::security_core::{ + DatabaseKind, InspectionCompleteness, Operation, ProtectedResource, ResourceRef, + SecurityFinding, SecurityPosture, SECURITY_MODEL_VERSION, + }; + use crate::tenant_identity::{ + TenantIdentityAuthority, TenantIdentityClaims, TenantIdentityExpectation, + }; + + fn authority() -> PolicyEvidenceAuthority { + PolicyEvidenceAuthority::new(vec![11; 32], vec![19; 32]).unwrap() + } + + fn protected_resource() -> ProtectedResource { + ProtectedResource { + resource: ResourceRef { + namespace: Some("public".into()), + name: "orders".into(), + kind: crate::security_core::ResourceKind::Table, + }, + tenant_key: "tenant_id".into(), + operations: vec![Operation::Read, Operation::Create, Operation::Update, Operation::Delete], + } + } + + fn semantic_checks(resource: &ProtectedResource) -> Vec { + let mut checks = Vec::new(); + for operation in &resource.operations { + checks.push(EvidenceCheck { + resource: resource.resource.clone(), + operation: *operation, + kind: EvidenceCheckKind::OwnTenantAllow, + passed: true, + detail: format!("own-tenant {operation:?} probe passed"), + }); + checks.push(EvidenceCheck { + resource: resource.resource.clone(), + operation: *operation, + kind: EvidenceCheckKind::CrossTenantDeny, + passed: true, + detail: format!("cross-tenant {operation:?} probe denied"), + }); + if matches!(operation, Operation::Create | Operation::Update | Operation::Delete) { + checks.push(EvidenceCheck { + resource: resource.resource.clone(), + operation: *operation, + kind: EvidenceCheckKind::MutationRollback, + passed: true, + detail: format!("own-tenant {operation:?} mutation was rolled back"), + }); + } + } + checks + } + + fn signed_pair(authority: &PolicyEvidenceAuthority) -> (SignedPolicyEvidence, SignedPolicyAdmission) { + let resource = protected_resource(); + let checks = semantic_checks(&resource); + let payload = PolicyEvidencePayload { + model_version: SECURITY_MODEL_VERSION.into(), + policy_id: "tenant-boundary".into(), + policy_revision: 3, + database_kind: DatabaseKind::PostgreSql, + target_id: "prod-db".into(), + tenant_id: "tenant-a".into(), + posture: SecurityPosture::Verified, + inspection: InspectionCompleteness::Complete, + findings: Vec::::new(), + protected_resources: vec![resource], + verified_operations: vec![Operation::Read, Operation::Create, Operation::Update, Operation::Delete], + fingerprint: "c".repeat(64), + observed_at_unix: 1_900_000_000, + checks, + }; + let evidence = authority.sign_evidence(payload).unwrap(); + let admission = authority.issue_admission(&evidence, 1_900_000_001, 30).unwrap(); + (evidence, admission) + } + + fn expected() -> AdmissionExpectation<'static> { + AdmissionExpectation { database_kind: DatabaseKind::PostgreSql, policy_id: "tenant-boundary", policy_revision: 3, target_id: "prod-db", tenant_id: "tenant-a" } + } + + #[test] + fn scoped_identity_and_admission_are_consumed_atomically() { + let admission_authority = authority(); + let identity_authority = TenantIdentityAuthority::new(vec![31; 32]).unwrap(); + let gate = ConnectionAdmissionGate::new(); + let (evidence, first_admission) = signed_pair(&admission_authority); + let identity_claims = TenantIdentityClaims { + schema_version: "proxima.tenant-identity.v1".into(), + tenant_id: "tenant-a".into(), + principal_id: "app-service".into(), + target_id: "prod-db".into(), + database_kind: DatabaseKind::PostgreSql, + policy_id: "tenant-boundary".into(), + policy_revision: 3, + request_id: "550e8400-e29b-41d4-a716-446655440000".into(), + issued_at_unix: 1_900_000_001, + expires_at_unix: 1_900_000_030, + }; + let token = identity_authority.sign(&identity_claims, 1_900_000_001).unwrap(); + let expected = TenantIdentityExpectation { + tenant_id: "tenant-a", + principal_id: "app-service", + target_id: "prod-db", + database_kind: DatabaseKind::PostgreSql, + policy_id: "tenant-boundary", + policy_revision: 3, + }; + let verified = identity_authority.verify(&token, expected, 1_900_000_002).unwrap(); + assert_eq!( + gate.consume_for_identity( + &admission_authority, &first_admission, &evidence, &verified, + "conn-1", 1_900_000_002, + ), + Ok(AccessDecision::Allow), + ); + + let second_admission = admission_authority.issue_admission(&evidence, 1_900_000_004, 30).unwrap(); + let verified_again = identity_authority.verify(&token, expected, 1_900_000_005).unwrap(); + assert_eq!( + gate.consume_for_identity( + &admission_authority, &second_admission, &evidence, &verified_again, + "conn-2", 1_900_000_005, + ).unwrap_err().code, + "admission_replay_detected", + ); + } + + #[test] + fn admission_is_consumed_once() { + let authority = authority(); + let gate = ConnectionAdmissionGate::new(); + let (evidence, admission) = signed_pair(&authority); + assert_eq!(gate.consume_for_connection(&authority, &admission, &evidence, expected(), "conn-1", 1_900_000_002), Ok(AccessDecision::Allow)); + assert_eq!(gate.consume_for_connection(&authority, &admission, &evidence, expected(), "conn-1", 1_900_000_003).unwrap_err().code, "admission_replay_detected"); + } + + #[test] + fn admission_cannot_be_replayed_on_another_connection() { + let authority = authority(); + let gate = ConnectionAdmissionGate::new(); + let (evidence, admission) = signed_pair(&authority); + gate.consume_for_connection(&authority, &admission, &evidence, expected(), "conn-tenant-a", 1_900_000_002).unwrap(); + assert_eq!(gate.consume_for_connection(&authority, &admission, &evidence, expected(), "conn-tenant-b", 1_900_000_003).unwrap_err().code, "admission_replay_detected"); + } + + #[test] + fn expired_entries_are_pruned() { + let authority = authority(); + let gate = ConnectionAdmissionGate::new(); + let (evidence, admission) = signed_pair(&authority); + gate.consume_for_connection(&authority, &admission, &evidence, expected(), "conn-1", 1_900_000_002).unwrap(); + assert_eq!(gate.active_consumptions(1_900_000_031).unwrap(), 0); + } + + #[test] + fn replay_registry_capacity_fails_closed_without_eviction() { + let authority = authority(); + let gate = ConnectionAdmissionGate::new(); + let (evidence, admission) = signed_pair(&authority); + { + let mut consumed = gate.consumed.lock().unwrap(); + for index in 0..100_000 { + consumed.insert(format!("signature-{index}"), (format!("connection-{index}"), 1_900_000_100)); + } + } + assert_eq!( + gate.consume_for_connection(&authority, &admission, &evidence, expected(), "conn-new", 1_900_000_002).unwrap_err().code, + "admission_capacity_exceeded" + ); + assert_eq!(gate.active_consumptions(1_900_000_002).unwrap(), 100_000); + } + + #[test] + fn invalid_connection_identifier_fails_closed() { + let authority = authority(); + let gate = ConnectionAdmissionGate::new(); + let (evidence, admission) = signed_pair(&authority); + assert_eq!(gate.consume_for_connection(&authority, &admission, &evidence, expected(), "", 1_900_000_002).unwrap_err().code, "invalid_connection_id"); + } +} diff --git a/crates/proxima-engine/src/database_adapter.rs b/crates/proxima-engine/src/database_adapter.rs new file mode 100644 index 00000000..708bbe17 --- /dev/null +++ b/crates/proxima-engine/src/database_adapter.rs @@ -0,0 +1,306 @@ +//! Database adapter contract for the database-independent Proxima Security Core. +//! +//! A database driver is not an adapter by itself. An implementation must inspect +//! native authorization state, compile the canonical policy, verify effective +//! enforcement, and detect drift. No planned adapter is registered as supported. + +use crate::security_core::{ + AdapterDescriptor, DatabaseKind, InspectionCompleteness, Operation, ProtectedResource, + SecurityFinding, SecurityPosture, TenantSecurityPolicy, VerificationReport, +}; +use serde::{Deserialize, Serialize}; +use serde_json::Value; +use std::{ + collections::HashMap, + future::Future, + pin::Pin, + sync::Arc, +}; + +pub type AdapterFuture<'a, T> = Pin + Send + 'a>>; + +#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +pub struct AdapterTarget { + /// Stable, non-secret identifier for the configured database target. + pub target_id: String, + pub database_name: String, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub namespace: Option, +} + +#[derive(Clone, Debug, Eq, PartialEq)] +pub struct InspectionRequest { + pub target: AdapterTarget, + pub policy: TenantSecurityPolicy, +} + +/// A discovered native resource. Attributes contain database-specific catalog +/// facts; credentials and connection strings must never be included. +#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +pub struct DiscoveredResource { + pub namespace: Option, + pub name: String, + pub kind: crate::security_core::ResourceKind, + pub owner: Option, + pub attributes: Value, +} + +#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +pub struct DiscoveryRequest { + pub target: AdapterTarget, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub namespace: Option, +} + +#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +pub struct DiscoverySnapshot { + pub database_kind: DatabaseKind, + pub target: AdapterTarget, + pub completeness: InspectionCompleteness, + /// Database-level facts such as server version and effective account grants. + pub target_attributes: Value, + pub resources: Vec, + pub findings: Vec, + pub fingerprint: Option, + pub observed_at: String, +} + +#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +pub struct ResourceInspection { + pub resource: ProtectedResource, + pub completeness: InspectionCompleteness, + pub posture: SecurityPosture, + /// Operations whose native enforcement was actually inspected and verified. + pub verified_operations: Vec, + pub findings: Vec, + pub fingerprint: Option, +} + +#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +pub struct InspectionSnapshot { + pub database_kind: DatabaseKind, + pub target: AdapterTarget, + pub completeness: InspectionCompleteness, + pub posture: SecurityPosture, + pub resources: Vec, + pub findings: Vec, + pub fingerprint: Option, + /// RFC 3339 timestamp generated by the adapter after inspection completes. + pub observed_at: String, +} + +#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +pub struct NativePolicyChange { + pub resource: ProtectedResource, + /// Adapter-defined operation such as create_policy or update_role_binding. + pub action: String, + /// Native, reviewable definition. It is never executed by policy compilation. + pub definition: Value, +} + +#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +pub struct CompiledPolicy { + pub database_kind: DatabaseKind, + pub policy_id: String, + pub revision: u64, + pub changes: Vec, + /// Applying native changes requires a separately authorized approval step. + pub requires_approval: bool, +} + +#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +pub struct DriftReport { + pub database_kind: DatabaseKind, + pub target: AdapterTarget, + pub detected: bool, + pub completeness: InspectionCompleteness, + pub previous_fingerprint: Option, + pub observed_fingerprint: Option, + pub findings: Vec, + pub observed_at: String, +} + +#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +pub struct AdapterError { + pub code: String, + pub detail: String, + pub retryable: bool, +} + +impl std::fmt::Display for AdapterError { + fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "{}: {}", self.code, self.detail) + } +} + +impl std::error::Error for AdapterError {} + +/// Native database adapter boundary. Implementations must fail closed when +/// inspection is incomplete and must never claim verification from a connection +/// test, catalog listing, or generated policy alone. +pub trait DatabaseAdapter: Send + Sync { + fn descriptor(&self) -> AdapterDescriptor; + + fn inspect<'a>( + &'a self, + request: &'a InspectionRequest, + ) -> AdapterFuture<'a, Result>; + + /// Enumerate native resources without assuming that a policy already names + /// them. Adapters that cannot provide complete discovery must return an + /// explicit error rather than silently returning a partial inventory. + fn discover<'a>( + &'a self, + _request: &'a DiscoveryRequest, + ) -> AdapterFuture<'a, Result> { + Box::pin(async { + Err(AdapterError { + code: "discovery_not_supported".into(), + detail: "This database adapter does not implement native resource discovery.".into(), + retryable: false, + }) + }) + } + + fn compile_policy( + &self, + policy: &TenantSecurityPolicy, + ) -> Result; + + fn verify<'a>( + &'a self, + policy: &'a TenantSecurityPolicy, + snapshot: &'a InspectionSnapshot, + ) -> AdapterFuture<'a, Result>; + + fn detect_drift<'a>( + &'a self, + target: &'a AdapterTarget, + previous_fingerprint: Option<&'a str>, + ) -> AdapterFuture<'a, Result>; +} + +#[derive(Default)] +pub struct AdapterRegistry { + adapters: HashMap>, +} + +#[derive(Clone, Copy, Debug, Eq, PartialEq)] +pub enum RegistryError { + DuplicateAdapter, + IncompleteAdapter, +} + +impl AdapterRegistry { + pub fn register(&mut self, adapter: Arc) -> Result<(), RegistryError> { + let descriptor = adapter.descriptor(); + if descriptor.maturity != crate::security_core::AdapterMaturity::Supported + || !descriptor.capabilities.is_production_complete() + { + return Err(RegistryError::IncompleteAdapter); + } + let kind = descriptor.kind; + if self.adapters.contains_key(&kind) { + return Err(RegistryError::DuplicateAdapter); + } + self.adapters.insert(kind, adapter); + Ok(()) + } + + pub fn get(&self, kind: DatabaseKind) -> Option> { + self.adapters.get(&kind).cloned() + } + + pub fn registered_kinds(&self) -> Vec { + let mut kinds: Vec<_> = self.adapters.keys().copied().collect(); + kinds.sort_by_key(|kind| format!("{kind:?}")); + kinds + } + + pub fn descriptors(&self) -> Vec { + let mut descriptors: Vec<_> = self.adapters.values().map(|adapter| adapter.descriptor()).collect(); + descriptors.sort_by_key(|descriptor| format!("{:?}", descriptor.kind)); + descriptors + } +} + + +#[cfg(test)] +mod registry_tests { + use super::*; + use crate::security_core::{AdapterCapabilities, AdapterMaturity}; + + struct CandidateAdapter { + maturity: AdapterMaturity, + capabilities: AdapterCapabilities, + } + + impl DatabaseAdapter for CandidateAdapter { + fn descriptor(&self) -> AdapterDescriptor { + AdapterDescriptor { + kind: DatabaseKind::MySql, + name: "candidate", + maturity: self.maturity, + capabilities: self.capabilities, + status_note: "test adapter", + } + } + + fn inspect<'a>(&'a self, _request: &'a InspectionRequest) -> AdapterFuture<'a, Result> { + Box::pin(async { Err(AdapterError { code: "not_implemented".into(), detail: "test adapter".into(), retryable: false }) }) + } + + fn compile_policy(&self, _policy: &TenantSecurityPolicy) -> Result { + Err(AdapterError { code: "not_implemented".into(), detail: "test adapter".into(), retryable: false }) + } + + fn verify<'a>(&'a self, _policy: &'a TenantSecurityPolicy, _snapshot: &'a InspectionSnapshot) -> AdapterFuture<'a, Result> { + Box::pin(async { Err(AdapterError { code: "not_implemented".into(), detail: "test adapter".into(), retryable: false }) }) + } + + fn detect_drift<'a>(&'a self, _target: &'a AdapterTarget, _previous_fingerprint: Option<&'a str>) -> AdapterFuture<'a, Result> { + Box::pin(async { Err(AdapterError { code: "not_implemented".into(), detail: "test adapter".into(), retryable: false }) }) + } + } + + #[test] + fn registry_rejects_review_only_and_partial_adapters() { + let adapter = CandidateAdapter { + maturity: AdapterMaturity::InDevelopment, + capabilities: AdapterCapabilities { policy_generation: true, ..AdapterCapabilities::default() }, + }; + let mut registry = AdapterRegistry::default(); + assert_eq!(registry.register(Arc::new(adapter)).unwrap_err(), RegistryError::IncompleteAdapter); + assert!(registry.get(DatabaseKind::MySql).is_none()); + } + + #[test] + fn registry_accepts_only_a_complete_supported_adapter() { + let adapter = CandidateAdapter { + maturity: AdapterMaturity::Supported, + capabilities: AdapterCapabilities { + schema_inspection: true, + tenant_identity_enforcement: true, + policy_semantic_verification: true, + policy_generation: true, + controlled_policy_deployment: true, + drift_detection: true, + runtime_fail_closed_admission: true, + signed_security_evidence: true, + }, + }; + let mut registry = AdapterRegistry::default(); + assert!(registry.register(Arc::new(adapter)).is_ok()); + assert!(registry.get(DatabaseKind::MySql).is_some()); + } +} diff --git a/crates/proxima-engine/src/elasticsearch_adapter.rs b/crates/proxima-engine/src/elasticsearch_adapter.rs new file mode 100644 index 00000000..917decc5 --- /dev/null +++ b/crates/proxima-engine/src/elasticsearch_adapter.rs @@ -0,0 +1,542 @@ +//! Elasticsearch / OpenSearch native index and security-role discovery. +//! +//! This adapter inspects index mappings/settings and security role/user +//! assignments over verified HTTPS. It does not deploy DLS/FLS policies or +//! claim tenant enforcement; document isolation requires trusted principal +//! binding and independent cross-tenant probes. +use crate::database_adapter::{ + AdapterError, AdapterFuture, AdapterTarget, CompiledPolicy, DatabaseAdapter, + DiscoveryRequest, DiscoverySnapshot, DiscoveredResource, DriftReport, + InspectionRequest, InspectionSnapshot, ResourceInspection, +}; +use crate::security_core::{ + AdapterCapabilities, AdapterDescriptor, AdapterMaturity, DatabaseKind, + InspectionCompleteness, ResourceKind, ResourceRef, SecurityFinding, + SecurityPosture, TenantSecurityPolicy, VerificationReport, SECURITY_MODEL_VERSION, +}; +use reqwest::{header::{HeaderMap, HeaderValue, AUTHORIZATION}, redirect::Policy, Client, Url}; +use serde_json::{json, Value}; +use sha2::{Digest, Sha256}; +use std::{str::FromStr, time::Duration}; + +pub struct ElasticsearchCatalogAdapter { + target_id: String, + index_pattern: String, + endpoint: Url, + client: Client, +} + +impl ElasticsearchCatalogAdapter { + pub fn new( + target_id: impl Into, + index_pattern: impl Into, + endpoint: impl AsRef, + authorization: impl AsRef, + ) -> Result { + let target_id = target_id.into(); + let index_pattern = index_pattern.into(); + if target_id.trim().is_empty() || target_id.len() > 256 || target_id.contains('\0') + || index_pattern.trim().is_empty() || index_pattern.len() > 255 + || index_pattern.contains('\0') || index_pattern.contains('/') || index_pattern.contains('\\') + || !index_pattern.bytes().all(|byte| byte.is_ascii_lowercase() || byte.is_ascii_digit() || matches!(byte, b'-' | b'_' | b'.' | b'*')) + { + return Err(error("invalid_elasticsearch_target", "A bounded target ID and index pattern are required.")); + } + let endpoint = Url::parse(endpoint.as_ref()) + .map_err(|_| error("invalid_elasticsearch_endpoint", "The Elasticsearch endpoint URL could not be parsed."))?; + if endpoint.scheme() != "https" || endpoint.host_str().is_none() + || !endpoint.username().is_empty() || endpoint.password().is_some() + || endpoint.query().is_some() || endpoint.fragment().is_some() || endpoint.path() != "/" + { + return Err(error("elasticsearch_tls_required", "Elasticsearch/OpenSearch requires an HTTPS endpoint with no embedded credentials, query parameters or fragment.")); + } + let auth = authorization.as_ref().trim(); + if !(auth.starts_with("ApiKey ") || auth.starts_with("Bearer ") || auth.starts_with("Basic ")) || auth.len() > 8192 { + return Err(error("invalid_elasticsearch_auth_header", "Supply an Authorization header using ApiKey, Bearer or Basic authentication.")); + } + let auth_value = HeaderValue::from_str(auth) + .map_err(|_| error("invalid_elasticsearch_auth_header", "The Authorization header contains invalid HTTP header bytes."))?; + let mut headers = HeaderMap::new(); + headers.insert(AUTHORIZATION, auth_value); + let client = Client::builder() + .default_headers(headers) + .connect_timeout(Duration::from_secs(10)) + .timeout(Duration::from_secs(15)) + .redirect(Policy::none()) + .user_agent("Agata-Proxima-Security-Discovery/1") + .build() + .map_err(|_| error("elasticsearch_http_client_failed", "The HTTPS discovery client could not be initialized."))?; + Ok(Self { target_id, index_pattern, endpoint, client }) + } + + fn validate_target(&self, target: &AdapterTarget) -> Result<(), AdapterError> { + if target.target_id != self.target_id || target.database_name != self.index_pattern { + return Err(error("elasticsearch_target_mismatch", "The request does not match this registered endpoint and index-pattern target.")); + } + Ok(()) + } + + fn url_for(&self, segments: &[&str]) -> Result { + let mut url = self.endpoint.clone(); + { + let mut path = url.path_segments_mut() + .map_err(|_| error("invalid_elasticsearch_endpoint", "The endpoint cannot accept API path segments."))?; + path.clear(); + for segment in segments { path.push(segment); } + } + Ok(url) + } + + async fn get_json(&self, url: Url) -> Result { + let response = self.client.get(url).send().await.map_err(http_error)?; + if !response.status().is_success() { + return Err(AdapterError { + code: "elasticsearch_api_rejected".into(), + detail: format!("Elasticsearch/OpenSearch API returned HTTP {}.", response.status().as_u16()), + retryable: response.status().is_server_error() || response.status().as_u16() == 429, + }); + } + response.json::().await.map_err(|_| error("elasticsearch_invalid_json", "The Elasticsearch/OpenSearch API returned invalid JSON.")) + } + + async fn get_optional_json(&self, url: Url) -> Result, AdapterError> { + let response = self.client.get(url).send().await.map_err(http_error)?; + if matches!(response.status().as_u16(), 401 | 403 | 404) { return Ok(None); } + if !response.status().is_success() { + return Err(AdapterError { + code: "elasticsearch_security_api_rejected".into(), + detail: format!("Elasticsearch/OpenSearch security API returned HTTP {}.", response.status().as_u16()), + retryable: response.status().is_server_error() || response.status().as_u16() == 429, + }); + } + response.json::().await.map(Some) + .map_err(|_| error("elasticsearch_invalid_json", "The security API returned invalid JSON.")) + } + + async fn discover_inner(&self, request: &DiscoveryRequest) -> Result { + self.validate_target(&request.target)?; + if request.namespace.is_some() { + return Err(error("elasticsearch_namespace_unsupported", "Use the registered index pattern as the target namespace.")); + } + let root = self.get_json(self.url_for(&[])?).await?; + let version = root.pointer("/version/number").and_then(Value::as_str).unwrap_or("unknown").to_owned(); + let tagline = root.get("tagline").and_then(Value::as_str).unwrap_or_default(); + let distribution = root.pointer("/version/distribution").and_then(Value::as_str).unwrap_or_default(); + let is_opensearch = distribution.eq_ignore_ascii_case("opensearch") || tagline.to_ascii_lowercase().contains("opensearch"); + let kind = if is_opensearch { + DatabaseKind::Elasticsearch + } else if root.get("version").is_some() { + DatabaseKind::Elasticsearch + } else { + return Err(error("elasticsearch_server_identity_unavailable", "The endpoint did not return a recognized Elasticsearch/OpenSearch root response.")); + }; + let cat_url = self.url_for(&["_cat", "indices"])?; + let mut cat_url = cat_url; + cat_url.query_pairs_mut().append_pair("format", "json").append_pair("h", "index,health,status,docs.count,store.size"); + let cat = self.get_json(cat_url).await?; + let index_rows = cat.as_array().ok_or_else(|| error("elasticsearch_index_inventory_invalid", "The index inventory response was not a JSON array."))?; + let truncated = index_rows.len() > 10_000; + let mut resources = Vec::new(); + let mut findings = Vec::new(); + let mut state = Vec::new(); + for row in index_rows.iter().take(10_000) { + let Some(index) = row.get("index").and_then(Value::as_str) else { continue }; + if !matches_index_pattern(&self.index_pattern, index) { continue; } + let mapping = self.get_json(self.url_for(&[index, "_mapping"])?).await?; + let settings = self.get_json(self.url_for(&[index, "_settings"])?).await?; + let aliases = self.get_optional_json(self.url_for(&[index, "_alias"])?).await?.unwrap_or_else(|| json!({})); + let mapping_value = mapping.get(index).cloned().unwrap_or_else(|| mapping.clone()); + let settings_value = settings.get(index).cloned().unwrap_or_else(|| settings.clone()); + let aliases_value = aliases.get(index).cloned().unwrap_or_else(|| aliases.clone()); + let attributes = json!({ + "health": row.get("health").cloned().unwrap_or(Value::Null), + "status": row.get("status").cloned().unwrap_or(Value::Null), + "document_count": row.get("docs.count").cloned().unwrap_or(Value::Null), + "store_size": row.get("store.size").cloned().unwrap_or(Value::Null), + "mapping": mapping_value, + "settings": settings_value, + "aliases": aliases_value + }); + resources.push(DiscoveredResource { + namespace: None, + name: index.to_owned(), + kind: ResourceKind::Collection, + owner: None, + attributes: attributes.clone(), + }); + // Fingerprints intentionally exclude volatile document counts, store size and health. + state.push(json!({ + "index": index, + "mapping": mapping_value, + "settings": settings_value, + "aliases": aliases_value + })); + } + if truncated { + findings.push(SecurityFinding { + code: "elasticsearch_index_inventory_truncated".into(), + resource: None, + detail: "The cluster index inventory exceeded 10,000 entries; discovery is incomplete.".into(), + }); + } + let (roles, role_mappings, users, authenticated_identity, security_api) = if is_opensearch { + let roles = self.get_optional_json(self.url_for(&["_plugins", "_security", "api", "roles"])?).await?; + let mappings = self.get_optional_json(self.url_for(&["_plugins", "_security", "api", "rolesmapping"])?).await?; + let users = self.get_optional_json(self.url_for(&["_plugins", "_security", "api", "internalusers"])?).await?; + let identity = self.get_optional_json(self.url_for(&["_plugins", "_security", "authinfo"])?).await?; + (roles, mappings, users, identity, "opensearch_security_plugin") + } else { + let roles = self.get_optional_json(self.url_for(&["_security", "role"])?).await?; + let users = self.get_optional_json(self.url_for(&["_security", "user"])?).await?; + let identity = self.get_optional_json(self.url_for(&["_security", "_authenticate"])?).await?; + (roles, None, users, identity, "elasticsearch_security") + }; + let security_visible = roles.is_some() && users.is_some() && authenticated_identity.is_some() + && (!is_opensearch || role_mappings.is_some()); + if !security_visible { + findings.push(SecurityFinding { + code: "elasticsearch_security_catalog_unavailable".into(), + resource: None, + detail: "The authenticated principal could not read the native security role/user catalog. Index discovery alone cannot establish effective document-level privileges.".into(), + }); + } + let target_attributes = json!({ + "server_version": version, + "distribution": if security_api == "opensearch_security_plugin" { "opensearch" } else { "elasticsearch" }, + "security_api": security_api, + "index_pattern": self.index_pattern, + "endpoint_host": self.endpoint.host_str(), + "endpoint_port": self.endpoint.port_or_known_default(), + "roles": roles.clone().unwrap_or(Value::Null), + "role_mappings": role_mappings.clone().unwrap_or(Value::Null), + "users": sanitize_user_catalog(users.clone().unwrap_or(Value::Null)), + "authenticated_identity": sanitize_user_catalog(authenticated_identity.clone().unwrap_or(Value::Null)), + "security_catalog_visible": security_visible + }); + let fingerprint = digest(&serde_json::to_vec(&json!({ "target": target_attributes, "indices": state })) + .map_err(|_| error("elasticsearch_fingerprint_failed", "Could not serialize Elasticsearch/OpenSearch catalog state."))?); + if resources.is_empty() { + findings.push(SecurityFinding { + code: "elasticsearch_no_matching_indices".into(), + resource: None, + detail: "No visible index matched the registered index pattern. Check the pattern and the inspection principal's index privileges.".into(), + }); + } + findings.push(SecurityFinding { + code: "elasticsearch_catalog_visibility_not_proven".into(), + resource: None, + detail: "The adapter cannot independently prove that the authenticated principal can enumerate every cluster index, role, role mapping and user. The visible inventory is not a complete security baseline.".into(), + }); + Ok(DiscoverySnapshot { + database_kind: kind, + target: request.target.clone(), + completeness: InspectionCompleteness::Incomplete, + target_attributes, + resources, + findings, + fingerprint: Some(fingerprint), + observed_at: chrono::Utc::now().to_rfc3339(), + }) + } + + async fn discover_bounded(&self, request: &DiscoveryRequest) -> Result { + tokio::time::timeout(Duration::from_secs(90), self.discover_inner(request)) + .await + .map_err(|_| AdapterError { + code: "elasticsearch_catalog_timeout".into(), + detail: "Elasticsearch/OpenSearch catalog discovery exceeded the ninety-second operation deadline.".into(), + retryable: true, + })? + } +} + +impl DatabaseAdapter for ElasticsearchCatalogAdapter { + fn descriptor(&self) -> AdapterDescriptor { + AdapterDescriptor { + kind: DatabaseKind::Elasticsearch, + name: "Elasticsearch / OpenSearch catalog adapter", + maturity: AdapterMaturity::InDevelopment, + capabilities: AdapterCapabilities { schema_inspection: true, drift_detection: true, ..AdapterCapabilities::default() }, + status_note: "Verified-HTTPS discovery inventories matching indices, mappings, settings, aliases and native security roles/users where visible. DLS/FLS enforcement, trusted tenant-principal binding, policy deployment, independent document probes and runtime admission are not implemented.", + } + } + + fn discover<'a>(&'a self, request: &'a DiscoveryRequest) -> AdapterFuture<'a, Result> { + Box::pin(async move { self.discover_bounded(request).await }) + } + + fn inspect<'a>(&'a self, request: &'a InspectionRequest) -> AdapterFuture<'a, Result> { + Box::pin(async move { + request.policy.validate().map_err(|_| error("invalid_policy", "The canonical tenant policy failed validation."))?; + let discovery = self.discover_bounded(&DiscoveryRequest { target: request.target.clone(), namespace: None }).await?; + let mut findings = discovery.findings.clone(); + let mut inspected = Vec::new(); + for required in &request.policy.resources { + let resource = discovery.resources.iter().find(|resource| resource.name == required.resource.name + && resource.kind == required.resource.kind && required.resource.namespace.is_none()); + let Some(resource) = resource else { + findings.push(finding("elasticsearch_required_index_missing", &required.resource, "The protected index was not present in the visible index inventory.")); + continue; + }; + let mapping = resource.attributes.get("mapping").cloned().unwrap_or(Value::Null); + let field_type = mapping_field_type(&mapping, &required.tenant_key); + let mut resource_findings = Vec::new(); + if field_type.is_none() { + resource_findings.push(finding("elasticsearch_tenant_field_missing", &required.resource, "The declared tenant ownership field is absent from the index mapping.")); + } + if !discovery.target_attributes.get("security_catalog_visible").and_then(Value::as_bool).unwrap_or(false) { + resource_findings.push(finding("elasticsearch_security_roles_unavailable", &required.resource, "Native DLS/FLS role state could not be inspected.")); + } else { + let empty_roles = Value::Null; + let roles = discovery.target_attributes.get("roles").unwrap_or(&empty_roles); + let identity = discovery.target_attributes.get("authenticated_identity").unwrap_or(&empty_roles); + let effective_roles = identity.get("roles").and_then(Value::as_array) + .map(|values| values.iter().filter_map(Value::as_str).map(str::to_owned).collect::>()) + .unwrap_or_default(); + let (matching_roles, tenant_dls_roles, broad_roles) = dls_role_coverage(roles, &effective_roles, &required.resource.name, &required.tenant_key); + if matching_roles == 0 { + resource_findings.push(finding("elasticsearch_no_index_role_observed", &required.resource, "No native security role with an index pattern matching this index was observed.")); + } else if tenant_dls_roles == 0 { + resource_findings.push(finding("elasticsearch_dls_not_observed", &required.resource, "No matching index role was observed with a document-level query that references the declared tenant field.")); + } + if broad_roles > 0 { + resource_findings.push(finding("elasticsearch_broad_index_role_observed", &required.resource, "One or more matching native roles grant index access without a tenant-scoped DLS query.")); + } + } + if field_type.is_some() { + resource_findings.push(finding("elasticsearch_dls_probe_required", &required.resource, "A mapped tenant field and matching DLS query are not proof of enforcement; verify effective role assignment and independent positive/negative document probes.")); + } + findings.extend(resource_findings.iter().cloned()); + inspected.push(ResourceInspection { + resource: required.clone(), + completeness: discovery.completeness, + posture: SecurityPosture::NeedsAttention, + verified_operations: Vec::new(), + findings: resource_findings, + fingerprint: discovery.fingerprint.clone(), + }); + } + findings.push(SecurityFinding { + code: "elasticsearch_runtime_tenant_binding_unavailable".into(), + resource: None, + detail: "No trusted gateway currently binds authenticated tenant identity to a dedicated Elasticsearch/OpenSearch principal with verified DLS/FLS restrictions.".into(), + }); + Ok(InspectionSnapshot { + database_kind: discovery.database_kind, + target: discovery.target, + completeness: discovery.completeness, + posture: SecurityPosture::NeedsAttention, + resources: inspected, + findings, + fingerprint: discovery.fingerprint, + observed_at: discovery.observed_at, + }) + }) + } + + fn compile_policy(&self, _policy: &TenantSecurityPolicy) -> Result { + Err(error("elasticsearch_policy_compilation_unavailable", "DLS/FLS policy compilation and controlled role deployment are not implemented; the adapter will not generate unverified role definitions.")) + } + + fn verify<'a>(&'a self, _policy: &'a TenantSecurityPolicy, snapshot: &'a InspectionSnapshot) -> AdapterFuture<'a, Result> { + Box::pin(async move { + if snapshot.database_kind != DatabaseKind::Elasticsearch { + return Err(error("elasticsearch_snapshot_target_mismatch", "The inspection snapshot belongs to a different database kind.")); + } + self.validate_target(&snapshot.target)?; + let mut findings = snapshot.findings.clone(); + findings.push(SecurityFinding { + code: "elasticsearch_semantic_verification_unavailable".into(), + resource: None, + detail: "Document isolation has not been proven with distinct authenticated tenant principals and independent cross-tenant document probes.".into(), + }); + Ok(VerificationReport { + model_version: SECURITY_MODEL_VERSION.into(), + posture: SecurityPosture::Blocked, + inspection: snapshot.completeness, + findings, + }) + }) + } + + fn detect_drift<'a>(&'a self, target: &'a AdapterTarget, previous_fingerprint: Option<&'a str>) -> AdapterFuture<'a, Result> { + Box::pin(async move { + self.validate_target(target)?; + if previous_fingerprint.is_some_and(|value| value.len() != 64 || hex::decode(value).map_or(true, |bytes| bytes.len() != 32)) { + return Err(error("invalid_previous_fingerprint", "The previous fingerprint must be a 32-byte hexadecimal SHA-256 digest.")); + } + let snapshot = self.discover_bounded(&DiscoveryRequest { target: target.clone(), namespace: None }).await?; + let detected = previous_fingerprint.is_some_and(|previous| Some(previous) != snapshot.fingerprint.as_deref()); + Ok(DriftReport { + database_kind: DatabaseKind::Elasticsearch, + target: target.clone(), + detected, + completeness: snapshot.completeness, + previous_fingerprint: previous_fingerprint.map(str::to_owned), + observed_fingerprint: snapshot.fingerprint, + findings: if detected { vec![SecurityFinding { + code: "elasticsearch_catalog_fingerprint_changed".into(), + resource: None, + detail: "Index mappings, settings, aliases or security-role assignments differ from the previously accepted fingerprint.".into(), + }] } else { snapshot.findings }, + observed_at: snapshot.observed_at, + }) + }) + } +} + +fn dls_role_coverage(roles: &Value, effective_roles: &[String], index: &str, tenant_field: &str) -> (usize, usize, usize) { + let mut matching_roles = 0usize; + let mut tenant_dls_roles = 0usize; + let mut broad_roles = 0usize; + let Some(role_map) = roles.as_object() else { return (0, 0, 0) }; + for role_name in effective_roles { + let Some(role) = role_map.get(role_name) else { continue }; + let permissions = role.get("indices").and_then(Value::as_array) + .or_else(|| role.get("index_permissions").and_then(Value::as_array)); + let Some(permissions) = permissions else { continue }; + for permission in permissions { + let patterns = permission.get("names").and_then(Value::as_array) + .or_else(|| permission.get("index_patterns").and_then(Value::as_array)); + let matches = patterns.is_some_and(|patterns| patterns.iter().filter_map(Value::as_str) + .any(|pattern| matches_index_pattern(pattern, index))); + if !matches { continue; } + matching_roles += 1; + let query = permission.get("query").or_else(|| permission.get("dls")); + let query_text = query.filter(|value| !value.is_null()).map(Value::to_string).unwrap_or_default(); + if query_text.is_empty() { + broad_roles += 1; + } else if query_text.contains(tenant_field) { + tenant_dls_roles += 1; + } else { + broad_roles += 1; + } + } + } + (matching_roles, tenant_dls_roles, broad_roles) +} + +fn mapping_field_type(mapping: &Value, field: &str) -> Option { + let mut current = mapping.get("mappings").unwrap_or(mapping); + for part in field.split('.') { + current = current.get("properties")?.get(part)?; + } + current.get("type").and_then(Value::as_str).map(str::to_owned) +} + +fn matches_index_pattern(pattern: &str, value: &str) -> bool { + let parts = pattern.split('*').collect::>(); + if parts.len() == 1 { return pattern == value; } + if !value.starts_with(parts[0]) || !value.ends_with(parts[parts.len()-1]) { return false; } + let mut offset = parts[0].len(); + for part in parts.iter().skip(1).take(parts.len().saturating_sub(2)) { + let Some(found) = value[offset..].find(part) else { return false }; + offset += found + part.len(); + } + offset <= value.len() - parts[parts.len()-1].len() +} + +fn sanitize_user_catalog(mut value: Value) -> Value { + fn strip_secrets(value: &mut Value) { + match value { + Value::Object(map) => { + for key in ["password", "password_hash", "hash", "salt", "api_key", "token"] { + map.remove(key); + } + for child in map.values_mut() { strip_secrets(child); } + } + Value::Array(items) => for child in items { strip_secrets(child); }, + _ => {} + } + } + strip_secrets(&mut value); + value +} + +fn digest(bytes: &[u8]) -> String { hex::encode(Sha256::digest(bytes)) } +fn error(code: &str, detail: &str) -> AdapterError { AdapterError { code: code.into(), detail: detail.into(), retryable: false } } +fn http_error(error: reqwest::Error) -> AdapterError { + AdapterError { code: "elasticsearch_http_request_failed".into(), detail: "The verified HTTPS request to the search cluster failed.".into(), retryable: error.is_timeout() || error.is_connect() } +} +fn finding(code: &str, resource: &ResourceRef, detail: &str) -> SecurityFinding { + SecurityFinding { code: code.into(), resource: Some(resource.clone()), detail: detail.into() } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn descriptor_claims_discovery_only() { + let adapter = ElasticsearchCatalogAdapter::new( + "target", + "tenant-*", + "https://search.example.com:9200", + "ApiKey abc", + ).unwrap(); + let descriptor = adapter.descriptor(); + assert_eq!(descriptor.maturity, AdapterMaturity::InDevelopment); + assert!(descriptor.capabilities.schema_inspection); + assert!(descriptor.capabilities.drift_detection); + assert!(!descriptor.capabilities.tenant_identity_enforcement); + assert!(!descriptor.capabilities.policy_semantic_verification); + assert!(!descriptor.capabilities.policy_generation); + assert!(!descriptor.capabilities.controlled_policy_deployment); + assert!(!descriptor.capabilities.runtime_fail_closed_admission); + assert!(!descriptor.capabilities.signed_security_evidence); + } + + #[test] + fn requires_https_and_non_embedded_credentials() { + assert!(ElasticsearchCatalogAdapter::new("target", "tenant-*", "http://localhost:9200", "ApiKey x").is_err()); + assert!(ElasticsearchCatalogAdapter::new("target", "tenant-*", "https://user:pass@example.com", "ApiKey x").is_err()); + assert!(ElasticsearchCatalogAdapter::new("target", "tenant-*", "https://search.example.com:9200", "ApiKey x").is_ok()); + } + + #[test] + fn matches_globbed_index_names_without_regex_interpretation() { + assert!(matches_index_pattern("tenant-*", "tenant-a")); + assert!(matches_index_pattern("tenant-*-events", "tenant-a-events")); + assert!(!matches_index_pattern("tenant-*", "other-a")); + assert!(!matches_index_pattern("tenant-a", "tenant-ab")); + } + + #[test] + fn resolves_nested_mapping_field_types() { + let mapping = json!({ "mappings": { "properties": { "tenant": { "properties": { "id": { "type": "keyword" } } } } } }); + assert_eq!(mapping_field_type(&mapping, "tenant.id"), Some("keyword".into())); + assert_eq!(mapping_field_type(&mapping, "missing"), None); + } + + #[test] + fn distinguishes_tenant_scoped_and_broad_dls_roles() { + let roles = json!({ + "tenant_reader": { + "indices": [{ + "names": ["tenant-*"], + "privileges": ["read"], + "query": { "term": { "tenant_id": "{{_user.metadata.tenant_id}}" } } + }] + }, + "legacy_reader": { + "index_permissions": [{ + "index_patterns": ["tenant-*"], + "allowed_actions": ["read"], + "dls": "" + }] + } + }); + assert_eq!(dls_role_coverage(&roles, &["tenant_reader".into(), "legacy_reader".into()], "tenant-acme", "tenant_id"), (2, 1, 1)); + assert_eq!(dls_role_coverage(&roles, &["tenant_reader".into()], "tenant-acme", "tenant_id"), (1, 1, 0)); + assert_eq!(dls_role_coverage(&roles, &["tenant_reader".into()], "other-acme", "tenant_id"), (0, 0, 0)); + } + + #[test] + fn strips_credentials_from_user_catalog() { + let users = json!({ "alice": { "password": "secret", "roles": ["reader"], "metadata": { "token": "secret" } } }); + let sanitized = sanitize_user_catalog(users); + assert!(sanitized.pointer("/alice/password").is_none()); + assert!(sanitized.pointer("/alice/metadata/token").is_none()); + assert_eq!(sanitized.pointer("/alice/roles/0").and_then(Value::as_str), Some("reader")); + } +} diff --git a/crates/proxima-engine/src/lib.rs b/crates/proxima-engine/src/lib.rs index 2560f594..4c372b10 100644 --- a/crates/proxima-engine/src/lib.rs +++ b/crates/proxima-engine/src/lib.rs @@ -8,4 +8,24 @@ pub mod protocol; pub mod security_breaker; pub mod session; pub mod tenant; +pub mod tenant_identity; pub mod tls; +pub mod sql_guard; +pub mod security_core; +pub mod database_adapter; +pub mod native_policy_plans; +pub mod policy_evidence; +pub mod connection_admission; +pub mod security_core_coordinator; +pub mod postgres_adapter; + +pub mod mysql_adapter; +pub mod mongodb_adapter; + +pub mod redis_adapter; + +pub mod sql_server_adapter; + +pub mod cockroach_adapter; +pub mod sqlite_adapter; +pub mod elasticsearch_adapter; diff --git a/crates/proxima-engine/src/main.rs b/crates/proxima-engine/src/main.rs index 89dd1e1d..0ced0069 100644 --- a/crates/proxima-engine/src/main.rs +++ b/crates/proxima-engine/src/main.rs @@ -5,6 +5,7 @@ use std::io; use std::sync::Arc; use hmac::Mac; +use serde::{Deserialize, Serialize}; use proxima_engine::{ attestation::{AttestationConfig, AttestationLedger, SecurityState, TelemetrySummary}, break_glass, @@ -12,6 +13,7 @@ use proxima_engine::{ dashboard, metrics::{self, QueryLatencyTracker}, protocol::SSL_REQUEST_CODE, + sql_guard, security_breaker::{BreakerConfig, SecurityBreaker}, session::{establish, BoxedPgStream}, tenant::TenantTokenVerifier, @@ -27,7 +29,7 @@ use tokio::io::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt}; use tokio::net::{TcpListener, TcpStream}; use tokio::sync::Semaphore; use tokio::time::timeout; -use tracing::{error, info}; +use tracing::{error, info, warn}; async fn deliver_pending_attestations( ledger: &AttestationLedger, @@ -176,6 +178,334 @@ fn sign_node_heartbeat( Ok(hex::encode(mac.finalize().into_bytes())) } + +#[derive(Serialize)] +struct NodePolicyStatusRequestCanonical<'a> { + domain: &'static str, + node_id: &'a str, + timestamp: i64, + request_id: &'a str, + target_id: &'a str, + database_name: &'a str, + tenant_id: &'a str, + tenant_role_prefix: &'a str, +} + +#[derive(Serialize, Deserialize)] +struct NodePolicyStatusPayload { + node_id: String, + request_timestamp: i64, + request_id: String, + target_id: String, + database_name: String, + tenant_id: String, + decision: String, + policy_revision: Option, + reason: String, + evidence: serde_json::Value, + issued_at: i64, + expires_at: i64, +} + +#[derive(Deserialize)] +struct SignedNodePolicyStatus { + payload: NodePolicyStatusPayload, + signature: String, +} + +fn policy_admission_evidence_is_consistent( + payload: &NodePolicyStatusPayload, + target_id: &str, + database_name: &str, + tenant_id: &str, +) -> bool { + let evidence = &payload.evidence; + if evidence.get("schema_version").and_then(serde_json::Value::as_str) + != Some("proxima.postgresql.policy-admission-evidence.v1") + || evidence.get("target_id").and_then(serde_json::Value::as_str) != Some(target_id) + || evidence.get("database_name").and_then(serde_json::Value::as_str) != Some(database_name) + || evidence.get("tenant_id").and_then(serde_json::Value::as_str) != Some(tenant_id) + || evidence.get("decision").and_then(serde_json::Value::as_str) != Some(payload.decision.as_str()) + || evidence.get("reason").and_then(serde_json::Value::as_str) != Some(payload.reason.as_str()) + || evidence.get("observed_at").and_then(serde_json::Value::as_i64).is_none() + { + return false; + } + let Some(observed_at) = evidence.get("observed_at").and_then(serde_json::Value::as_i64) else { + return false; + }; + if observed_at > payload.issued_at + 30 || observed_at < payload.issued_at - 90 { + return false; + } + let Some(checks) = evidence.get("checks").and_then(serde_json::Value::as_array) else { + return false; + }; + if payload.decision != "allow" { + return payload.decision == "deny"; + } + if checks.is_empty() || payload.policy_revision.is_none() { + return false; + } + let mut maximum_revision = None; + for check in checks { + let revision = check.get("revision_version") + .and_then(serde_json::Value::as_i64) + .and_then(|value| i32::try_from(value).ok()); + maximum_revision = match (maximum_revision, revision) { + (Some(current), Some(value)) => Some(current.max(value)), + (None, Some(value)) => Some(value), + _ => return false, + }; + let protected = check.get("protected").and_then(serde_json::Value::as_bool) == Some(true) + && check.get("registration_enabled").and_then(serde_json::Value::as_bool) == Some(true) + && check.get("connection_status").and_then(serde_json::Value::as_str) == Some("reachable") + && check.get("schema_drift_detected").and_then(serde_json::Value::as_bool) == Some(false) + && check.get("schema_fingerprint").and_then(serde_json::Value::as_str).is_some_and(|value| !value.is_empty()) + && check.get("fingerprint_fresh").and_then(serde_json::Value::as_bool) == Some(true) + && check.get("tenant_role_prefix_matches").and_then(serde_json::Value::as_bool) == Some(true) + && check.get("tenant_role_binding_valid").and_then(serde_json::Value::as_bool) == Some(true) + && check.get("revision_id").and_then(serde_json::Value::as_str).is_some() + && check.get("revision_status").and_then(serde_json::Value::as_str) == Some("applied") + && check.get("revision_verified_at").and_then(serde_json::Value::as_str).is_some() + && check.get("verification").and_then(|value| value.get("state")).and_then(serde_json::Value::as_str) == Some("protected") + && check.get("latest_drift_state").and_then(serde_json::Value::as_str) == Some("protected") + && check.get("latest_drift_finding_code").and_then(serde_json::Value::as_str) == Some("protected") + && check.get("latest_drift_observed_at").and_then(serde_json::Value::as_str).is_some() + && check.get("drift_event_fresh").and_then(serde_json::Value::as_bool) == Some(true); + if !protected { + return false; + } + } + payload.policy_revision == maximum_revision +} + +#[cfg(test)] +mod admission_expiry_tests { + use super::policy_admission_expiry_is_valid; + + #[test] + fn bounds_signed_admission_expiry_without_overflow() { + assert!(policy_admission_expiry_is_valid(100, 115)); + assert!(!policy_admission_expiry_is_valid(100, 116)); + assert!(!policy_admission_expiry_is_valid(100, 100)); + assert!(!policy_admission_expiry_is_valid(i64::MAX, i64::MAX)); + } +} + +#[cfg(test)] +mod admission_requirement_tests { + use super::parse_policy_admission_required; + + #[test] + fn admission_is_required_by_default_and_values_must_be_explicit() { + assert_eq!(parse_policy_admission_required(None).unwrap(), true); + assert_eq!(parse_policy_admission_required(Some(" yes ")).unwrap(), true); + if cfg!(debug_assertions) { + assert_eq!(parse_policy_admission_required(Some("0")).unwrap(), false); + assert_eq!(parse_policy_admission_required(Some("false")).unwrap(), false); + } else { + assert!(parse_policy_admission_required(Some("0")).is_err()); + assert!(parse_policy_admission_required(Some("false")).is_err()); + } + assert!(parse_policy_admission_required(Some("sometimes")).is_err()); + } +} + +/// Per-connection fail-closed check against the Control Plane's latest verified +/// PostgreSQL posture. Every response is bound to a fresh one-time request ID, +/// node, target, database and tenant; it includes signed per-registration +/// verification evidence and expires within 15 seconds. +#[derive(Clone)] +struct PolicyAdmissionClient { + client: reqwest::Client, + url: String, + node_id: String, + target_id: String, + tenant_role_prefix: String, + signing_key: Vec, +} + +fn policy_admission_expiry_is_valid(issued_at: i64, expires_at: i64) -> bool { + issued_at.checked_add(15).is_some_and(|latest_expiry| { + expires_at > issued_at && expires_at <= latest_expiry + }) +} + +fn parse_policy_admission_required(value: Option<&str>) -> io::Result { + match value.map(str::trim).map(str::to_ascii_lowercase).as_deref() { + // Tenant traffic requires a live, signed posture decision by default. + // Local development may explicitly opt out with false/0/no. + None | Some("1") | Some("true") | Some("yes") => Ok(true), + Some("0") | Some("false") | Some("no") if cfg!(debug_assertions) => Ok(false), + Some("0") | Some("false") | Some("no") => Err(io::Error::new( + io::ErrorKind::InvalidInput, + "Policy admission cannot be disabled in release builds", + )), + Some(_) => Err(io::Error::new( + io::ErrorKind::InvalidInput, + "PROXIMA_POLICY_ADMISSION_REQUIRED must be true/false, yes/no, or 1/0", + )), + } +} + +impl PolicyAdmissionClient { + fn from_env(tenant_role_prefix: &str) -> io::Result> { + let url = std::env::var("PROXIMA_NODE_POLICY_STATUS_URL").ok() + .filter(|value| !value.trim().is_empty()); + let required_env = std::env::var("PROXIMA_POLICY_ADMISSION_REQUIRED"); + let required = match required_env { + Ok(value) => parse_policy_admission_required(Some(&value))?, + Err(std::env::VarError::NotPresent) => parse_policy_admission_required(None)?, + Err(std::env::VarError::NotUnicode(_)) => { + return Err(io::Error::new( + io::ErrorKind::InvalidInput, + "PROXIMA_POLICY_ADMISSION_REQUIRED is not valid Unicode", + )); + } + }; + let Some(url) = url else { + if required { + return Err(io::Error::new(io::ErrorKind::InvalidInput, + "PROXIMA_POLICY_ADMISSION_REQUIRED is enabled but PROXIMA_NODE_POLICY_STATUS_URL is missing")); + } + return Ok(None); + }; + if !attestation_ingest_url_allowed(&url, true) { + return Err(io::Error::new(io::ErrorKind::InvalidInput, + "PROXIMA_NODE_POLICY_STATUS_URL must use HTTPS or an approved loopback/development endpoint")); + } + let node_id = std::env::var("PROXIMA_NODE_ID") + .map_err(|_| io::Error::new(io::ErrorKind::InvalidInput, "PROXIMA_NODE_ID is required for policy admission"))?; + let target_id = std::env::var("PROXIMA_DATABASE_TARGET_ID") + .map_err(|_| io::Error::new(io::ErrorKind::InvalidInput, "PROXIMA_DATABASE_TARGET_ID is required for policy admission"))?; + let signing_key = std::env::var("PROXIMA_NODE_SIGNING_KEY_HEX") + .map_err(|_| io::Error::new(io::ErrorKind::InvalidInput, "PROXIMA_NODE_SIGNING_KEY_HEX is required for policy admission"))?; + let signing_key = hex::decode(signing_key.trim()) + .map_err(|_| io::Error::new(io::ErrorKind::InvalidInput, "PROXIMA_NODE_SIGNING_KEY_HEX must be hexadecimal"))?; + if signing_key.len() != 32 { + return Err(io::Error::new(io::ErrorKind::InvalidInput, "Node policy admission signing key must be exactly 32 bytes")); + } + uuid::Uuid::parse_str(&node_id) + .map_err(|_| io::Error::new(io::ErrorKind::InvalidInput, "PROXIMA_NODE_ID must be a UUID"))?; + uuid::Uuid::parse_str(&target_id) + .map_err(|_| io::Error::new(io::ErrorKind::InvalidInput, "PROXIMA_DATABASE_TARGET_ID must be a UUID"))?; + let client = reqwest::Client::builder() + .redirect(reqwest::redirect::Policy::none()) + .timeout(std::time::Duration::from_secs(5)) + .build() + .map_err(|error| io::Error::new(io::ErrorKind::InvalidInput, error.to_string()))?; + Ok(Some(Self { + client, url, node_id, target_id, + tenant_role_prefix: tenant_role_prefix.to_owned(), + signing_key, + })) + } + + async fn authorize(&self, database_name: &str, tenant_id: &str) -> io::Result<()> { + if database_name.is_empty() || database_name.len() > 63 + || tenant_id.is_empty() || tenant_id.len() > 128 + { + return Err(io::Error::new(io::ErrorKind::PermissionDenied, + "Invalid database or tenant identity for policy admission")); + } + let timestamp = std::time::SystemTime::now() + .duration_since(std::time::UNIX_EPOCH) + .map_err(|error| io::Error::new(io::ErrorKind::PermissionDenied, error.to_string()))? + .as_secs() as i64; + // A fresh unpredictable request ID makes every signed decision + // single-request scoped; an earlier allow response cannot be replayed + // for another PostgreSQL connection or a later recheck. + let request_id = uuid::Uuid::new_v4().to_string(); + let canonical = NodePolicyStatusRequestCanonical { + domain: "proxima-node-policy-status-request-v1", + node_id: &self.node_id, + timestamp, + request_id: &request_id, + target_id: &self.target_id, + database_name, + tenant_id, + tenant_role_prefix: &self.tenant_role_prefix, + }; + let bytes = serde_json::to_vec(&canonical) + .map_err(|error| io::Error::new(io::ErrorKind::PermissionDenied, error.to_string()))?; + let mut mac = hmac::Hmac::::new_from_slice(&self.signing_key) + .map_err(|_| io::Error::new(io::ErrorKind::PermissionDenied, "Invalid node signing key"))?; + mac.update(&bytes); + let signature = hex::encode(mac.finalize().into_bytes()); + + let response = self.client.post(&self.url) + .json(&serde_json::json!({ + "node_id": self.node_id, + "timestamp": timestamp, + "request_id": request_id, + "target_id": self.target_id, + "database_name": database_name, + "tenant_id": tenant_id, + "tenant_role_prefix": self.tenant_role_prefix, + "signature": signature + })) + .send().await + .map_err(|error| io::Error::new(io::ErrorKind::PermissionDenied, + format!("Policy admission service unavailable: {error}")))? + .error_for_status() + .map_err(|error| io::Error::new(io::ErrorKind::PermissionDenied, + format!("Policy admission request rejected: {error}")))?; + let signed: SignedNodePolicyStatus = response.json().await + .map_err(|error| io::Error::new(io::ErrorKind::PermissionDenied, + format!("Invalid signed policy admission response: {error}")))?; + let payload = &signed.payload; + if payload.node_id != self.node_id + || payload.request_timestamp != timestamp + || payload.request_id != request_id + || payload.target_id != self.target_id + || payload.database_name != database_name + || payload.tenant_id != tenant_id + || payload.issued_at > timestamp + 30 + || payload.issued_at < timestamp - 30 + || payload.expires_at <= timestamp + || !policy_admission_expiry_is_valid(payload.issued_at, payload.expires_at) + || payload.decision == "allow" && payload.policy_revision.is_none() + { + return Err(io::Error::new(io::ErrorKind::PermissionDenied, + "Policy admission response is stale or bound to a different node, target, database, or tenant")); + } + let signature = hex::decode(&signed.signature) + .map_err(|_| io::Error::new(io::ErrorKind::PermissionDenied, "Invalid policy admission signature encoding"))?; + let payload_bytes = serde_json::to_vec(payload) + .map_err(|error| io::Error::new(io::ErrorKind::PermissionDenied, error.to_string()))?; + let mut verifier = hmac::Hmac::::new_from_slice(&self.signing_key) + .map_err(|_| io::Error::new(io::ErrorKind::PermissionDenied, "Invalid node signing key"))?; + verifier.update(&payload_bytes); + verifier.verify_slice(&signature) + .map_err(|_| io::Error::new(io::ErrorKind::PermissionDenied, "Policy admission signature verification failed"))?; + if !policy_admission_evidence_is_consistent(payload, &self.target_id, database_name, tenant_id) { + return Err(io::Error::new(io::ErrorKind::PermissionDenied, + "Signed policy admission evidence is incomplete or bound to a different tenant posture")); + } + let allow = payload.decision == "allow"; + if !allow { + return Err(io::Error::new(io::ErrorKind::PermissionDenied, + format!("Tenant policy admission denied: {}", payload.reason))); + } + Ok(()) + } + + async fn authorize_with_metrics(&self, database_name: &str, tenant_id: &str) -> io::Result<()> { + let metrics = metrics::global(); + metrics.policy_admission_checked(); + match self.authorize(database_name, tenant_id).await { + Ok(()) => { + metrics.policy_admission_allowed(); + Ok(()) + } + Err(error) => { + metrics.policy_admission_denied(); + Err(error) + } + } + } +} + fn attestation_ingest_url_allowed(url: &str, allow_insecure_http: bool) -> bool { let Ok(parsed) = reqwest::Url::parse(url) else { return false; @@ -465,6 +795,12 @@ async fn main() -> io::Result<()> { .transpose() .map_err(|error| io::Error::new(io::ErrorKind::InvalidInput, error.to_string()))?; + let policy_admission = PolicyAdmissionClient::from_env(&config_tenant_role_prefix)?; + if policy_admission.is_some() && verifier.is_none() { + return Err(io::Error::new(io::ErrorKind::InvalidInput, + "Signed policy admission requires PROXIMA_TENANT_SIGNING_KEY and mandatory tenant-token verification")); + } + let client_acceptor = client_acceptor(&config)?; let upstream_connector = upstream_connector(&config)?; @@ -767,6 +1103,7 @@ async fn main() -> io::Result<()> { if let Some(probe_listener) = probe_listener { let probe_upstream = config.upstream_addr.clone(); let probe_verifier = verifier.clone(); + let probe_policy_admission = policy_admission.clone(); let probe_role_prefix = config_tenant_role_prefix.clone(); let probe_connect_timeout = config.upstream_connect_timeout; let probe_client_tls_timeout = config.tls_handshake_timeout; @@ -805,6 +1142,7 @@ async fn main() -> io::Result<()> { peer, &upstream, verifier.as_ref(), + probe_policy_admission.as_deref(), &role_prefix, probe_connect_timeout, None, @@ -881,6 +1219,7 @@ async fn main() -> io::Result<()> { let security_event_client = security_event_client.clone(); let upstream = config.upstream_addr.clone(); let verifier = verifier.clone(); + let policy_admission = policy_admission.clone(); let tenant_role_prefix = config_tenant_role_prefix.clone(); let upstream_connect_timeout = config.upstream_connect_timeout; let client_acceptor = client_acceptor.clone(); @@ -898,6 +1237,7 @@ async fn main() -> io::Result<()> { peer, &upstream, verifier.as_ref(), + policy_admission.as_deref(), &tenant_role_prefix, upstream_connect_timeout, client_acceptor.as_ref(), @@ -945,11 +1285,32 @@ async fn main() -> io::Result<()> { } #[allow(clippy::too_many_arguments)] +async fn write_startup_error( + client: &mut BoxedPgStream, + code: &str, + message: &str, +) -> io::Result<()> { + let mut payload = Vec::new(); + for (tag, value) in [(b'S', "FATAL"), (b'V', "FATAL"), (b'C', code), (b'M', message)] { + payload.push(tag); + payload.extend(value.bytes().filter(|byte| *byte != 0)); + payload.push(0); + } + payload.push(0); + let length = i32::try_from(payload.len() + 4) + .map_err(|_| io::Error::new(io::ErrorKind::InvalidData, "PostgreSQL startup error frame is too large"))?; + client.write_all(&[b'E']).await?; + client.write_all(&length.to_be_bytes()).await?; + client.write_all(&payload).await?; + client.flush().await +} + async fn handle_connection( mut client: TcpStream, peer: std::net::SocketAddr, upstream_addr: &str, verifier: Option<&TenantTokenVerifier>, + policy_admission: Option<&PolicyAdmissionClient>, tenant_role_prefix: &str, upstream_connect_timeout: std::time::Duration, client_acceptor: Option<&tokio_rustls::TlsAcceptor>, @@ -1008,9 +1369,26 @@ async fn handle_connection( Box::new(upstream_tcp) }; - let (client, upstream, session) = + let (mut client, upstream, session) = establish(client, upstream, verifier, tenant_role_prefix).await?; + if policy_admission.is_some() && session.tenant_context.is_none() { + metrics::global().policy_admission_checked(); + metrics::global().policy_admission_denied(); + return Err(io::Error::new(io::ErrorKind::PermissionDenied, + "Unauthenticated PostgreSQL protocol requests are disabled when policy admission is required")); + } + if let (Some(admission), Some(context)) = (policy_admission, session.tenant_context.as_ref()) { + if let Err(error) = admission.authorize_with_metrics(&session.database_name, &context.tenant_id).await { + let _ = write_startup_error( + &mut client, + "28000", + "Tenant policy posture is not verified; connection denied.", + ).await; + return Err(error); + } + } + if let Some(context) = session.tenant_context.as_ref().filter(|c| c.emergency) { let node_id = std::env::var("PROXIMA_NODE_ID").unwrap_or_default(); let nonce_hash = context.emergency_nonce_hash.as_deref().unwrap_or_default(); @@ -1025,6 +1403,10 @@ async fn handle_connection( )); } } + if let Some(ready_for_query) = session.ready_for_query.as_ref() { + client.write_all(ready_for_query).await?; + } + let session_started_at = Instant::now(); metrics::global().session_started(session.tenant_context.is_some()); info!( @@ -1039,17 +1421,45 @@ async fn handle_connection( "PostgreSQL session established" ); + let policy_identity = session.tenant_context.as_ref() + .map(|context| (session.database_name.clone(), context.tenant_id.clone())); let (mut client_reader, mut client_writer) = tokio::io::split(client); let (mut upstream_reader, mut upstream_writer) = tokio::io::split(upstream); let query_latency = Arc::new(QueryLatencyTracker::default()); - let copy_result = tokio::try_join!( - copy_frontend_messages( - &mut client_reader, - &mut upstream_writer, - query_latency.clone() - ), - copy_backend_messages(&mut upstream_reader, &mut client_writer, query_latency), - ); + let copy_result = { + let copy_future = tokio::try_join!( + copy_frontend_messages( + &mut client_reader, + &mut upstream_writer, + query_latency.clone(), + session.tenant_context.is_some(), + ), + copy_backend_messages( + &mut upstream_reader, + &mut client_writer, + query_latency, + session.tenant_context.is_some(), + ), + ); + tokio::pin!(copy_future); + if let (Some(admission), Some((database_name, tenant_id))) = (policy_admission, policy_identity.as_ref()) { + loop { + tokio::select! { + result = &mut copy_future => break result, + _ = tokio::time::sleep(std::time::Duration::from_secs(5)) => { + if let Err(error) = admission.authorize_with_metrics(database_name, tenant_id).await { + metrics::global().policy_admission_session_revoked(); + error!(peer = %peer, tenant = %tenant_id, %error, + "active PostgreSQL session terminated because tenant policy posture is no longer verified"); + break Err(error); + } + } + } + } + } else { + copy_future.await + } + }; let duration_micros = session_started_at .elapsed() .as_micros() @@ -1120,6 +1530,7 @@ async fn copy_backend_messages( reader: &mut R, writer: &mut W, query_latency: Arc, + tenant_enforced: bool, ) -> io::Result where R: AsyncRead + Unpin, @@ -1141,6 +1552,9 @@ where } let frame_length = i32::from_be_bytes(pending[1..5].try_into().unwrap()); if frame_length < 4 || frame_length as usize > 16 * 1024 * 1024 { + if tenant_enforced { + return Err(io::Error::new(io::ErrorKind::InvalidData, "invalid or oversized PostgreSQL backend frame in tenant-bound session")); + } pending.clear(); break; } @@ -1159,6 +1573,9 @@ where pending.advance(total_length); } if pending.len() > 16 * 1024 * 1024 + 5 { + if tenant_enforced { + return Err(io::Error::new(io::ErrorKind::InvalidData,"PostgreSQL frontend frame exceeded the inspection limit")); + } pending.clear(); } writer.write_all(&buffer[..size]).await?; @@ -1170,6 +1587,7 @@ async fn copy_frontend_messages( reader: &mut R, writer: &mut W, query_latency: Arc, + tenant_enforced: bool, ) -> io::Result where R: AsyncRead + Unpin, @@ -1191,7 +1609,9 @@ where } let frame_length = i32::from_be_bytes(pending[1..5].try_into().unwrap()); if frame_length < 4 || frame_length as usize > 16 * 1024 * 1024 { - // Preserve wire behavior: observer failures never mutate or suppress forwarded bytes. + if tenant_enforced { + return Err(io::Error::new(io::ErrorKind::InvalidData,"invalid or oversized PostgreSQL frontend frame in tenant-bound session")); + } pending.clear(); break; } @@ -1202,6 +1622,26 @@ where if pending.len() < total_length { break; } + if tenant_enforced && pending[0] == b'F' { + warn!("blocked legacy PostgreSQL FunctionCall in tenant-bound session"); + return Err(io::Error::new( + io::ErrorKind::PermissionDenied, + "legacy PostgreSQL FunctionCall is not permitted in tenant-bound sessions", + )); + } + if tenant_enforced && matches!(pending[0], b'Q' | b'P') { + let frame = &pending[..total_length]; + let Some(sql) = sql_guard::sql_from_frontend_frame(frame) else { + return Err(io::Error::new(io::ErrorKind::InvalidData,"could not safely inspect PostgreSQL query frame in tenant-bound session")); + }; + if sql_guard::blocks_tenant_session_mutation(sql) { + warn!("blocked SQL that attempts to change tenant-bound PostgreSQL session security state"); + return Err(io::Error::new( + io::ErrorKind::PermissionDenied, + "tenant-bound PostgreSQL sessions cannot change database roles, weaken row security, or mutate policy boundaries", + )); + } + } if matches!(pending[0], b'Q' | b'E') { metrics::global().query_processed(); query_latency.start(pending[0] == b'Q'); @@ -1367,3 +1807,87 @@ mod node_heartbeat_signature_tests { } } +#[cfg(test)] +mod policy_admission_evidence_tests { + use super::{policy_admission_evidence_is_consistent, NodePolicyStatusPayload}; + use serde_json::json; + + fn payload(decision: &str, checks: serde_json::Value) -> NodePolicyStatusPayload { + NodePolicyStatusPayload { + node_id: "node-1".into(), + request_timestamp: 1_800_000_000, + request_id: "request-1".into(), + target_id: "target-1".into(), + database_name: "app".into(), + tenant_id: "tenant-a".into(), + decision: decision.into(), + policy_revision: if decision == "allow" { Some(7) } else { None }, + reason: if decision == "allow" { "verified".into() } else { "policy_not_verified".into() }, + evidence: json!({ + "schema_version": "proxima.postgresql.policy-admission-evidence.v1", + "target_id": "target-1", + "database_name": "app", + "tenant_id": "tenant-a", + "observed_at": 1_800_000_000, + "decision": decision, + "reason": if decision == "allow" { "verified" } else { "policy_not_verified" }, + "checks": checks + }), + issued_at: 1_800_000_000, + expires_at: 1_800_000_015, + } + } + + fn protected_check() -> serde_json::Value { + json!({ + "revision_id": "revision-1", + "revision_version": 7, + "revision_status": "applied", + "revision_verified_at": "2026-11-17T10:00:00Z", + "registration_enabled": true, + "connection_status": "reachable", + "schema_drift_detected": false, + "schema_fingerprint": "fingerprint", + "fingerprint_fresh": true, + "tenant_role_prefix_matches": true, + "tenant_role_binding_valid": true, + "verification": {"state": "protected"}, + "latest_drift_state": "protected", + "latest_drift_finding_code": "protected", + "latest_drift_observed_at": "2026-11-17T10:00:00Z", + "drift_event_fresh": true, + "protected": true + }) + } + + #[test] + fn allow_requires_complete_matching_protected_evidence() { + let value = payload("allow", json!([protected_check()])); + assert!(policy_admission_evidence_is_consistent(&value, "target-1", "app", "tenant-a")); + } + + #[test] + fn allow_rejects_empty_or_unprotected_checks() { + let empty = payload("allow", json!([])); + let mut blocked = protected_check(); + blocked["tenant_role_binding_valid"] = json!(false); + let blocked = payload("allow", json!([blocked])); + assert!(!policy_admission_evidence_is_consistent(&empty, "target-1", "app", "tenant-a")); + assert!(!policy_admission_evidence_is_consistent(&blocked, "target-1", "app", "tenant-a")); + } + + #[test] + fn evidence_is_bound_to_target_database_and_tenant() { + let value = payload("allow", json!([protected_check()])); + assert!(!policy_admission_evidence_is_consistent(&value, "other-target", "app", "tenant-a")); + assert!(!policy_admission_evidence_is_consistent(&value, "target-1", "other-db", "tenant-a")); + assert!(!policy_admission_evidence_is_consistent(&value, "target-1", "app", "tenant-b")); + } + + #[test] + fn deny_evidence_may_have_no_registration_checks() { + let value = payload("deny", json!([])); + assert!(policy_admission_evidence_is_consistent(&value, "target-1", "app", "tenant-a")); + } +} + diff --git a/crates/proxima-engine/src/metrics.rs b/crates/proxima-engine/src/metrics.rs index d1f96806..7c94cdf2 100644 --- a/crates/proxima-engine/src/metrics.rs +++ b/crates/proxima-engine/src/metrics.rs @@ -18,6 +18,10 @@ pub struct EngineMetrics { established_sessions: AtomicU64, failed_sessions: AtomicU64, blocked_violations: AtomicU64, + policy_admission_checks: AtomicU64, + policy_admission_allowed: AtomicU64, + policy_admission_denied: AtomicU64, + policy_admission_session_revocations: AtomicU64, client_bytes: AtomicU64, database_bytes: AtomicU64, session_duration_micros: AtomicU64, @@ -129,6 +133,18 @@ impl EngineMetrics { pub fn violation_blocked(&self) { self.blocked_violations.fetch_add(1, Ordering::Relaxed); } + pub fn policy_admission_checked(&self) { + self.policy_admission_checks.fetch_add(1, Ordering::Relaxed); + } + pub fn policy_admission_allowed(&self) { + self.policy_admission_allowed.fetch_add(1, Ordering::Relaxed); + } + pub fn policy_admission_denied(&self) { + self.policy_admission_denied.fetch_add(1, Ordering::Relaxed); + } + pub fn policy_admission_session_revoked(&self) { + self.policy_admission_session_revocations.fetch_add(1, Ordering::Relaxed); + } pub fn observe_query_latency(&self, elapsed_micros: u64) { self.query_latency_count.fetch_add(1, Ordering::Relaxed); self.query_latency_sum_micros @@ -191,6 +207,18 @@ impl EngineMetrics { "# HELP proxima_engine_security_violations_blocked Total protocol or tenant-security violations blocked.\n", "# TYPE proxima_engine_security_violations_blocked counter\n", "proxima_engine_security_violations_blocked_total {}\n", + "# HELP proxima_engine_policy_admission_checks_total Signed PostgreSQL policy admission checks performed.\n", + "# TYPE proxima_engine_policy_admission_checks_total counter\n", + "proxima_engine_policy_admission_checks_total {}\n", + "# HELP proxima_engine_policy_admission_allowed_total Policy admission decisions that allowed tenant sessions.\n", + "# TYPE proxima_engine_policy_admission_allowed_total counter\n", + "proxima_engine_policy_admission_allowed_total {}\n", + "# HELP proxima_engine_policy_admission_denied_total Policy admission decisions that denied tenant sessions.\n", + "# TYPE proxima_engine_policy_admission_denied_total counter\n", + "proxima_engine_policy_admission_denied_total {}\n", + "# HELP proxima_engine_policy_admission_session_revocations_total Active sessions closed after a policy recheck denied access.\n", + "# TYPE proxima_engine_policy_admission_session_revocations_total counter\n", + "proxima_engine_policy_admission_session_revocations_total {}\n", "# HELP proxima_engine_client_bytes_total Bytes copied from clients to PostgreSQL.\n", "# TYPE proxima_engine_client_bytes_total counter\n", "proxima_engine_client_bytes_total {}\n", @@ -213,6 +241,10 @@ impl EngineMetrics { self.established_sessions.load(Ordering::Relaxed), self.failed_sessions.load(Ordering::Relaxed), self.blocked_violations.load(Ordering::Relaxed), + self.policy_admission_checks.load(Ordering::Relaxed), + self.policy_admission_allowed.load(Ordering::Relaxed), + self.policy_admission_denied.load(Ordering::Relaxed), + self.policy_admission_session_revocations.load(Ordering::Relaxed), self.client_bytes.load(Ordering::Relaxed), self.database_bytes.load(Ordering::Relaxed), duration as f64 / 1_000_000.0, @@ -303,6 +335,11 @@ mod tests { fn metrics_exposition_is_prometheus_compatible_and_tracks_sessions() { let metrics = EngineMetrics::default(); metrics.connection_accepted(); + metrics.policy_admission_checked(); + metrics.policy_admission_allowed(); + metrics.policy_admission_checked(); + metrics.policy_admission_denied(); + metrics.policy_admission_session_revoked(); metrics.session_started(true); metrics.session_finished(100, 80, 2_500); metrics.observe_query_latency(500); @@ -314,6 +351,10 @@ mod tests { assert!(output.contains("proxima_engine_database_bytes_total 80\n")); assert!(output.contains("proxima_engine_session_duration_seconds_total 0.002500\n")); assert!(output.contains("proxima_engine_authenticated_tenant_sessions_total 1\n")); + assert!(output.contains("proxima_engine_policy_admission_checks_total 2\n")); + assert!(output.contains("proxima_engine_policy_admission_allowed_total 1\n")); + assert!(output.contains("proxima_engine_policy_admission_denied_total 1\n")); + assert!(output.contains("proxima_engine_policy_admission_session_revocations_total 1\n")); assert!(output .contains("proxima_engine_query_roundtrip_latency_seconds_bucket{le=\"0.001\"} 1\n")); assert!(output diff --git a/crates/proxima-engine/src/mongodb_adapter.rs b/crates/proxima-engine/src/mongodb_adapter.rs new file mode 100644 index 00000000..9c002afb --- /dev/null +++ b/crates/proxima-engine/src/mongodb_adapter.rs @@ -0,0 +1,493 @@ +//! Native MongoDB catalog and authorization discovery. +//! +//! Discovery is performed with the authenticated account's effective +//! connection-status privileges. MongoDB database roles do not by themselves +//! enforce tenant ownership on individual documents; this adapter therefore +//! never converts catalog presence into an isolation allow decision. + +use crate::database_adapter::{ + AdapterError, AdapterFuture, AdapterTarget, CompiledPolicy, DatabaseAdapter, + DiscoveryRequest, DiscoverySnapshot, DiscoveredResource, DriftReport, + InspectionRequest, InspectionSnapshot, ResourceInspection, +}; +use crate::native_policy_plans::compile_mongodb_database_boundary; +use crate::security_core::{ + AdapterCapabilities, AdapterDescriptor, AdapterMaturity, DatabaseKind, + InspectionCompleteness, ResourceKind, ResourceRef, SecurityFinding, + SecurityPosture, TenantSecurityPolicy, VerificationReport, SECURITY_MODEL_VERSION, +}; +use mongodb::{ + bson::{doc, Bson, Document}, + options::{ClientOptions, ConnectionString, Tls}, + Client, +}; +use serde_json::{json, Value}; +use sha2::{Digest, Sha256}; +use std::time::Duration; + +pub struct MongoCatalogAdapter { + target_id: String, + database_name: String, + connection_uri: String, +} + +impl MongoCatalogAdapter { + pub fn new( + target_id: impl Into, + database_name: impl Into, + connection_uri: impl Into, + ) -> Result { + let target_id = target_id.into(); + let database_name = database_name.into(); + let connection_uri = connection_uri.into(); + let uri = connection_uri.to_ascii_lowercase(); + if target_id.trim().is_empty() || target_id.len() > 256 || target_id.contains('\0') + || database_name.trim().is_empty() || database_name.len() > 63 || database_name.contains('\0') + || connection_uri.trim().is_empty() || connection_uri.len() > 4096 + { + return Err(error("invalid_mongodb_target", "A bounded target ID, database name and connection URI are required.")); + } + let parameters: Vec<(&str, &str)> = uri.split_once('?').map(|(_, query)| { + query.split('&').filter_map(|part| part.split_once('=')).collect() + }).unwrap_or_default(); + let parameter_is_true = |key: &str| parameters.iter().any(|(name, value)| *name == key && *value == "true"); + let parsed = ConnectionString::parse(&connection_uri) + .map_err(|_| error("invalid_mongodb_connection_uri", "The MongoDB connection URI could not be parsed."))?; + let tls_enabled = uri.starts_with("mongodb+srv://") + || matches!(parsed.tls.as_ref(), Some(Tls::Enabled(_))); + let tls_disabled = matches!(parsed.tls.as_ref(), Some(Tls::Disabled)); + let insecure_tls = parsed.tls_insecure() == Some(true) + || parameter_is_true("tlsinsecure") + || parameter_is_true("tlsallowinvalidcertificates") + || parameter_is_true("tlsallowinvalidhostnames") + || matches!(parsed.tls.as_ref(), Some(Tls::Enabled(options)) if options.allow_invalid_certificates == Some(true)); + if !tls_enabled || tls_disabled || insecure_tls { + return Err(error("mongodb_tls_verification_required", "MongoDB connections must use TLS with certificate and hostname verification; insecure TLS options are forbidden.")); + } + Ok(Self { target_id, database_name, connection_uri }) + } + + fn validate_target(&self, target: &AdapterTarget) -> Result<(), AdapterError> { + if target.target_id != self.target_id || target.database_name != self.database_name { + return Err(error("mongodb_target_mismatch", "The request does not match this adapter's registered database target.")); + } + Ok(()) + } + + async fn connect_checked(&self) -> Result { + let mut options = ClientOptions::parse(&self.connection_uri).await.map_err(db_error)?; + options.server_selection_timeout = Some(Duration::from_secs(10)); + options.connect_timeout = Some(Duration::from_secs(10)); + let client = Client::with_options(options).map_err(db_error)?; + // Force authentication and server selection now, rather than treating + // the driver's lazy Client construction as a successful connection. + client.database(&self.database_name) + .run_command(doc! { "ping": 1 }) + .await.map_err(db_error)?; + Ok(client) + } + + async fn discover_inner(&self, request: &DiscoveryRequest) -> Result { + self.validate_target(&request.target)?; + if request.namespace.as_ref().is_some_and(|namespace| { + namespace.trim().is_empty() || namespace.len() > 63 || namespace.contains('\0') + || namespace != &self.database_name + }) { + return Err(error("invalid_discovery_namespace", "MongoDB discovery namespace must be the registered database name.")); + } + let client = self.connect_checked().await?; + let database = client.database(&self.database_name); + let connection_status = database.run_command(doc! { + "connectionStatus": 1, + "showPrivileges": true + }).await.map_err(db_error)?; + let names = database.list_collection_names().await.map_err(db_error)?; + let collection_inventory_truncated = names.len() > 10_000; + let names = names.into_iter().take(10_000).collect::>(); + let mut resources = Vec::with_capacity(names.len()); + let mut index_inventory_truncated = false; + let mut total_index_count = 0usize; + for name in names { + let response = database.run_command(doc! { + "listCollections": 1, + "filter": { "name": &name }, + "nameOnly": false, + }).await.map_err(db_error)?; + let first_batch = response.get_document("cursor") + .and_then(|cursor| cursor.get_array("firstBatch")) + .map_err(|_| error("mongodb_discovery_response_invalid", "MongoDB listCollections returned an invalid cursor response."))?; + let entry = first_batch.iter().find_map(Bson::as_document) + .ok_or_else(|| error("mongodb_discovery_resource_disappeared", "A collection disappeared between enumeration and metadata inspection."))?; + let resource_type = entry.get_str("type").unwrap_or("collection"); + let options = entry.get_document("options").cloned().unwrap_or_default(); + let info = entry.get_document("info").cloned().unwrap_or_default(); + let kind = if resource_type == "view" { ResourceKind::View } else { ResourceKind::Collection }; + let indexes = if resource_type == "view" { + Vec::new() + } else { + let index_response = database.run_command(doc! { "listIndexes": &name, "cursor": {} }) + .await.map_err(db_error)?; + let cursor = index_response.get_document("cursor") + .map_err(|_| error("mongodb_index_discovery_response_invalid", "MongoDB listIndexes returned an invalid cursor response."))?; + let first_batch = cursor.get_array("firstBatch") + .map_err(|_| error("mongodb_index_discovery_response_invalid", "MongoDB listIndexes did not return an index batch."))?; + let mut indexes = first_batch.iter().filter_map(Bson::as_document) + .map(bson_value).collect::,AdapterError>>()?; + total_index_count = total_index_count.saturating_add(indexes.len()); + let mut cursor_id = read_cursor_id(cursor); + while cursor_id != 0 && indexes.len() < 10_000 && total_index_count < 100_000 { + let next_response = database.run_command(doc! { "getMore": cursor_id, "collection": &name }) + .await.map_err(db_error)?; + let next_cursor = next_response.get_document("cursor") + .map_err(|_| error("mongodb_index_discovery_response_invalid", "MongoDB getMore returned an invalid cursor response."))?; + let next_batch = next_cursor.get_array("nextBatch") + .map_err(|_| error("mongodb_index_discovery_response_invalid", "MongoDB getMore did not return an index batch."))?; + for index in next_batch.iter().filter_map(Bson::as_document) { + if indexes.len() >= 10_000 || total_index_count >= 100_000 { index_inventory_truncated = true; break; } + indexes.push(bson_value(index)?); + total_index_count = total_index_count.saturating_add(1); + } + cursor_id = read_cursor_id(next_cursor); + } + if cursor_id != 0 { + index_inventory_truncated = true; + let _ = database.run_command(doc! { "killCursors": &name, "cursors": [cursor_id] }).await; + } + indexes + }; + let attributes = json!({ + "native_type": resource_type, + "options": bson_value(&options)?, + "info": bson_value(&info)?, + "indexes": indexes, + "collection_uuid": info.get("uuid").map(|value| format!("{value:?}")), + "validator": options.get("validator").map(|value| format!("{value:?}")), + "view_on": options.get_str("viewOn").ok(), + "pipeline": options.get_array("pipeline").ok().map(|value| format!("{value:?}")) + }); + resources.push(DiscoveredResource { + namespace: Some(self.database_name.clone()), + name, + kind, + owner: None, + attributes, + }); + } + let target_attributes = json!({ + "database": self.database_name, + "connection_status": bson_value(&connection_status)?, + "tls_certificate_verification_required": true, + "collection_inventory_truncated": collection_inventory_truncated, + "index_inventory_truncated": index_inventory_truncated, + "index_count": total_index_count + }); + let fingerprint = digest(&serde_json::to_vec(&json!({"target_id":self.target_id,"database_name":self.database_name,"target":target_attributes,"resources":resources})) + .map_err(|_| error("fingerprint_serialization_failed", "Could not serialize MongoDB discovery results."))?); + Ok(DiscoverySnapshot { + database_kind: DatabaseKind::MongoDb, + target: request.target.clone(), + // listCollections and connectionStatus are scoped to what the + // authenticated principal is allowed to see. + completeness: InspectionCompleteness::Incomplete, + target_attributes, + resources, + findings: { + let mut findings = vec![SecurityFinding { + code: "mongodb_catalog_visibility_not_proven".into(), + resource: None, + detail: "MongoDB collection and privilege visibility is scoped to the authenticated account; a partial inventory cannot certify complete database coverage.".into(), + }]; + if has_broad_mongodb_privileges(&connection_status) { + findings.push(SecurityFinding { + code: "mongodb_inspection_principal_overprivileged".into(), + resource: None, + detail: "The authenticated MongoDB principal has broad administrative, any-database or any-resource privileges. Use a dedicated least-privilege inspection identity separate from application tenant principals.".into(), + }); + } + if index_inventory_truncated { + findings.push(SecurityFinding { + code: "mongodb_index_inventory_truncated".into(), + resource: None, + detail: "At least one collection exposed more than 10,000 indexes; the index inventory is truncated.".into(), + }); + } + if collection_inventory_truncated { + findings.push(SecurityFinding { + code: "mongodb_collection_inventory_truncated".into(), + resource: None, + detail: "The visible collection/view inventory exceeded the 10,000-resource safety bound and was truncated.".into(), + }); + } + findings + }, + fingerprint: Some(fingerprint), + observed_at: chrono::Utc::now().to_rfc3339(), + }) + } + + async fn discover_bounded(&self, request: &DiscoveryRequest) -> Result { + tokio::time::timeout(std::time::Duration::from_secs(60), self.discover_inner(request)) + .await + .map_err(|_| AdapterError { + code: "mongodb_catalog_timeout".into(), + detail: "MongoDB catalog discovery exceeded the sixty-second operation deadline.".into(), + retryable: true, + })? + } + +} + +impl DatabaseAdapter for MongoCatalogAdapter { + fn descriptor(&self) -> AdapterDescriptor { + AdapterDescriptor { + kind: DatabaseKind::MongoDb, + name: "MongoDB catalog adapter", + maturity: AdapterMaturity::InDevelopment, + capabilities: AdapterCapabilities { + schema_inspection: true, + policy_generation: true, + drift_detection: true, + ..AdapterCapabilities::default() + }, + status_note: "TLS-verified collection, validator, view and effective privilege discovery are implemented. MongoDB document ownership enforcement, independent tenant probes, controlled deployment and runtime admission are not implemented.", + } + } + + fn discover<'a>(&'a self, request: &'a DiscoveryRequest) -> AdapterFuture<'a, Result> { + Box::pin(async move { self.discover_bounded(request).await }) + } + + fn inspect<'a>(&'a self, request: &'a InspectionRequest) -> AdapterFuture<'a, Result> { + Box::pin(async move { + self.validate_target(&request.target)?; + request.policy.validate().map_err(|_| error("invalid_policy", "The canonical tenant policy failed validation."))?; + let _compiled_plan = compile_mongodb_database_boundary(&request.policy)?; + let discovery = self.discover_bounded(&DiscoveryRequest { + target: request.target.clone(), + namespace: None, + }).await?; + let mut findings = discovery.findings.clone(); + let mut resources = Vec::with_capacity(request.policy.resources.len()); + for protected in &request.policy.resources { + let namespace = protected.resource.namespace.as_deref().unwrap_or(&self.database_name); + if namespace != self.database_name { + return Err(error("mongodb_resource_namespace_mismatch", "A MongoDB resource must belong to the registered database target.")); + } + let found = discovery.resources.iter().find(|resource| { + resource.namespace.as_deref() == Some(namespace) + && resource.name == protected.resource.name + && resource.kind == protected.resource.kind + }); + let mut resource_findings = Vec::new(); + if found.is_none() { + resource_findings.push(finding("protected_resource_not_found", &protected.resource, "The collection or view was not visible in the authenticated database inventory.")); + } else if protected.resource.kind != ResourceKind::Collection { + resource_findings.push(finding("unsupported_mongodb_policy_resource", &protected.resource, "The current MongoDB policy compiler manages tenant-isolated database resources, not views.")); + } else { + let attrs = &found.unwrap().attributes; + let validator = attrs["options"]["validator"].clone(); + let properties = validator.get("$jsonSchema").and_then(|schema| schema.get("properties")); + let tenant_property = properties.and_then(|value| value.get(protected.tenant_key.as_str())); + if tenant_property.is_none() { + resource_findings.push(finding("tenant_ownership_validator_missing", &protected.resource, "The collection validator does not declare the policy tenant ownership field.")); + } else if tenant_property.and_then(|property| property.get("bsonType")).is_none() { + resource_findings.push(finding("tenant_ownership_type_unconstrained", &protected.resource, "The collection validator does not constrain the BSON type of the tenant ownership field.")); + } else if tenant_property.and_then(|property| property.get("bsonType")).is_some_and(|bson_type| { + bson_type.as_str() == Some("null") || bson_type.as_array().is_some_and(|types| types.iter().any(|kind| kind.as_str() == Some("null"))) + }) { + resource_findings.push(finding("tenant_ownership_type_nullable", &protected.resource, "The collection validator permits BSON null for the tenant ownership field.")); + } + let required = validator.get("$jsonSchema").and_then(|schema| schema.get("required")).and_then(Value::as_array); + if !required.is_some_and(|fields| fields.iter().any(|field| field.as_str() == Some(protected.tenant_key.as_str()))) { + resource_findings.push(finding("tenant_ownership_not_required", &protected.resource, "The collection validator does not require the tenant ownership field.")); + } + let validation_action = attrs["options"]["validationAction"].as_str().unwrap_or("error"); + if !validation_action.eq_ignore_ascii_case("error") { + resource_findings.push(finding("mongodb_validator_not_rejecting_invalid_documents", &protected.resource, "The collection validationAction is not error, so invalid tenant documents may be accepted.")); + } + let validation_level = attrs["options"]["validationLevel"].as_str().unwrap_or("strict"); + if !validation_level.eq_ignore_ascii_case("strict") { + resource_findings.push(finding("mongodb_validator_not_strict", &protected.resource, "The collection validationLevel is not strict; existing documents may avoid full validation on updates.")); + } + } + resource_findings.push(finding("mongodb_document_isolation_probe_required", &protected.resource, "MongoDB database roles do not automatically enforce tenant ownership for individual documents; independent tenant-scoped document probes are required.")); + findings.extend(resource_findings.clone()); + let resource_fingerprint = if let Some(resource) = found { + Some(digest(&serde_json::to_vec(&resource.attributes) + .map_err(|_| error("fingerprint_serialization_failed", "Could not serialize MongoDB resource metadata."))?)) + } else { + None + }; + resources.push(ResourceInspection { + resource: protected.clone(), + completeness: InspectionCompleteness::Incomplete, + posture: SecurityPosture::NeedsAttention, + verified_operations: Vec::new(), + findings: resource_findings, + fingerprint: resource_fingerprint, + }); + } + Ok(InspectionSnapshot { + database_kind: DatabaseKind::MongoDb, + target: request.target.clone(), + completeness: discovery.completeness, + posture: SecurityPosture::NeedsAttention, + resources, + findings, + fingerprint: discovery.fingerprint, + observed_at: discovery.observed_at, + }) + }) + } + + fn compile_policy(&self, policy: &TenantSecurityPolicy) -> Result { + compile_mongodb_database_boundary(policy) + } + + fn verify<'a>(&'a self, policy: &'a TenantSecurityPolicy, snapshot: &'a InspectionSnapshot) -> AdapterFuture<'a, Result> { + Box::pin(async move { + if snapshot.database_kind != DatabaseKind::MongoDb + || snapshot.target.target_id != self.target_id + || snapshot.target.database_name != self.database_name { + return Err(error("mongodb_snapshot_target_mismatch", "The inspection snapshot does not belong to this MongoDB adapter target.")); + } + let mut findings = snapshot.findings.clone(); + findings.push(SecurityFinding { + code: "independent_tenant_probes_required".into(), + resource: None, + detail: format!("{} protected resources require own-tenant allow and cross-tenant deny document probes using distinct authenticated principals.", policy.resources.len()), + }); + findings.push(SecurityFinding { + code: "mongodb_runtime_tenant_binding_unavailable".into(), + resource: None, + detail: "No trusted MongoDB protocol gateway currently binds authenticated tenant identity to a native database/user boundary.".into(), + }); + Ok(VerificationReport { + model_version: SECURITY_MODEL_VERSION.into(), + posture: SecurityPosture::Blocked, + inspection: snapshot.completeness, + findings, + }) + }) + } + + fn detect_drift<'a>(&'a self, target: &'a AdapterTarget, previous_fingerprint: Option<&'a str>) -> AdapterFuture<'a, Result> { + Box::pin(async move { + self.validate_target(target)?; + if previous_fingerprint.is_some_and(|value| value.len() != 64 || hex::decode(value).map_or(true, |bytes| bytes.len() != 32)) { + return Err(error("invalid_previous_fingerprint", "The previous catalog fingerprint must be a 32-byte hexadecimal SHA-256 digest.")); + } + let snapshot = self.discover_bounded(&DiscoveryRequest { target: target.clone(), namespace: None }).await?; + Ok(DriftReport { + database_kind: DatabaseKind::MongoDb, + target: target.clone(), + detected: previous_fingerprint.is_some_and(|previous| Some(previous) != snapshot.fingerprint.as_deref()), + completeness: snapshot.completeness, + previous_fingerprint: previous_fingerprint.map(str::to_owned), + observed_fingerprint: snapshot.fingerprint, + findings: snapshot.findings, + observed_at: snapshot.observed_at, + }) + }) + } +} + +fn read_cursor_id(cursor: &Document) -> i64 { + cursor.get_i64("id").or_else(|_| cursor.get_i32("id").map(i64::from)).unwrap_or(0) +} + +fn has_broad_mongodb_privileges(status: &Document) -> bool { + let Some(auth_info) = status.get_document("authInfo").ok() else { return false }; + let broad_roles = ["root", "dbOwner", "userAdminAnyDatabase", "readWriteAnyDatabase", "dbAdminAnyDatabase", "clusterAdmin"]; + let role_is_broad = auth_info.get_array("authenticatedUserRoles").ok().is_some_and(|roles| { + roles.iter().filter_map(Bson::as_document).any(|role| { + role.get_str("role").ok().is_some_and(|name| broad_roles.iter().any(|broad| name.eq_ignore_ascii_case(broad))) + }) + }); + let privilege_is_broad = auth_info.get_array("authenticatedUserPrivileges").ok().is_some_and(|privileges| { + privileges.iter().filter_map(Bson::as_document).any(|privilege| { + let any_resource = privilege.get_document("resource").ok() + .and_then(|resource| resource.get_bool("anyResource").ok()).unwrap_or(false); + let any_action = privilege.get_array("actions").ok() + .is_some_and(|actions| actions.iter().any(|action| action.as_str() == Some("anyAction"))); + any_resource || any_action + }) + }); + role_is_broad || privilege_is_broad +} + +fn bson_value(document: &Document) -> Result { + serde_json::to_value(document).map_err(|_| error("mongodb_catalog_serialization_failed", "Could not serialize MongoDB catalog metadata.")) +} + +fn finding(code: &str, resource: &ResourceRef, detail: &str) -> SecurityFinding { + SecurityFinding { code: code.into(), resource: Some(resource.clone()), detail: detail.into() } +} + +fn digest(bytes: &[u8]) -> String { + let mut hash = Sha256::new(); + hash.update(bytes); + hex::encode(hash.finalize()) +} + +fn error(code: &str, detail: &str) -> AdapterError { + AdapterError { code: code.into(), detail: detail.into(), retryable: false } +} + +fn db_error(_error: mongodb::error::Error) -> AdapterError { + AdapterError { + code: "mongodb_catalog_operation_failed".into(), + detail: "The authenticated MongoDB catalog operation failed.".into(), + retryable: true, + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn requires_verified_tls_for_mongodb_connections() { + assert!(MongoCatalogAdapter::new("target", "app", "mongodb://localhost/app").is_err()); + assert!(MongoCatalogAdapter::new("target", "app", "mongodb://localhost/app?tls=false").is_err()); + assert!(MongoCatalogAdapter::new("target", "app", "mongodb://localhost/app?tls=true&tlsInsecure=true").is_err()); + assert!(MongoCatalogAdapter::new("target", "app", "mongodb://localhost/app?tls=true").is_ok()); + assert!(MongoCatalogAdapter::new("target", "app", "mongodb+srv://cluster.example/app").is_ok()); + } + + #[test] + fn detects_broad_mongodb_roles_and_any_resource_privileges() { + let root = doc! { + "authInfo": { + "authenticatedUserRoles": [{ "role": "root", "db": "admin" }], + "authenticatedUserPrivileges": [] + } + }; + assert!(has_broad_mongodb_privileges(&root)); + let any_resource = doc! { + "authInfo": { + "authenticatedUserRoles": [], + "authenticatedUserPrivileges": [{ + "resource": { "anyResource": true }, + "actions": ["find"] + }] + } + }; + assert!(has_broad_mongodb_privileges(&any_resource)); + } + + #[test] + fn descriptor_exposes_inventory_but_not_document_enforcement() { + let adapter = MongoCatalogAdapter::new("target", "app", "mongodb://localhost/app?tls=true").unwrap(); + let descriptor = adapter.descriptor(); + assert_eq!(descriptor.maturity, AdapterMaturity::InDevelopment); + assert!(descriptor.capabilities.schema_inspection); + assert!(descriptor.capabilities.policy_generation); + assert!(descriptor.capabilities.drift_detection); + assert!(!descriptor.capabilities.tenant_identity_enforcement); + assert!(!descriptor.capabilities.policy_semantic_verification); + assert!(!descriptor.capabilities.controlled_policy_deployment); + assert!(!descriptor.capabilities.runtime_fail_closed_admission); + assert!(!descriptor.capabilities.signed_security_evidence); + } +} diff --git a/crates/proxima-engine/src/mysql_adapter.rs b/crates/proxima-engine/src/mysql_adapter.rs new file mode 100644 index 00000000..fd0a7198 --- /dev/null +++ b/crates/proxima-engine/src/mysql_adapter.rs @@ -0,0 +1,801 @@ +//! Native MySQL/MariaDB catalog inspection adapter. +//! +//! This adapter discovers schemas, tables, views, routines and grants over a +//! TLS-verified MySQL protocol connection. It deliberately denies admission: +//! MySQL has no PostgreSQL-equivalent row-level security, and a catalog scan +//! cannot prove that a database-per-tenant runtime mapping is enforced. + +use crate::database_adapter::{ + AdapterError, AdapterFuture, AdapterTarget, CompiledPolicy, DatabaseAdapter, + DiscoveryRequest, DiscoverySnapshot, DiscoveredResource, DriftReport, + InspectionRequest, InspectionSnapshot, ResourceInspection, +}; +use crate::native_policy_plans::compile_mysql_database_boundary; +use crate::tenant_identity::VerifiedTenantIdentity; +use crate::connection_admission::ConnectionAdmissionGate; +use crate::policy_evidence::{PolicyEvidenceAuthority, SignedPolicyAdmission, SignedPolicyEvidence}; +use crate::security_core::{ + AdapterCapabilities, AdapterDescriptor, AdapterMaturity, DatabaseKind, + InspectionCompleteness, Operation, ResourceKind, ResourceRef, SecurityFinding, + SecurityPosture, TenantSecurityPolicy, VerificationReport, SECURITY_MODEL_VERSION, +}; +use serde_json::{json, Value}; +use sha2::{Digest, Sha256}; +use sqlx::{ + mysql::{MySqlConnectOptions, MySqlConnection, MySqlSslMode}, + Connection, Row, +}; +use std::str::FromStr; + +fn grants_are_scoped_to_database(grants: &[String], database_name: &str) -> bool { + if grants.is_empty() || database_name.trim().is_empty() + || database_name.chars().any(|character| character == char::from(0)) + { return false; } + let escaped_database = database_name.replace(char::from(96), "``"); + let expected_prefix = format!("{}{}{}.", char::from(96), escaped_database, char::from(96)); + grants.iter().all(|grant| { + let upper = grant.to_ascii_uppercase(); + let Some(on_index) = upper.find(" ON ") else { return false; }; + if !upper.starts_with("GRANT ") || upper.contains(" WITH GRANT OPTION") { return false; } + let privilege_clause = upper[..on_index].trim(); + let scope_start = on_index + 4; + let Some(to_offset) = upper[scope_start..].find(" TO ") else { return false; }; + let scope = grant[scope_start..scope_start + to_offset].trim(); + if scope == "*.*" { return privilege_clause == "GRANT USAGE"; } + scope.starts_with(&expected_prefix) + }) +} + +/// Open a database-per-tenant MySQL or MariaDB connection using a verified +/// tenant identity. The registered target selects one tenant database; the +/// authenticated account must have no global, wildcard, role, or other-database +/// grants. Shared-table row isolation is not inferred from this boundary. +pub async fn connect_tenant_session( + connection_url: &str, + target: &AdapterTarget, + kind: DatabaseKind, + identity: &VerifiedTenantIdentity, + evidence_authority: &PolicyEvidenceAuthority, + admission_gate: &ConnectionAdmissionGate, + evidence: &SignedPolicyEvidence, + admission: &SignedPolicyAdmission, + connection_id: &str, +) -> Result { + if !matches!(kind, DatabaseKind::MySql | DatabaseKind::MariaDb) + || identity.database_kind() != kind + || identity.target_id() != target.target_id + { + return Err(error("mysql_tenant_identity_scope_mismatch", "The verified tenant identity does not match this MySQL/MariaDB target.")); + } + let now = std::time::SystemTime::now() + .duration_since(std::time::UNIX_EPOCH) + .map_err(|_| error("mysql_tenant_identity_clock_invalid", "The system clock is before the Unix epoch."))? + .as_secs() as i64; + if identity.issued_at_unix() > now || identity.expires_at_unix() <= now { + return Err(error("mysql_tenant_identity_expired", "The verified tenant identity is not currently valid.")); + } + admission_gate.consume_for_identity( + evidence_authority, + admission, + evidence, + identity, + connection_id, + now, + ).map_err(|_| error("mysql_policy_admission_denied", "A valid, fresh, one-use signed tenant policy admission is required before opening a MySQL/MariaDB session."))?; + let mut options = MySqlConnectOptions::from_str(connection_url) + .map_err(|_| error("invalid_mysql_connection_config", "The MySQL connection URL could not be parsed."))?; + options = options.ssl_mode(MySqlSslMode::VerifyIdentity); + let mut connection = tokio::time::timeout( + std::time::Duration::from_secs(10), + MySqlConnection::connect_with(&options), + ).await.map_err(|_| error("mysql_tenant_connection_timeout", "The tenant database connection exceeded the ten-second deadline."))? + .map_err(db_error)?; + + let row = tokio::time::timeout( + std::time::Duration::from_secs(10), + sqlx::query("SELECT DATABASE() AS database_name, CURRENT_USER() AS authenticated_account") + .fetch_one(&mut connection), + ).await.map_err(|_| error("mysql_tenant_identity_timeout", "MySQL did not return connection identity within the ten-second deadline."))? + .map_err(db_error)?; + let database: Option = row.try_get("database_name").map_err(db_error)?; + let account: String = row.try_get("authenticated_account").map_err(db_error)?; + if database.as_deref() != Some(target.database_name.as_str()) || account.trim().is_empty() { + return Err(error("mysql_tenant_target_mismatch", "The authenticated connection reached a different database or did not expose its account.")); + } + + let grant_rows = tokio::time::timeout( + std::time::Duration::from_secs(10), + sqlx::query("SHOW GRANTS FOR CURRENT_USER()").fetch_all(&mut connection), + ).await.map_err(|_| error("mysql_tenant_grant_inspection_timeout", "MySQL grant inspection exceeded the ten-second deadline."))? + .map_err(db_error)?; + let mut grants = Vec::with_capacity(grant_rows.len()); + for row in grant_rows { + let grant: String = row.try_get(0).map_err(db_error)?; + grants.push(grant); + } + if !grants_are_scoped_to_database(&grants, &target.database_name) { + return Err(error("mysql_tenant_grants_too_broad", "The authenticated MySQL account has grants outside the selected tenant database, an inherited role, or unrecognized grant syntax.")); + } + Ok(connection) +} + +pub struct MySqlCatalogAdapter { + target_id: String, + database_name: String, + connection_url: String, + kind: DatabaseKind, +} + +impl MySqlCatalogAdapter { + pub fn new( + target_id: impl Into, + database_name: impl Into, + connection_url: impl Into, + kind: DatabaseKind, + ) -> Result { + let target_id = target_id.into(); + let database_name = database_name.into(); + let connection_url = connection_url.into(); + if target_id.trim().is_empty() || target_id.len() > 256 || target_id.contains('\0') + || database_name.trim().is_empty() || database_name.len() > 64 || database_name.contains('\0') + || connection_url.trim().is_empty() || connection_url.len() > 4096 + { + return Err(error("invalid_mysql_target", "A bounded target ID, database name and connection URL are required.")); + } + if !matches!(kind, DatabaseKind::MySql | DatabaseKind::MariaDb) { + return Err(error("invalid_mysql_adapter_kind", "The MySQL wire adapter only accepts MySQL or MariaDB targets.")); + } + MySqlConnectOptions::from_str(&connection_url) + .map_err(|_| error("invalid_mysql_connection_config", "The MySQL connection URL could not be parsed."))?; + Ok(Self { target_id, database_name, connection_url, kind }) + } + + fn validate_target(&self, target: &AdapterTarget) -> Result<(), AdapterError> { + if target.target_id != self.target_id || target.database_name != self.database_name { + return Err(error("mysql_target_mismatch", "The request does not match this adapter's registered database target.")); + } + Ok(()) + } + + async fn connect_checked(&self) -> Result { + let mut options = MySqlConnectOptions::from_str(&self.connection_url) + .map_err(|_| error("invalid_mysql_connection_config", "The MySQL connection URL could not be parsed."))?; + options = options.ssl_mode(MySqlSslMode::VerifyIdentity); + let mut connection = tokio::time::timeout( + std::time::Duration::from_secs(10), + MySqlConnection::connect_with(&options), + ).await.map_err(|_| error("mysql_connection_timeout", "The MySQL TLS connection exceeded the ten-second connection deadline."))? + .map_err(db_error)?; + let row = sqlx::query("SELECT DATABASE() AS database_name, CURRENT_USER() AS authenticated_account, VERSION() AS server_version") + .fetch_one(&mut connection).await.map_err(db_error)?; + let database: Option = row.try_get("database_name").map_err(db_error)?; + let account: String = row.try_get("authenticated_account").map_err(db_error)?; + let version: String = row.try_get("server_version").map_err(db_error)?; + if database.as_deref() != Some(self.database_name.as_str()) { + return Err(error("mysql_database_mismatch", "The authenticated connection reached a different database.")); + } + if account.trim().is_empty() { + return Err(error("mysql_identity_unavailable", "The server did not expose an authenticated account identity.")); + } + // Force subsequent autocommit statements into read-only transactions and + // require the vendor-specific SELECT execution deadline. Do not silently + // continue when the server refuses either safety setting. + sqlx::query("SET SESSION TRANSACTION READ ONLY") + .execute(&mut connection).await.map_err(db_error)?; + if version.to_ascii_lowercase().contains("mariadb") { + sqlx::query("SET SESSION max_statement_time=10") + .execute(&mut connection).await.map_err(db_error)?; + } else { + sqlx::query("SET SESSION MAX_EXECUTION_TIME=10000") + .execute(&mut connection).await.map_err(db_error)?; + } + // Catalog operations below are SELECT-only. No DDL, DML, role changes, + // or privilege mutations are performed by this adapter. + Ok(connection) + } + + async fn discover_inner( + &self, + request: &DiscoveryRequest, + ) -> Result { + self.validate_target(&request.target)?; + if request.namespace.as_ref().is_some_and(|namespace| { + namespace.trim().is_empty() || namespace.len() > 64 || namespace.contains('\0') + || namespace != &self.database_name + }) { + return Err(error("invalid_discovery_namespace", "MySQL discovery namespace must be the registered database name.")); + } + let mut connection = self.connect_checked().await?; + let table_rows = sqlx::query( + "SELECT TABLE_SCHEMA,TABLE_NAME,TABLE_TYPE,ENGINE,ROW_FORMAT,CREATE_OPTIONS \ + FROM information_schema.TABLES WHERE TABLE_SCHEMA=? ORDER BY TABLE_NAME LIMIT 10001" + ).bind(&self.database_name).fetch_all(&mut connection).await.map_err(db_error)?; + let table_inventory_truncated = table_rows.len() > 10_000; + let table_rows = table_rows.into_iter().take(10_000).collect::>(); + let mut resources = Vec::with_capacity(table_rows.len()); + for row in table_rows { + let schema: String = row.try_get("TABLE_SCHEMA").map_err(db_error)?; + let name: String = row.try_get("TABLE_NAME").map_err(db_error)?; + let table_type: String = row.try_get("TABLE_TYPE").map_err(db_error)?; + let columns = sqlx::query( + "SELECT COLUMN_NAME,COLUMN_TYPE,IS_NULLABLE,COLUMN_DEFAULT,EXTRA \ + FROM information_schema.COLUMNS WHERE TABLE_SCHEMA=? AND TABLE_NAME=? ORDER BY ORDINAL_POSITION" + ).bind(&schema).bind(&name).fetch_all(&mut connection).await.map_err(db_error)?; + let privileges = sqlx::query( + "SELECT GRANTEE,PRIVILEGE_TYPE,IS_GRANTABLE \ + FROM information_schema.TABLE_PRIVILEGES WHERE TABLE_SCHEMA=? AND TABLE_NAME=? \ + ORDER BY GRANTEE,PRIVILEGE_TYPE" + ).bind(&schema).bind(&name).fetch_all(&mut connection).await.map_err(db_error)?; + let column_privileges = sqlx::query( + "SELECT GRANTEE,COLUMN_NAME,PRIVILEGE_TYPE,IS_GRANTABLE \ + FROM information_schema.COLUMN_PRIVILEGES WHERE TABLE_SCHEMA=? AND TABLE_NAME=? ORDER BY GRANTEE,COLUMN_NAME,PRIVILEGE_TYPE" + ).bind(&schema).bind(&name).fetch_all(&mut connection).await.map_err(db_error)?; + let schema_privileges = sqlx::query( + "SELECT GRANTEE,PRIVILEGE_TYPE,IS_GRANTABLE \ + FROM information_schema.SCHEMA_PRIVILEGES WHERE TABLE_SCHEMA=? ORDER BY GRANTEE,PRIVILEGE_TYPE" + ).bind(&schema).fetch_all(&mut connection).await.map_err(db_error)?; + let constraints = sqlx::query( + "SELECT tc.CONSTRAINT_NAME,tc.CONSTRAINT_TYPE,kcu.COLUMN_NAME,kcu.REFERENCED_TABLE_SCHEMA,kcu.REFERENCED_TABLE_NAME,kcu.REFERENCED_COLUMN_NAME \ + FROM information_schema.TABLE_CONSTRAINTS tc \ + LEFT JOIN information_schema.KEY_COLUMN_USAGE kcu ON kcu.CONSTRAINT_SCHEMA=tc.CONSTRAINT_SCHEMA AND kcu.TABLE_NAME=tc.TABLE_NAME AND kcu.CONSTRAINT_NAME=tc.CONSTRAINT_NAME \ + WHERE tc.TABLE_SCHEMA=? AND tc.TABLE_NAME=? ORDER BY tc.CONSTRAINT_NAME,kcu.ORDINAL_POSITION" + ).bind(&schema).bind(&name).fetch_all(&mut connection).await.map_err(db_error)?; + let partitions = sqlx::query( + "SELECT PARTITION_NAME,SUBPARTITION_NAME,PARTITION_METHOD,SUBPARTITION_METHOD,PARTITION_EXPRESSION,SUBPARTITION_EXPRESSION FROM information_schema.PARTITIONS WHERE TABLE_SCHEMA=? AND TABLE_NAME=? ORDER BY PARTITION_ORDINAL_POSITION,SUBPARTITION_ORDINAL_POSITION" + ).bind(&schema).bind(&name).fetch_all(&mut connection).await.map_err(db_error)?; + let indexes = sqlx::query( + "SELECT INDEX_NAME,NON_UNIQUE,SEQ_IN_INDEX,COLUMN_NAME,INDEX_TYPE \ + FROM information_schema.STATISTICS WHERE TABLE_SCHEMA=? AND TABLE_NAME=? ORDER BY INDEX_NAME,SEQ_IN_INDEX" + ).bind(&schema).bind(&name).fetch_all(&mut connection).await.map_err(db_error)?; + let triggers = sqlx::query( + "SELECT TRIGGER_NAME,EVENT_MANIPULATION,ACTION_TIMING,ACTION_STATEMENT,DEFINER,SQL_MODE \ + FROM information_schema.TRIGGERS WHERE TRIGGER_SCHEMA=? AND EVENT_OBJECT_TABLE=? ORDER BY TRIGGER_NAME" + ).bind(&schema).bind(&name).fetch_all(&mut connection).await.map_err(db_error)?; + let kind = if table_type.eq_ignore_ascii_case("VIEW") { ResourceKind::View } else { ResourceKind::Table }; + let view_metadata = if kind == ResourceKind::View { + let view = sqlx::query( + "SELECT VIEW_DEFINITION,CHECK_OPTION,IS_UPDATABLE,DEFINER,SECURITY_TYPE \ + FROM information_schema.VIEWS WHERE TABLE_SCHEMA=? AND TABLE_NAME=?" + ).bind(&schema).bind(&name).fetch_optional(&mut connection).await.map_err(db_error)?; + view.map(|row| Ok(json!({ + "definition": row.try_get::,_>("VIEW_DEFINITION").map_err(db_error)?, + "check_option": row.try_get::("CHECK_OPTION").map_err(db_error)?, + "is_updatable": row.try_get::("IS_UPDATABLE").map_err(db_error)?, + "definer": row.try_get::("DEFINER").map_err(db_error)?, + "security_type": row.try_get::("SECURITY_TYPE").map_err(db_error)? + }))).transpose()? + } else { None }; + let attributes = json!({ + "table_type": table_type, + "engine": row.try_get::,_>("ENGINE").map_err(db_error)?, + "row_format": row.try_get::,_>("ROW_FORMAT").map_err(db_error)?, + "create_options": row.try_get::,_>("CREATE_OPTIONS").map_err(db_error)?, + "columns": columns.iter().map(|column| Ok(json!({ + "name": column.try_get::("COLUMN_NAME").map_err(db_error)?, + "type": column.try_get::("COLUMN_TYPE").map_err(db_error)?, + "nullable": column.try_get::("IS_NULLABLE").map_err(db_error)?, + "default": column.try_get::,_>("COLUMN_DEFAULT").map_err(db_error)?, + "extra": column.try_get::("EXTRA").map_err(db_error)? + }))).collect::,AdapterError>>()?, + "table_privileges": privileges.iter().map(|grant| Ok(json!({ + "grantee": grant.try_get::("GRANTEE").map_err(db_error)?, + "privilege": grant.try_get::("PRIVILEGE_TYPE").map_err(db_error)?, + "grantable": grant.try_get::("IS_GRANTABLE").map_err(db_error)? + }))).collect::,AdapterError>>()?, + "column_privileges": column_privileges.iter().map(|grant| Ok(json!({ + "grantee": grant.try_get::("GRANTEE").map_err(db_error)?, + "column": grant.try_get::("COLUMN_NAME").map_err(db_error)?, + "privilege": grant.try_get::("PRIVILEGE_TYPE").map_err(db_error)?, + "grantable": grant.try_get::("IS_GRANTABLE").map_err(db_error)? + }))).collect::,AdapterError>>()?, + "schema_privileges": schema_privileges.iter().map(|grant| Ok(json!({ + "grantee": grant.try_get::("GRANTEE").map_err(db_error)?, + "privilege": grant.try_get::("PRIVILEGE_TYPE").map_err(db_error)?, + "grantable": grant.try_get::("IS_GRANTABLE").map_err(db_error)? + }))).collect::,AdapterError>>()?, + "constraints": constraints.iter().map(|item| Ok(json!({ + "name": item.try_get::("CONSTRAINT_NAME").map_err(db_error)?, + "type": item.try_get::("CONSTRAINT_TYPE").map_err(db_error)?, + "column": item.try_get::,_>("COLUMN_NAME").map_err(db_error)?, + "referenced_schema": item.try_get::,_>("REFERENCED_TABLE_SCHEMA").map_err(db_error)?, + "referenced_table": item.try_get::,_>("REFERENCED_TABLE_NAME").map_err(db_error)?, + "referenced_column": item.try_get::,_>("REFERENCED_COLUMN_NAME").map_err(db_error)? + }))).collect::,AdapterError>>()?, + "partitions": partitions.iter().map(|item| Ok(json!({ + "partition": item.try_get::,_>("PARTITION_NAME").map_err(db_error)?, + "subpartition": item.try_get::,_>("SUBPARTITION_NAME").map_err(db_error)?, + "method": item.try_get::,_>("PARTITION_METHOD").map_err(db_error)?, + "subpartition_method": item.try_get::,_>("SUBPARTITION_METHOD").map_err(db_error)?, + "expression": item.try_get::,_>("PARTITION_EXPRESSION").map_err(db_error)?, + "subpartition_expression": item.try_get::,_>("SUBPARTITION_EXPRESSION").map_err(db_error)? + }))).collect::,AdapterError>>()?, + "indexes": indexes.iter().map(|item| Ok(json!({ + "name": item.try_get::("INDEX_NAME").map_err(db_error)?, + "non_unique": item.try_get::("NON_UNIQUE").map_err(db_error)?, + "sequence": item.try_get::("SEQ_IN_INDEX").map_err(db_error)?, + "column": item.try_get::,_>("COLUMN_NAME").map_err(db_error)?, + "type": item.try_get::("INDEX_TYPE").map_err(db_error)? + }))).collect::,AdapterError>>()?, + "triggers": triggers.iter().map(|item| Ok(json!({ + "name": item.try_get::("TRIGGER_NAME").map_err(db_error)?, + "event": item.try_get::("EVENT_MANIPULATION").map_err(db_error)?, + "timing": item.try_get::("ACTION_TIMING").map_err(db_error)?, + "statement": item.try_get::("ACTION_STATEMENT").map_err(db_error)?, + "definer": item.try_get::("DEFINER").map_err(db_error)?, + "sql_mode": item.try_get::("SQL_MODE").map_err(db_error)? + }))).collect::,AdapterError>>()?, + "view": view_metadata + }); + resources.push(DiscoveredResource { + namespace: Some(schema), + name, + kind, + owner: None, + attributes, + }); + } + let routine_rows = sqlx::query( + "SELECT ROUTINE_SCHEMA,ROUTINE_NAME,ROUTINE_TYPE,DEFINER,SECURITY_TYPE,SQL_DATA_ACCESS,IS_DETERMINISTIC,SQL_MODE,ROUTINE_DEFINITION \ + FROM information_schema.ROUTINES WHERE ROUTINE_SCHEMA=? ORDER BY ROUTINE_NAME,ROUTINE_TYPE LIMIT 10001" + ).bind(&self.database_name).fetch_all(&mut connection).await.map_err(db_error)?; + let routine_inventory_truncated = routine_rows.len() > 10_000; + let routine_rows = routine_rows.into_iter().take(10_000).collect::>(); + for row in routine_rows { + let routine_schema: String = row.try_get("ROUTINE_SCHEMA").map_err(db_error)?; + let routine_name: String = row.try_get("ROUTINE_NAME").map_err(db_error)?; + let routine_type: String = row.try_get("ROUTINE_TYPE").map_err(db_error)?; + let parameters = sqlx::query( + "SELECT PARAMETER_NAME,ORDINAL_POSITION,PARAMETER_MODE,DATA_TYPE \ + FROM information_schema.PARAMETERS WHERE SPECIFIC_SCHEMA=? AND SPECIFIC_NAME=? ORDER BY ORDINAL_POSITION" + ).bind(&routine_schema).bind(&routine_name).fetch_all(&mut connection).await.map_err(db_error)?; + resources.push(DiscoveredResource { + namespace: Some(routine_schema), + name: routine_name, + kind: if routine_type.eq_ignore_ascii_case("PROCEDURE") { ResourceKind::Procedure } else { ResourceKind::Function }, + owner: Some(row.try_get("DEFINER").map_err(db_error)?), + attributes: json!({ + "routine_type": routine_type, + "security_type": row.try_get::("SECURITY_TYPE").map_err(db_error)?, + "sql_data_access": row.try_get::("SQL_DATA_ACCESS").map_err(db_error)?, + "is_deterministic": row.try_get::("IS_DETERMINISTIC").map_err(db_error)?, + "sql_mode": row.try_get::("SQL_MODE").map_err(db_error)?, + "definition": row.try_get::,_>("ROUTINE_DEFINITION").map_err(db_error)?, + "parameters": parameters.iter().map(|parameter| Ok(json!({ + "name": parameter.try_get::,_>("PARAMETER_NAME").map_err(db_error)?, + "position": parameter.try_get::,_>("ORDINAL_POSITION").map_err(db_error)?, + "mode": parameter.try_get::,_>("PARAMETER_MODE").map_err(db_error)?, + "data_type": parameter.try_get::,_>("DATA_TYPE").map_err(db_error)? + }))).collect::,AdapterError>>()? + }), + }); + } + let target_row = sqlx::query("SELECT DATABASE() AS database_name, CURRENT_USER() AS authenticated_account, VERSION() AS server_version") + .fetch_one(&mut connection).await.map_err(db_error)?; + let grants = sqlx::query("SHOW GRANTS FOR CURRENT_USER") + .fetch_all(&mut connection).await.map_err(db_error)?; + let account_grant_statements = grants.iter() + .map(|row| row.try_get::(0).map_err(db_error)) + .collect::,AdapterError>>()?; + let elevated_inspection_account = has_elevated_inspection_grants(&account_grant_statements); + let active_roles_result: Result, sqlx::Error> = sqlx::query_scalar("SELECT CURRENT_ROLE()") + .fetch_one(&mut connection).await; + let active_roles_available = active_roles_result.is_ok(); + let active_roles = active_roles_result.ok().flatten(); + let global_privileges = sqlx::query( + "SELECT PRIVILEGE_TYPE,IS_GRANTABLE FROM information_schema.USER_PRIVILEGES ORDER BY PRIVILEGE_TYPE" + ).fetch_all(&mut connection).await.map_err(db_error)?; + let routine_privileges = sqlx::query( + "SELECT GRANTEE,ROUTINE_SCHEMA,ROUTINE_NAME,ROUTINE_TYPE,PRIVILEGE_TYPE,IS_GRANTABLE \ + FROM information_schema.ROUTINE_PRIVILEGES WHERE ROUTINE_SCHEMA=? ORDER BY ROUTINE_NAME,GRANTEE,PRIVILEGE_TYPE" + ).bind(&self.database_name).fetch_all(&mut connection).await.map_err(db_error)?; + let target_attributes = json!({ + "database": target_row.try_get::,_>("database_name").map_err(db_error)?, + "authenticated_account": target_row.try_get::("authenticated_account").map_err(db_error)?, + "server_version": target_row.try_get::("server_version").map_err(db_error)?, + "authenticated_account_grants": account_grant_statements, + "active_roles": active_roles, + "active_roles_available": active_roles_available, + "global_privileges": global_privileges.iter().map(|grant| Ok(json!({ + "privilege": grant.try_get::("PRIVILEGE_TYPE").map_err(db_error)?, + "grantable": grant.try_get::("IS_GRANTABLE").map_err(db_error)? + }))).collect::,AdapterError>>()?, + "inspection_account_has_elevated_privileges": elevated_inspection_account, + "routine_privileges": routine_privileges.iter().map(|grant| Ok(json!({ + "grantee": grant.try_get::("GRANTEE").map_err(db_error)?, + "routine_schema": grant.try_get::("ROUTINE_SCHEMA").map_err(db_error)?, + "routine": grant.try_get::("ROUTINE_NAME").map_err(db_error)?, + "routine_type": grant.try_get::("ROUTINE_TYPE").map_err(db_error)?, + "privilege": grant.try_get::("PRIVILEGE_TYPE").map_err(db_error)?, + "grantable": grant.try_get::("IS_GRANTABLE").map_err(db_error)? + }))).collect::,AdapterError>>()?, + "tls_identity_verification_required": true + }); + let fingerprint = digest(&serde_json::to_vec(&json!({"target_id":self.target_id,"database_name":self.database_name,"target":target_attributes,"resources":resources})) + .map_err(|_| error("fingerprint_serialization_failed", "Could not serialize MySQL discovery results."))?); + let observed_at: String = sqlx::query_scalar("SELECT DATE_FORMAT(UTC_TIMESTAMP(6),'%Y-%m-%dT%H:%i:%s.%fZ')") + .fetch_one(&mut connection).await.map_err(db_error)?; + Ok(DiscoverySnapshot { + database_kind: self.kind, + target: request.target.clone(), + // information_schema visibility is privilege-filtered. Without a + // separately attested inventory principal/metadata scope, absence + // from this result cannot prove that a resource does not exist. + completeness: InspectionCompleteness::Incomplete, + target_attributes, + resources, + findings: { + let mut findings = vec![SecurityFinding { + code: "mysql_catalog_visibility_not_proven".into(), + resource: None, + detail: "MySQL/MariaDB information_schema visibility is privilege-filtered; this inventory is limited to objects visible to the authenticated account and cannot certify full database coverage.".into(), + }]; + if !active_roles_available { + findings.push(SecurityFinding { + code: "mysql_active_role_state_unavailable".into(), + resource: None, + detail: "The server did not expose CURRENT_ROLE(); active role state must be reviewed through the authenticated account's grants before accepting an inventory.".into(), + }); + } + if table_inventory_truncated || routine_inventory_truncated { + findings.push(SecurityFinding { + code: "mysql_catalog_inventory_truncated".into(), + resource: None, + detail: "The visible catalog exceeded the 10,000-table or 10,000-routine safety bound; discovery is truncated and cannot be treated as a complete inventory.".into(), + }); + } + if elevated_inspection_account { + findings.push(SecurityFinding { + code: "mysql_inspection_account_overprivileged".into(), + resource: None, + detail: "The catalog inspection account has broad global or administrative privileges. Use a dedicated least-privilege inspection identity and keep it separate from application tenant principals.".into(), + }); + } + findings + }, + fingerprint: Some(fingerprint), + observed_at, + }) + } + + async fn discover_bounded(&self, request: &DiscoveryRequest) -> Result { + tokio::time::timeout(std::time::Duration::from_secs(60), self.discover_inner(request)) + .await + .map_err(|_| AdapterError { + code: "mysql_catalog_timeout".into(), + detail: "MySQL/MariaDB catalog discovery exceeded the sixty-second operation deadline.".into(), + retryable: true, + })? + } + +} + +impl DatabaseAdapter for MySqlCatalogAdapter { + fn descriptor(&self) -> AdapterDescriptor { + AdapterDescriptor { + kind: self.kind, + name: if self.kind == DatabaseKind::MariaDb { "MariaDB catalog adapter" } else { "MySQL catalog adapter" }, + maturity: AdapterMaturity::InDevelopment, + capabilities: AdapterCapabilities { + schema_inspection: true, + policy_generation: true, + drift_detection: true, + ..AdapterCapabilities::default() + }, + status_note: "TLS-verified native catalog discovery and privilege inspection are implemented. Database-per-tenant grant plans are review-only; runtime tenant binding, independent probes, controlled deployment and signed native admission remain unavailable.", + } + } + + fn discover<'a>(&'a self, request: &'a DiscoveryRequest) -> AdapterFuture<'a, Result> { + Box::pin(async move { self.discover_bounded(request).await }) + } + + fn inspect<'a>(&'a self, request: &'a InspectionRequest) -> AdapterFuture<'a, Result> { + Box::pin(async move { + self.validate_target(&request.target)?; + request.policy.validate().map_err(|_| error("invalid_policy", "The canonical tenant policy failed validation."))?; + let _compiled_plan = self.compile_policy(&request.policy)?; + let discovery = self.discover_bounded(&DiscoveryRequest { target: request.target.clone(), namespace: None }).await?; + let mut resources = Vec::with_capacity(request.policy.resources.len()); + let mut findings = discovery.findings.clone(); + for protected in &request.policy.resources { + let namespace = protected.resource.namespace.as_deref().unwrap_or(&self.database_name); + if namespace != self.database_name { + return Err(error("mysql_resource_namespace_mismatch", "A MySQL resource must belong to the registered database target.")); + } + let found = discovery.resources.iter().find(|resource| { + resource.namespace.as_deref() == Some(namespace) + && resource.name == protected.resource.name + && resource.kind == protected.resource.kind + }); + let Some(found) = found else { + resources.push(ResourceInspection { + resource: protected.clone(), + completeness: InspectionCompleteness::Incomplete, + posture: SecurityPosture::Blocked, + verified_operations: Vec::new(), + findings: vec![finding("protected_resource_not_found", &protected.resource, "The registered resource was not found in information_schema.")], + fingerprint: None, + }); + findings.push(finding("protected_resource_not_found", &protected.resource, "The registered resource was not found in information_schema.")); + continue; + }; + let mut resource_findings = Vec::new(); + if protected.resource.kind != ResourceKind::Table { + resource_findings.push(finding("unsupported_mysql_policy_resource", &protected.resource, "The current database-per-tenant compiler manages tables only.")); + } + if found.kind == ResourceKind::View && found.attributes["view"].is_null() { + resource_findings.push(finding("mysql_view_security_metadata_unavailable", &protected.resource, "View security metadata was not visible; definer/invoker behavior cannot be verified.")); + } else if found.kind == ResourceKind::View + && found.attributes["view"]["security_type"].as_str().is_some_and(|value| value.eq_ignore_ascii_case("DEFINER")) { + resource_findings.push(finding("mysql_definer_view_requires_review", &protected.resource, "This view executes with definer privileges and may expose rows beyond the caller's direct grants.")); + } + if found.attributes["triggers"].as_array().is_some_and(|triggers| !triggers.is_empty()) { + resource_findings.push(finding("mysql_trigger_definer_requires_review", &protected.resource, "Triggers execute in a definer security context; review every trigger body and definer privilege for tenant-boundary bypasses.")); + } + if found.attributes["security_type"].as_str().is_some_and(|value| value.eq_ignore_ascii_case("DEFINER")) { + resource_findings.push(finding("mysql_definer_routine_requires_review", &protected.resource, "This stored routine executes with definer privileges and requires explicit tenant-boundary review.")); + } + if matches!(protected.resource.kind, ResourceKind::Table | ResourceKind::View) { + let columns = found.attributes["columns"].as_array().cloned().unwrap_or_default(); + let tenant_column = columns.iter().find(|column| column["name"].as_str() == Some(protected.tenant_key.as_str())); + match tenant_column { + None => resource_findings.push(finding("tenant_ownership_column_missing", &protected.resource, "The policy tenant key does not exist on this table or view.")), + Some(column) if column["nullable"].as_str() != Some("NO") => + resource_findings.push(finding("tenant_ownership_column_nullable", &protected.resource, "The policy tenant key allows NULL values.")), + _ => {} + } + } else { + let parameters = found.attributes["parameters"].as_array().cloned().unwrap_or_default(); + let tenant_parameter = parameters.iter().find(|parameter| { + parameter["name"].as_str() == Some(protected.tenant_key.as_str()) + && matches!(parameter["mode"].as_str(), Some("IN" | "INOUT")) + }); + if tenant_parameter.is_none() { + resource_findings.push(finding("mysql_tenant_identity_parameter_missing", &protected.resource, "The routine does not expose the configured tenant identity as an IN or INOUT parameter.")); + } + } + resource_findings.push(finding("mysql_database_per_tenant_probe_required", &protected.resource, "MySQL has no native row-level security. Separate database grants must be tested with independent tenant principals before isolation can be verified.")); + let resource_fingerprint = digest(&serde_json::to_vec(&found.attributes) + .map_err(|_| error("fingerprint_serialization_failed", "Could not serialize MySQL resource inspection."))?); + findings.extend(resource_findings.clone()); + resources.push(ResourceInspection { + resource: protected.clone(), + completeness: InspectionCompleteness::Incomplete, + posture: SecurityPosture::NeedsAttention, + verified_operations: Vec::new(), + findings: resource_findings, + fingerprint: Some(resource_fingerprint), + }); + } + Ok(InspectionSnapshot { + database_kind: self.kind, + target: request.target.clone(), + completeness: discovery.completeness, + posture: SecurityPosture::NeedsAttention, + resources, + findings, + fingerprint: discovery.fingerprint, + observed_at: discovery.observed_at, + }) + }) + } + + fn compile_policy(&self, policy: &TenantSecurityPolicy) -> Result { + compile_mysql_database_boundary(policy, self.kind) + } + + fn verify<'a>(&'a self, policy: &'a TenantSecurityPolicy, snapshot: &'a InspectionSnapshot) -> AdapterFuture<'a, Result> { + Box::pin(async move { + if snapshot.database_kind != self.kind || snapshot.target.target_id != self.target_id + || snapshot.target.database_name != self.database_name { + return Err(error("mysql_snapshot_target_mismatch", "The inspection snapshot does not match this adapter target.")); + } + let mut findings = snapshot.findings.clone(); + findings.push(SecurityFinding { + code: "independent_tenant_probes_required".into(), + resource: None, + detail: format!("{} policy resources require own-tenant allow and cross-tenant deny probes using distinct database principals.", policy.resources.len()), + }); + findings.push(SecurityFinding { + code: "mysql_runtime_principal_binding_unavailable".into(), + resource: None, + detail: "No trusted MySQL protocol gateway currently binds authenticated tenant identity to a dedicated native account and database.".into(), + }); + Ok(VerificationReport { + model_version: SECURITY_MODEL_VERSION.into(), + posture: SecurityPosture::Blocked, + inspection: snapshot.completeness, + findings, + }) + }) + } + + fn detect_drift<'a>(&'a self, target: &'a AdapterTarget, previous_fingerprint: Option<&'a str>) -> AdapterFuture<'a, Result> { + Box::pin(async move { + self.validate_target(target)?; + if previous_fingerprint.is_some_and(|value| value.len() != 64 || hex::decode(value).map_or(true, |bytes| bytes.len() != 32)) { + return Err(error("invalid_previous_fingerprint", "The previous catalog fingerprint must be a 32-byte hexadecimal SHA-256 digest.")); + } + let snapshot = self.discover_bounded(&DiscoveryRequest { target: target.clone(), namespace: None }).await?; + Ok(DriftReport { + database_kind: self.kind, + target: target.clone(), + detected: previous_fingerprint.is_some_and(|previous| Some(previous) != snapshot.fingerprint.as_deref()), + completeness: snapshot.completeness, + previous_fingerprint: previous_fingerprint.map(str::to_owned), + observed_fingerprint: snapshot.fingerprint, + findings: snapshot.findings, + observed_at: snapshot.observed_at, + }) + }) + } +} + +fn has_elevated_inspection_grants(grants: &[String]) -> bool { + grants.iter().any(|grant| { + let upper = grant.to_ascii_uppercase(); + upper.contains("ALL PRIVILEGES ON *.*") + || upper.contains("WITH GRANT OPTION") + || upper.contains(" SUPER ") + || upper.contains("SYSTEM_USER") + || upper.contains("ROLE_ADMIN") + || upper.contains("CREATE USER") + }) +} + +fn finding(code: &str, resource: &ResourceRef, detail: &str) -> SecurityFinding { + SecurityFinding { code: code.into(), resource: Some(resource.clone()), detail: detail.into() } +} + +fn digest(bytes: &[u8]) -> String { + let mut hash = Sha256::new(); + hash.update(bytes); + hex::encode(hash.finalize()) +} + +fn error(code: &str, detail: &str) -> AdapterError { + AdapterError { code: code.into(), detail: detail.into(), retryable: false } +} + +fn db_error(error: sqlx::Error) -> AdapterError { + AdapterError { + code: "mysql_catalog_query_failed".into(), + detail: "The authenticated MySQL catalog operation failed.".into(), + retryable: matches!(error, sqlx::Error::PoolTimedOut | sqlx::Error::Io(_) | sqlx::Error::Tls(_)), + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn accepts_only_mysql_family_database_kinds() { + assert!(MySqlCatalogAdapter::new("target", "app", "mysql://localhost/app", DatabaseKind::PostgreSql).is_err()); + assert!(MySqlCatalogAdapter::new("target", "app", "mysql://localhost/app", DatabaseKind::MySql).is_ok()); + assert!(MySqlCatalogAdapter::new("target", "app", "mysql://localhost/app", DatabaseKind::MariaDb).is_ok()); + } + + #[test] + fn descriptor_exposes_inspection_and_drift_but_not_admission() { + let adapter = MySqlCatalogAdapter::new("target", "app", "mysql://localhost/app", DatabaseKind::MySql).unwrap(); + let descriptor = adapter.descriptor(); + assert_eq!(descriptor.maturity, AdapterMaturity::InDevelopment); + assert!(descriptor.capabilities.schema_inspection); + assert!(descriptor.capabilities.policy_generation); + assert!(descriptor.capabilities.drift_detection); + assert!(!descriptor.capabilities.tenant_identity_enforcement); + assert!(!descriptor.capabilities.policy_semantic_verification); + assert!(!descriptor.capabilities.controlled_policy_deployment); + assert!(!descriptor.capabilities.runtime_fail_closed_admission); + assert!(!descriptor.capabilities.signed_security_evidence); + } + + #[test] + fn rejects_invalid_connection_urls_before_network_access() { + assert!(MySqlCatalogAdapter::new("target", "app", "not-a-mysql-url", DatabaseKind::MySql).is_err()); + assert!(MySqlCatalogAdapter::new("target", "app", "postgres://localhost/app", DatabaseKind::MySql).is_err()); + } + + #[test] + fn identifies_global_and_administrative_inspection_grants() { + assert!(has_elevated_inspection_grants(&[ + "GRANT SELECT ON app.* TO 'auditor'@'%'".into(), + "GRANT ALL PRIVILEGES ON *.* TO 'auditor'@'%'".into(), + ])); + assert!(has_elevated_inspection_grants(&[ + "GRANT SELECT ON app.* TO 'auditor'@'%' WITH GRANT OPTION".into(), + ])); + assert!(!has_elevated_inspection_grants(&[ + "GRANT SELECT, SHOW VIEW ON app.* TO 'auditor'@'%'".into(), + ])); + } + + #[tokio::test] + async fn discovery_rejects_a_different_registered_target_before_connecting() { + let adapter = MySqlCatalogAdapter::new("target-a", "app", "mysql://localhost/app", DatabaseKind::MySql).unwrap(); + let request = DiscoveryRequest { + target: AdapterTarget { target_id: "target-b".into(), database_name: "app".into(), namespace: None }, + namespace: None, + }; + assert_eq!(adapter.discover(&request).await.unwrap_err().code, "mysql_target_mismatch"); + } + + #[tokio::test] + async fn verification_never_allows_catalog_only_mysql_evidence() { + use crate::security_core::{ProtectedResource, ResourceRef}; + let adapter = MySqlCatalogAdapter::new("target", "app", "mysql://localhost/app", DatabaseKind::MySql).unwrap(); + let policy = TenantSecurityPolicy { + schema_version: SECURITY_MODEL_VERSION.into(), + policy_id: "tenant-policy".into(), + revision: 1, + tenant_identity_claim: "tenant_id".into(), + resources: vec![ProtectedResource { + resource: ResourceRef { namespace: Some("app".into()), name: "records".into(), kind: ResourceKind::Table }, + tenant_key: "tenant_id".into(), + operations: vec![Operation::Read], + }], + }; + let snapshot = InspectionSnapshot { + database_kind: DatabaseKind::MySql, + target: AdapterTarget { target_id: "target".into(), database_name: "app".into(), namespace: None }, + completeness: InspectionCompleteness::Complete, + posture: SecurityPosture::Verified, + resources: Vec::new(), + findings: Vec::new(), + fingerprint: Some("a".repeat(64)), + observed_at: "2026-11-17T00:00:00Z".into(), + }; + let report = adapter.verify(&policy, &snapshot).await.unwrap(); + assert_eq!(report.posture, SecurityPosture::Blocked); + assert!(!report.findings.is_empty()); + } + + #[test] + fn rejects_unbounded_or_empty_target_configuration() { + assert!(MySqlCatalogAdapter::new("", "app", "mysql://localhost/app", DatabaseKind::MySql).is_err()); + assert!(MySqlCatalogAdapter::new("target", &"d".repeat(65), "mysql://localhost/app", DatabaseKind::MySql).is_err()); + } +} + +#[cfg(test)] +mod tenant_database_grant_tests { + use super::grants_are_scoped_to_database; + + #[test] + fn grant_scope_must_be_limited_to_the_selected_database() { + let scoped = vec![ + "GRANT USAGE ON *.* TO 'tenant_a'@'%'".to_owned(), + "GRANT SELECT, INSERT, UPDATE, DELETE ON `tenant_a`.* TO 'tenant_a'@'%'".to_owned(), + ]; + assert!(grants_are_scoped_to_database(&scoped, "tenant_a")); + assert!(!grants_are_scoped_to_database( + &["GRANT SELECT ON `tenant_b`.* TO 'tenant_a'@'%'".to_owned()], + "tenant_a", + )); + assert!(!grants_are_scoped_to_database( + &["GRANT SELECT ON *.* TO 'tenant_a'@'%'".to_owned()], + "tenant_a", + )); + assert!(!grants_are_scoped_to_database( + &["GRANT 'tenant_role'@'%' TO 'tenant_a'@'%'".to_owned()], + "tenant_a", + )); + assert!(!grants_are_scoped_to_database( + &["GRANT SELECT ON `tenant_a_extra`.* TO 'tenant_a'@'%'".to_owned()], + "tenant_a", + )); + assert!(!grants_are_scoped_to_database( + &["GRANT SELECT ON `tenant_a`.* TO 'tenant_a'@'%' WITH GRANT OPTION".to_owned()], + "tenant_a", + )); + assert!(!grants_are_scoped_to_database( + &["unrecognized grant output".to_owned()], + "tenant_a", + )); + assert!(!grants_are_scoped_to_database( + &["GRANT USAGE ON *.* TO 'tenant_a'@'%'".to_owned()], + &format!("tenant{}a", char::from(0)), + )); + } +} diff --git a/crates/proxima-engine/src/native_policy_plans.rs b/crates/proxima-engine/src/native_policy_plans.rs new file mode 100644 index 00000000..10eaf119 --- /dev/null +++ b/crates/proxima-engine/src/native_policy_plans.rs @@ -0,0 +1,544 @@ +//! Native policy-plan compilers for non-PostgreSQL database families. +//! +//! These functions produce reviewable, non-executable policy plans. They do not +//! connect to customer databases, apply DDL/ACL changes, or prove effective +//! authorization. Runtime adapters must add native inspection, deployment, +//! semantic verification, drift handling, and adversarial acceptance first. + +use crate::security_core::{DatabaseKind, Operation, ProtectedResource, ResourceKind, TenantSecurityPolicy}; +use crate::database_adapter::{AdapterError, CompiledPolicy, NativePolicyChange}; +use serde_json::json; +use sha2::{Digest, Sha256}; + +fn error(code: &str, detail: &str) -> AdapterError { + AdapterError { code: code.into(), detail: detail.into(), retryable: false } +} + +fn identifier(value: &str, max: usize) -> Result<&str, AdapterError> { + if value.trim().is_empty() || value.len() > max || value.contains('\0') { + return Err(error("invalid_identifier", "A native resource identifier is empty, too long, or contains a NUL byte.")); + } + Ok(value) +} + +fn sql_server_ident(value: &str) -> Result { + identifier(value, 128)?; + Ok(format!("[{}]", value.replace(']', "]]"))) +} + +fn mysql_ident(value: &str) -> Result { + identifier(value, 64)?; + Ok(format!("\x60{}\x60", value.replace('\x60', "\x60\x60"))) +} + +fn resource_change(resource: &ProtectedResource, action: &str, definition: serde_json::Value) -> NativePolicyChange { + NativePolicyChange { resource: resource.clone(), action: action.into(), definition } +} + +/// SQL Server uses native Row-Level Security. The generated predicate binds +/// each row to the trusted connection's SESSION_CONTEXT tenant_id value. +pub fn compile_sql_server(policy: &TenantSecurityPolicy) -> Result { + policy.validate().map_err(|e| error("invalid_policy", &format!("The shared policy is invalid: {e:?}")))?; + let mut changes = Vec::new(); + for resource in &policy.resources { + if resource.resource.kind != ResourceKind::Table { + return Err(error("unsupported_resource_kind", "SQL Server RLS compilation currently accepts tables only; views, procedures and functions need separate review.")); + } + let schema = sql_server_ident(resource.resource.namespace.as_deref().unwrap_or("dbo"))?; + let table = sql_server_ident(&resource.resource.name)?; + let tenant_key = sql_server_ident(&resource.tenant_key)?; + if resource.operations.contains(&Operation::Execute) { + return Err(error("unsupported_operation", "SQL Server table RLS does not compile execute operations; use a separately reviewed module policy.")); + } + let identity = format!("{}:{}:{}", policy.policy_id, resource.resource.namespace.as_deref().unwrap_or("dbo"), resource.resource.name); + let digest = Sha256::digest(identity.as_bytes()); + let suffix = hex::encode(&digest[..8]); + let function_name = format!("{schema}.[proxima_tenant_{suffix}]"); + let policy_name = format!("{schema}.[proxima_policy_{suffix}]"); + let claim = policy.tenant_identity_claim.replace('\'', "''"); + let mut statements = vec![format!( + "CREATE OR ALTER FUNCTION {function_name}(@row_tenant_key )\nRETURNS TABLE WITH SCHEMABINDING AS\nRETURN SELECT 1 AS allowed\nWHERE CONVERT(nvarchar(450), @row_tenant_key) = CONVERT(nvarchar(450), SESSION_CONTEXT(N'{claim}'));" + )]; + if resource.operations.contains(&Operation::Read) { + statements.push(format!("ADD FILTER PREDICATE {function_name}({tenant_key}) ON {schema}.{table}")); + } + if resource.operations.iter().any(|op| matches!(op, Operation::Create | Operation::Update | Operation::Delete)) { + if resource.operations.contains(&Operation::Create) { + statements.push(format!("ADD BLOCK PREDICATE {function_name}({tenant_key}) ON {schema}.{table} AFTER INSERT")); + } + if resource.operations.contains(&Operation::Update) { + statements.push(format!("ADD BLOCK PREDICATE {function_name}({tenant_key}) ON {schema}.{table} BEFORE UPDATE")); + statements.push(format!("ADD BLOCK PREDICATE {function_name}({tenant_key}) ON {schema}.{table} AFTER UPDATE")); + } + if resource.operations.contains(&Operation::Delete) { + statements.push(format!("ADD BLOCK PREDICATE {function_name}({tenant_key}) ON {schema}.{table} BEFORE DELETE")); + } + } + let predicate_lines = statements.iter().skip(1).cloned().collect::>(); + let create_policy = if predicate_lines.is_empty() { + String::new() + } else { + let schema_name = resource.resource.namespace.as_deref().unwrap_or("dbo"); + let schema_literal = schema_name.replace('\'', "''"); + let policy_short_name = format!("proxima_policy_{suffix}"); + format!( + "IF NOT EXISTS (SELECT 1 FROM sys.security_policies WHERE name = N'{policy_short_name}' AND schema_id = SCHEMA_ID(N'{schema_literal}'))\nBEGIN\n CREATE SECURITY POLICY {policy_name}\n {}\n WITH (STATE = ON, SCHEMABINDING = ON);\nEND;", + predicate_lines.join(",\n ") + ) + }; + let mut batches = vec![statements[0].clone()]; + if !create_policy.is_empty() { batches.push(create_policy); } + changes.push(resource_change(resource, "sql_server_create_or_alter_rls", json!({ + "batches": batches, + "required_session_context": policy.tenant_identity_claim, + "session_context_must_be_set_by": "trusted_authenticated_application_or_gateway", + "required_catalog_substitution": { "placeholder": "", "source": "live_catalog_type_of_the_tenant_key_column" }, + "requires_operator_approval": true, + "limitations": [ + "The adapter must prove that untrusted clients cannot set or overwrite SESSION_CONTEXT.", + "The generated function contains a verified-column-type placeholder and is not executable until a live catalog inspector substitutes the exact native type.", + "Existing security policies require an explicit ALTER SECURITY POLICY revision; the template only creates a missing policy.", + "SQL Server ownership chaining, elevated principals, module signing and bypass paths require catalog verification." + ] + }))); + } + Ok(CompiledPolicy { database_kind: DatabaseKind::SqlServer, policy_id: policy.policy_id.clone(), revision: policy.revision, changes, requires_approval: true }) +} + +/// MySQL and MariaDB do not provide PostgreSQL/SQL Server-style native row-level +/// security. This compiler therefore emits a database-per-tenant grant template; +/// it deliberately refuses to pretend that a shared table is row-isolated. +pub fn compile_mysql_database_boundary(policy: &TenantSecurityPolicy, kind: DatabaseKind) -> Result { + if !matches!(kind, DatabaseKind::MySql | DatabaseKind::MariaDb) { + return Err(error("wrong_adapter_kind", "This compiler accepts MySQL or MariaDB only.")); + } + policy.validate().map_err(|e| error("invalid_policy", &format!("The shared policy is invalid: {e:?}")))?; + let mut changes = Vec::new(); + for resource in &policy.resources { + if resource.resource.kind != ResourceKind::Table { + return Err(error("unsupported_resource_kind", "MySQL-family tenant database templates currently accept tables only.")); + } + if resource.operations.contains(&Operation::Execute) { + return Err(error("unsupported_operation", "MySQL table grants do not implement the canonical execute operation; use a separately reviewed routine policy.")); + } + let table = mysql_ident(&resource.resource.name)?; + let mut grants = Vec::new(); + if resource.operations.contains(&Operation::Read) { grants.push("SELECT"); } + if resource.operations.contains(&Operation::Create) { grants.push("INSERT"); } + if resource.operations.contains(&Operation::Update) { grants.push("UPDATE"); } + if resource.operations.contains(&Operation::Delete) { grants.push("DELETE"); } + let sql = if grants.is_empty() { return Err(error("empty_privilege_set", "No supported table operations were requested.")); } + else { format!("GRANT {} ON \x60${{tenant_database}}\x60.{table} TO '${{tenant_principal}}'@'${{trusted_application_host}}';", grants.join(", ")) }; + changes.push(resource_change(resource, "mysql_family_per_tenant_database_grant_template", json!({ + "sql_template": [ + "CREATE USER IF NOT EXISTS '${tenant_principal}'@'${trusted_application_host}' IDENTIFIED BY '${secret_manager_generated_password}' REQUIRE SSL;", + sql + ], + "required_isolation_model": "one_database_per_tenant", + "database_placeholder": "${tenant_database}", + "database_placeholder_requirement": "Resolve from a trusted tenant-to-database registry, validate the native identifier length and character policy, and quote as a MySQL identifier; never interpolate an untrusted tenant string.", + "principal_placeholder": "${tenant_principal}", + "principal_placeholder_requirement": "Generate a unique bounded principal name from trusted tenant identity and quote it as a MySQL account component.", + "credential_placeholder": "${secret_manager_generated_password}", + "credential_placeholder_requirement": "Generate a unique high-entropy secret in a secret manager; never reuse a shared tenant password. CREATE USER IF NOT EXISTS does not rotate an existing credential; reconcile existing account credentials through a separately approved secret-rotation step.", + "account_transport_requirement": "The generated account requires SSL; the application connection must also verify the server certificate and hostname.", + "host_placeholder": "${trusted_application_host}", + "host_placeholder_requirement": "Replace with the exact trusted application egress host or a narrowly scoped network identity; never use an unrestricted wildcard host.", + "shared_table_row_level_isolation": false, + "limitations": [ + "MySQL and MariaDB have no native row-level security predicate equivalent.", + "A shared database/table with tenant_id is not protected by this grant template.", + "The application must resolve tenant identity before selecting a tenant-specific database and credential.", + "Database/user creation, grants, definer objects, global privileges and administrative accounts still require native inspection and acceptance." + ] + }))); + } + Ok(CompiledPolicy { database_kind: kind, policy_id: policy.policy_id.clone(), revision: policy.revision, changes, requires_approval: true }) +} + +/// MongoDB authorization is database/collection scoped, not document-tenant +/// scoped. This template is safe only with a database-per-tenant layout. +pub fn compile_mongodb_database_boundary(policy: &TenantSecurityPolicy) -> Result { + policy.validate().map_err(|e| error("invalid_policy", &format!("The shared policy is invalid: {e:?}")))?; + let mut changes = Vec::new(); + for resource in &policy.resources { + if resource.resource.kind != ResourceKind::Collection { + return Err(error("unsupported_resource_kind", "MongoDB boundary templates accept collections only.")); + } + if resource.operations.contains(&Operation::Execute) { + return Err(error("unsupported_operation", "MongoDB command, aggregation, map-reduce and change-stream execution require a separately reviewed command policy.")); + } + let database = resource.resource.namespace.as_deref().ok_or_else(|| error("tenant_database_required", "MongoDB collection policy requires a database namespace."))?; + identifier(database, 63)?; + identifier(&resource.resource.name, 120)?; + let mut actions = Vec::new(); + if resource.operations.contains(&Operation::Read) { actions.push("find"); } + if resource.operations.contains(&Operation::Create) { actions.push("insert"); } + if resource.operations.contains(&Operation::Update) { actions.push("update"); } + if resource.operations.contains(&Operation::Delete) { actions.push("remove"); } + if actions.is_empty() { return Err(error("empty_privilege_set", "No supported MongoDB actions were requested.")); } + changes.push(resource_change(resource, "mongodb_per_tenant_database_role_template", json!({ + "role_template": { + "role": "proximaTenantRole", + "db": "${tenant_database}", + "privileges": [{ + "resource": {"db": "${tenant_database}", "collection": resource.resource.name}, + "actions": actions + }], + "roles": [] + }, + "required_isolation_model": "one_database_per_tenant", + "shared_collection_document_level_isolation": false, + "limitations": [ + "MongoDB RBAC does not enforce arbitrary tenant_id predicates on individual documents.", + "Shared collections require an independently enforced document-level authorization layer; this role template is not sufficient.", + "Built-in roles, inherited custom roles, cluster privileges, change streams, views and administrative users require inspection." + ] + }))); + } + Ok(CompiledPolicy { database_kind: DatabaseKind::MongoDb, policy_id: policy.policy_id.clone(), revision: policy.revision, changes, requires_approval: true }) +} + +/// Redis ACL templates restrict a tenant principal to a tenant-specific key +/// namespace. The key pattern must contain the literal ${tenant_id} placeholder. +pub fn compile_redis_acl(policy: &TenantSecurityPolicy) -> Result { + policy.validate().map_err(|e| error("invalid_policy", &format!("The shared policy is invalid: {e:?}")))?; + let mut changes = Vec::new(); + for resource in &policy.resources { + let pattern = &resource.tenant_key; + let Some((prefix, suffix)) = pattern.split_once("${tenant_id}") else { + return Err(error("redis_tenant_key_pattern_required", "Redis tenant_key must contain exactly one literal ${tenant_id} placeholder, for example tenant:${tenant_id}:*.")); + }; + if pattern.matches("${tenant_id}").count() != 1 + || prefix.is_empty() + || prefix.contains('*') + || !suffix.starts_with(':') + || !pattern.chars().all(|ch| ch.is_ascii_alphanumeric() || matches!(ch, ':' | '_' | '-' | '*' | '$' | '{' | '}')) + { + return Err(error("unsafe_redis_key_pattern", "Redis key patterns must be a bounded tenant-prefixed pattern with one tenant placeholder and no whitespace, glob escape, or command syntax.")); + } + if resource.resource.kind != ResourceKind::Keyspace && resource.resource.kind != ResourceKind::Table { + return Err(error("unsupported_resource_kind", "Redis policy resources must represent a keyspace or logical key collection.")); + } + if resource.operations.contains(&Operation::Execute) { + return Err(error("unsupported_operation", "Redis script/function execution requires a separately reviewed command and key-access policy; it is not represented by the generic execute operation.")); + } + let mut commands: Vec<&str> = Vec::new(); + if resource.operations.contains(&Operation::Read) { + commands.extend([ + "+get", "+mget", "+exists", "+ttl", "+pttl", "+type", "+strlen", "+getrange", + "+hget", "+hmget", "+hgetall", "+hexists", "+hlen", "+lrange", "+llen", "+lindex", + "+scard", "+smembers", "+sismember", "+zrange", "+zscore", "+zcard", "+xrange", "+xlen" + ]); + } + if resource.operations.contains(&Operation::Create) { + // Redis writes are frequently upserts. These commands are + // restricted to the tenant key pattern, but ACLs cannot enforce + // NX/XX or distinguish creation from replacement. + commands.extend([ + "+set", "+mset", "+hset", "+lpush", "+rpush", "+sadd", + "+zadd", "+xadd" + ]); + } + if resource.operations.contains(&Operation::Update) { + commands.extend([ + "+set", "+mset", "+expire", "+pexpire", "+persist", "+incr", + "+decr", "+hset", "+lpush", "+rpush", "+sadd", "+zadd", "+xadd" + ]); + } + if resource.operations.contains(&Operation::Delete) { + commands.extend([ + "+del", "+unlink", "+hdel", "+lpop", "+rpop", "+srem", + "+zrem", "+xdel" + ]); + } + commands.sort_unstable(); + commands.dedup(); + if commands.is_empty() { + return Err(error("empty_privilege_set", "No supported Redis command category was requested.")); + } + let mut acl_template = vec![ + "reset".to_string(), + "on".to_string(), + ">${secret_manager_generated_password}".to_string(), + format!("~{pattern}"), + ]; + acl_template.extend(commands.iter().map(|value| value.to_string())); + changes.push(resource_change(resource, "redis_acl_user_template", json!({ + "acl_template": acl_template, + "username_template": "proxima:${tenant_id}", + "password_source": "unique_secret_from_secret_manager", + "transport": "TLS_required_outside_local_development", + "limitations": [ + "The trusted gateway must authenticate the tenant and select the matching Redis ACL user.", + "Every key must follow the tenant key pattern; unscoped keys and keyless commands need separate policy review.", + "This template is a database ACL boundary, not proof of command-level isolation for every Redis module or server version.", + "Redis ACLs cannot distinguish create-only from update-only semantics for upsert commands such as SET, HSET, SADD and ZADD; an enforcing gateway or application contract must enforce those distinctions.", + "ACL users, selectors, key patterns, channels, scripts, functions, modules and replication/admin commands require native inspection." + ] + }))); + } + Ok(CompiledPolicy { database_kind: DatabaseKind::Redis, policy_id: policy.policy_id.clone(), revision: policy.revision, changes, requires_approval: true }) +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::security_core::{ResourceRef, SECURITY_MODEL_VERSION}; + + fn policy(kind: ResourceKind, tenant_key: &str) -> TenantSecurityPolicy { + TenantSecurityPolicy { + schema_version: SECURITY_MODEL_VERSION.into(), + policy_id: "tenant-boundary".into(), + revision: 1, + tenant_identity_claim: "tenant_id".into(), + resources: vec![ProtectedResource { + resource: ResourceRef { namespace: Some("app".into()), name: "records".into(), kind }, + tenant_key: tenant_key.into(), + operations: vec![Operation::Read, Operation::Create, Operation::Update, Operation::Delete], + }], + } + } + + #[test] + fn sql_server_plan_uses_filter_and_block_predicates() { + let compiled = compile_sql_server(&policy(ResourceKind::Table, "tenant_id")).unwrap(); + assert_eq!(compiled.database_kind, DatabaseKind::SqlServer); + let batches = compiled.changes[0].definition["batches"].as_array().unwrap(); + let ddl = batches.iter().filter_map(|batch| batch.as_str()).collect::>().join("\n"); + assert!(ddl.contains("SESSION_CONTEXT(N'tenant_id')")); + assert!(ddl.contains("")); + assert!(ddl.contains("FILTER PREDICATE")); + assert!(ddl.contains("AFTER INSERT")); + assert!(ddl.contains("BEFORE UPDATE")); + assert!(ddl.contains("BEFORE DELETE")); + assert_eq!(batches.len(), 2); + } + + #[test] + fn mysql_family_template_explicitly_requires_database_per_tenant() { + let compiled = compile_mysql_database_boundary(&policy(ResourceKind::Table, "tenant_id"), DatabaseKind::MySql).unwrap(); + assert_eq!(compiled.database_kind, DatabaseKind::MySql); + assert_eq!(compiled.changes[0].definition["required_isolation_model"], "one_database_per_tenant"); + assert_eq!(compiled.changes[0].definition["shared_table_row_level_isolation"], false); + let template = compiled.changes[0].definition["sql_template"].as_array().unwrap() + .iter().filter_map(|value| value.as_str()).collect::>().join("\n"); + assert!(template.contains("@'${trusted_application_host}'")); + assert!(!template.contains("@'%'")); + assert_eq!(compiled.changes[0].definition["host_placeholder"], "${trusted_application_host}"); + } + + #[test] + fn mysql_template_rejects_execute_instead_of_silently_dropping_it() { + let mut requested = policy(ResourceKind::Table, "tenant_id"); + requested.resources[0].operations = vec![Operation::Read, Operation::Execute]; + let error = compile_mysql_database_boundary(&requested, DatabaseKind::MySql).unwrap_err(); + assert_eq!(error.code, "unsupported_operation"); + } + + #[test] + fn mysql_account_template_is_idempotent_and_requires_tls() { + let compiled = compile_mysql_database_boundary(&policy(ResourceKind::Table, "tenant_id"), DatabaseKind::MariaDb).unwrap(); + let template = compiled.changes[0].definition["sql_template"].as_array().unwrap() + .iter().filter_map(|value| value.as_str()).collect::>().join("\n"); + assert!(template.contains("CREATE USER IF NOT EXISTS")); + assert!(template.contains("REQUIRE SSL")); + assert!(template.contains("GRANT SELECT, INSERT, UPDATE, DELETE")); + } + + #[test] + fn mongodb_template_does_not_claim_document_level_security() { + let compiled = compile_mongodb_database_boundary(&policy(ResourceKind::Collection, "tenant_id")).unwrap(); + assert_eq!(compiled.changes[0].definition["shared_collection_document_level_isolation"], false); + } + + #[test] + fn mongodb_template_rejects_execute_instead_of_silently_dropping_it() { + let mut requested = policy(ResourceKind::Collection, "tenant_id"); + requested.resources[0].operations = vec![Operation::Read, Operation::Execute]; + let error = compile_mongodb_database_boundary(&requested).unwrap_err(); + assert_eq!(error.code, "unsupported_operation"); + } + + #[test] + fn redis_delete_only_policy_does_not_grant_write_or_update_commands() { + let mut delete_policy = policy(ResourceKind::Keyspace, "tenant:${tenant_id}:*"); + delete_policy.resources[0].operations = vec![Operation::Delete]; + let compiled = compile_redis_acl(&delete_policy).unwrap(); + let acl = compiled.changes[0].definition["acl_template"].as_array().unwrap(); + let commands = acl.iter().filter_map(|value| value.as_str()).collect::>(); + assert!(commands.contains(&"+del")); + assert!(commands.contains(&"+unlink")); + assert!(!commands.contains(&"+set")); + assert!(!commands.contains(&"+hset")); + assert!(!commands.contains(&"+incr")); + } + + #[test] + fn redis_template_rejects_execute_instead_of_silently_dropping_it() { + let mut requested = policy(ResourceKind::Keyspace, "tenant:${tenant_id}:*"); + requested.resources[0].operations = vec![Operation::Read, Operation::Execute]; + let error = compile_redis_acl(&requested).unwrap_err(); + assert_eq!(error.code, "unsupported_operation"); + } + + #[test] + fn redis_create_policy_documents_upsert_semantic_limit() { + let mut create_policy = policy(ResourceKind::Keyspace, "tenant:${tenant_id}:*"); + create_policy.resources[0].operations = vec![Operation::Create]; + let compiled = compile_redis_acl(&create_policy).unwrap(); + let acl = compiled.changes[0].definition["acl_template"].as_array().unwrap(); + let commands = acl.iter().filter_map(|value| value.as_str()).collect::>(); + assert!(commands.contains(&"+set")); + assert!(!commands.contains(&"+del")); + assert!(compiled.changes[0].definition["limitations"].as_array().unwrap().iter() + .any(|value| value.as_str().unwrap_or("").contains("cannot distinguish create-only from update-only"))); + } + + #[test] + fn redis_requires_explicit_tenant_key_pattern_and_uses_a_narrow_allowlist() { + let compiled = compile_redis_acl(&policy(ResourceKind::Keyspace, "tenant:${tenant_id}:*")).unwrap(); + let acl = compiled.changes[0].definition["acl_template"].as_array().unwrap(); + let acl_text = acl.iter().filter_map(|value| value.as_str()).collect::>().join(" "); + assert!(acl_text.contains("+get")); + assert!(acl_text.contains("+set")); + assert!(!acl_text.contains("+@all")); + assert!(!acl_text.contains("+keys")); + assert!(compile_redis_acl(&policy(ResourceKind::Keyspace, "tenant_id")).is_err()); + assert!(compile_redis_acl(&policy(ResourceKind::Keyspace, "*:${tenant_id}:*")).is_err()); + } +} + + +/// Oracle Virtual Private Database (VPD) policy compiler. +/// +/// Oracle's DBMS_RLS predicate is evaluated inside the database for each +/// statement. Tenant identity is read only from a secure application context; +/// the generated package contains a mandatory trusted-verifier integration +/// point and must not be deployed with that placeholder unresolved. +pub fn compile_oracle_vpd(policy: &TenantSecurityPolicy) -> Result { + policy.validate().map_err(|e| error("invalid_policy", &format!("The shared policy is invalid: {e:?}")))?; + let mut changes = Vec::new(); + for resource in &policy.resources { + if resource.resource.kind != ResourceKind::Table { + return Err(error("unsupported_resource_kind", "Oracle VPD compilation currently accepts tables only; views and PL/SQL entry points require separately verified policies.")); + } + if resource.operations.contains(&Operation::Execute) { + return Err(error("unsupported_operation", "Oracle table VPD does not authorize PL/SQL execution; package and procedure access require a separate least-privilege grant policy.")); + } + let owner = identifier(resource.resource.namespace.as_deref().ok_or_else(|| error("oracle_schema_required", "Oracle protected tables must specify their owning schema."))?, 128)?; + let table = identifier(&resource.resource.name, 128)?; + let tenant_column = identifier(&resource.tenant_key, 128)?; + let identity = format!("{}:{}:{}", policy.policy_id, owner.to_ascii_uppercase(), table.to_ascii_uppercase()); + let digest = Sha256::digest(identity.as_bytes()); + let suffix = hex::encode(&digest[..8]).to_ascii_uppercase(); + let package = format!("PROXIMA_CTX_{suffix}"); + let policy_name = format!("PROXIMA_POL_{suffix}"); + let function_name = format!("PROXIMA_VPD_{suffix}"); + let owner_sql = format!("\"{}\"", owner.replace('"', "\"\"")); + let column_sql = format!("\"{}\"", tenant_column.replace('"', "\"\"")); + let package_sql = format!("{owner_sql}.\"{package}\""); + let function_sql = format!("{owner_sql}.\"{function_name}\""); + let predicate = format!("{column_sql} = SYS_CONTEXT('PROXIMA_TENANT_CTX','TENANT_ID')"); + let statement_types = resource.operations.iter().filter_map(|op| match op { + Operation::Read => Some("SELECT"), + Operation::Create => Some("INSERT"), + Operation::Update => Some("UPDATE"), + Operation::Delete => Some("DELETE"), + Operation::Execute => None, + }).collect::>().join(","); + let statements = vec![ + format!( + "CREATE OR REPLACE PACKAGE {package_sql} AUTHID DEFINER AS\n PROCEDURE SET_TENANT(p_tenant_id IN VARCHAR2, p_signed_context IN CLOB, p_signature IN VARCHAR2);\n FUNCTION TENANT_PREDICATE(p_schema IN VARCHAR2, p_object IN VARCHAR2) RETURN VARCHAR2;\nEND;" + ), + format!( + "CREATE OR REPLACE PACKAGE BODY {package_sql} AS\n FUNCTION PROXIMA_TRUSTED_ASSERTION_VERIFY(p_tenant_id IN VARCHAR2, p_signed_context IN CLOB, p_signature IN VARCHAR2) RETURN BOOLEAN IS\n BEGIN\n -- Fail closed until the deployment supplies the audited signature verifier.\n RAISE_APPLICATION_ERROR(-20073, 'Trusted tenant assertion verifier is not configured');\n RETURN FALSE;\n END;\n PROCEDURE SET_TENANT(p_tenant_id IN VARCHAR2, p_signed_context IN CLOB, p_signature IN VARCHAR2) IS\n BEGIN\n IF p_tenant_id IS NULL OR LENGTH(p_tenant_id) > 256 THEN RAISE_APPLICATION_ERROR(-20071, 'Invalid tenant identity'); END IF;\n -- REQUIRED: replace this fail-closed hook with verification of the signed,\n -- short-lived tenant assertion against a key unavailable to application users.\n IF NOT PROXIMA_TRUSTED_ASSERTION_VERIFY(p_tenant_id, p_signed_context, p_signature) THEN\n RAISE_APPLICATION_ERROR(-20072, 'Tenant assertion rejected');\n END IF;\n DBMS_SESSION.SET_CONTEXT('PROXIMA_TENANT_CTX','TENANT_ID',p_tenant_id);\n END;\n FUNCTION TENANT_PREDICATE(p_schema IN VARCHAR2, p_object IN VARCHAR2) RETURN VARCHAR2 IS\n BEGIN\n IF SYS_CONTEXT('PROXIMA_TENANT_CTX','TENANT_ID') IS NULL THEN\n RETURN '1=0';\n END IF;\n RETURN '{predicate}';\n END;\nEND;" + ), + format!("CREATE CONTEXT PROXIMA_TENANT_CTX USING {package_sql};"), + format!( + "CREATE OR REPLACE FUNCTION {function_sql}(p_schema IN VARCHAR2, p_object IN VARCHAR2) RETURN VARCHAR2 AUTHID DEFINER IS\nBEGIN\n IF SYS_CONTEXT('PROXIMA_TENANT_CTX','TENANT_ID') IS NULL THEN RETURN '1=0'; END IF;\n RETURN '{predicate}';\nEND;" + ), + format!( + "BEGIN\n DBMS_RLS.ADD_POLICY(\n object_schema => '{}', object_name => '{}', policy_name => '{}',\n function_schema => '{}', policy_function => '{}',\n statement_types => '{}', update_check => TRUE, enable => TRUE,\n policy_type => DBMS_RLS.DYNAMIC);\nEND;", + owner.replace('\'', "''"), table.replace('\'', "''"), policy_name, + owner.replace('\'', "''"), function_name.replace('\'', "''"), statement_types + ) + ]; + changes.push(resource_change(resource, "oracle_create_vpd_policy_plan", json!({ + "plsql_batches": statements, + "native_enforcement": "Oracle DBMS_RLS Virtual Private Database", + "tenant_identity_source": "secure Oracle application context PROXIMA_TENANT_CTX.TENANT_ID", + "missing_context_behavior": "deny_all_predicate", + "write_semantics": "DBMS_RLS update_check TRUE enforces tenant predicate on inserted and updated row values", + "required_trusted_identity_integration": { + "placeholder": "PROXIMA_TRUSTED_ASSERTION_VERIFY", + "must_validate": ["signature", "issuer", "audience", "target_id", "tenant_id", "expiry", "nonce_or_replay_window"], + "key_storage": "database wallet or external secret manager; never application-readable", + "failure_behavior": "raise error and leave context unset" + }, + "required_grants": [ + "The deployment principal needs narrowly scoped DBMS_RLS policy administration rights.", + "The runtime principal must not own protected tables and must not have EXEMPT ACCESS POLICY.", + "Only the trusted context package may set PROXIMA_TENANT_CTX; revoke direct package/context administration from application principals." + ], + "requires_approval": true, + "limitations": [ + "The trusted assertion verifier is a mandatory implementation dependency; the generated plan is not deployable until it is linked and independently tested.", + "Oracle VPD is not automatically applied to every access path: inspect SYS-owned objects, definer-rights PL/SQL, synonyms, views, database links and exempt principals.", + "This plan does not grant table privileges or secure PL/SQL EXECUTE privileges.", + "The compiler does not execute DDL or certify tenant isolation." + ] + }))); + } + Ok(CompiledPolicy { database_kind: DatabaseKind::Oracle, policy_id: policy.policy_id.clone(), revision: policy.revision, changes, requires_approval: true }) +} + + +#[cfg(test)] +mod oracle_vpd_tests { + use super::*; + + fn oracle_policy() -> TenantSecurityPolicy { + TenantSecurityPolicy { + schema_version: crate::security_core::SECURITY_MODEL_VERSION.into(), + policy_id: "oracle-tenant-boundary".into(), + revision: 1, + tenant_identity_claim: "tenant_id".into(), + resources: vec![ProtectedResource { + resource: crate::security_core::ResourceRef { + namespace: Some("APP".into()), + name: "ORDERS".into(), + kind: ResourceKind::Table, + }, + tenant_key: "TENANT_ID".into(), + operations: vec![Operation::Read, Operation::Create, Operation::Update, Operation::Delete], + }], + } + } + + #[test] + fn oracle_compiles_vpd_with_secure_context_and_write_check() { + let compiled = compile_oracle_vpd(&oracle_policy()).unwrap(); + assert_eq!(compiled.database_kind, DatabaseKind::Oracle); + assert!(compiled.requires_approval); + let batches = compiled.changes[0].definition["plsql_batches"].as_array().unwrap(); + let sql = batches.iter().filter_map(|value| value.as_str()).collect::>().join("\n"); + assert!(sql.contains("DBMS_RLS.ADD_POLICY")); + assert!(sql.contains("SYS_CONTEXT('PROXIMA_TENANT_CTX','TENANT_ID')")); + assert!(sql.contains("update_check => TRUE")); + assert!(sql.contains("RETURN '1=0'")); + assert!(sql.contains("PROXIMA_TRUSTED_ASSERTION_VERIFY")); + assert!(sql.contains("statement_types => 'SELECT,INSERT,UPDATE,DELETE'")); + assert!(!sql.contains("CLIENT_IDENTIFIER")); + } + + #[test] + fn oracle_rejects_missing_schema_and_execute_operations() { + let mut policy = oracle_policy(); + policy.resources[0].resource.namespace = None; + assert_eq!(compile_oracle_vpd(&policy).unwrap_err().code, "oracle_schema_required"); + let mut policy = oracle_policy(); + policy.resources[0].operations.push(Operation::Execute); + assert_eq!(compile_oracle_vpd(&policy).unwrap_err().code, "unsupported_operation"); + } +} diff --git a/crates/proxima-engine/src/policy_evidence.rs b/crates/proxima-engine/src/policy_evidence.rs new file mode 100644 index 00000000..9ed466c0 --- /dev/null +++ b/crates/proxima-engine/src/policy_evidence.rs @@ -0,0 +1,599 @@ +//! Signed policy evidence and short-lived runtime-admission envelopes. +//! +//! This module defines cryptographic objects and fail-closed verification rules. +//! A runtime must still call the verifier at its protocol admission boundary and +//! obtain evidence from a trusted native database inspector before using it. + +use crate::security_core::{ + AccessDecision, DatabaseKind, InspectionCompleteness, Operation, ProtectedResource, + ResourceRef, SecurityFinding, SecurityPosture, SECURITY_MODEL_VERSION, +}; +use hmac::{Hmac, Mac}; +use serde::{Deserialize, Serialize}; +use sha2::{Digest, Sha256}; + +type HmacSha256 = Hmac; + +#[derive(Clone, Debug, Eq, PartialEq)] +pub struct EvidenceError { + pub code: &'static str, + pub detail: &'static str, +} + +fn error(code: &'static str, detail: &'static str) -> EvidenceError { + EvidenceError { code, detail } +} + +fn validate_key(key: &[u8]) -> Result<(), EvidenceError> { + if key.len() < 32 { + return Err(error("signing_key_too_short", "Policy evidence and admission keys must contain at least 32 bytes.")); + } + Ok(()) +} + +fn sign_bytes(key: &[u8], payload: &[u8]) -> Result { + validate_key(key)?; + let mut mac = HmacSha256::new_from_slice(key) + .map_err(|_| error("invalid_signing_key", "The HMAC signing key could not be initialized."))?; + mac.update(payload); + Ok(hex::encode(mac.finalize().into_bytes())) +} + +fn verify_bytes(key: &[u8], payload: &[u8], signature: &str) -> Result<(), EvidenceError> { + validate_key(key)?; + let signature = hex::decode(signature) + .map_err(|_| error("invalid_signature_encoding", "The signature is not valid hexadecimal."))?; + let mut mac = HmacSha256::new_from_slice(key) + .map_err(|_| error("invalid_signing_key", "The HMAC verification key could not be initialized."))?; + mac.update(payload); + mac.verify_slice(&signature) + .map_err(|_| error("signature_mismatch", "The signed policy object has been modified or was signed by another authority.")) +} + +#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)] +#[serde(rename_all = "snake_case")] +pub enum EvidenceCheckKind { + OwnTenantAllow, + CrossTenantDeny, + MutationRollback, +} + +#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +pub struct EvidenceCheck { + pub resource: ResourceRef, + pub operation: Operation, + pub kind: EvidenceCheckKind, + pub passed: bool, + pub detail: String, +} + +#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +pub struct PolicyEvidencePayload { + pub model_version: String, + pub policy_id: String, + pub policy_revision: u64, + pub database_kind: DatabaseKind, + pub target_id: String, + pub tenant_id: String, + pub posture: SecurityPosture, + pub inspection: InspectionCompleteness, + pub findings: Vec, + pub protected_resources: Vec, + pub verified_operations: Vec, + pub fingerprint: String, + pub observed_at_unix: i64, + pub checks: Vec, +} + +#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +pub struct SignedPolicyEvidence { + pub payload: PolicyEvidencePayload, + pub signature: String, +} + +#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +pub struct SignedPolicyAdmission { + pub model_version: String, + pub policy_id: String, + pub policy_revision: u64, + pub target_id: String, + pub tenant_id: String, + pub issued_at_unix: i64, + pub expires_at_unix: i64, + pub evidence_sha256: String, + pub signature: String, +} + +#[derive(Clone, Debug, Eq, PartialEq)] +pub struct AdmissionExpectation<'a> { + pub database_kind: DatabaseKind, + pub policy_id: &'a str, + pub policy_revision: u64, + pub target_id: &'a str, + pub tenant_id: &'a str, +} + +#[derive(Clone)] +pub struct PolicyEvidenceAuthority { + evidence_key: Vec, + admission_key: Vec, +} + +impl PolicyEvidenceAuthority { + pub fn new(evidence_key: Vec, admission_key: Vec) -> Result { + validate_key(&evidence_key)?; + validate_key(&admission_key)?; + Ok(Self { evidence_key, admission_key }) + } + + /// Sign a complete inspection result, including failures. Signing evidence + /// does not make an insecure result eligible for runtime admission. + pub fn sign_evidence(&self, payload: PolicyEvidencePayload) -> Result { + validate_evidence_payload(&payload)?; + let bytes = serde_json::to_vec(&payload) + .map_err(|_| error("evidence_serialization_failed", "The evidence payload could not be serialized."))?; + let signature = sign_bytes(&self.evidence_key, &bytes)?; + Ok(SignedPolicyEvidence { payload, signature }) + } + + pub fn verify_evidence(&self, evidence: &SignedPolicyEvidence) -> Result<(), EvidenceError> { + validate_evidence_payload(&evidence.payload)?; + let bytes = serde_json::to_vec(&evidence.payload) + .map_err(|_| error("evidence_serialization_failed", "The evidence payload could not be serialized."))?; + verify_bytes(&self.evidence_key, &bytes, &evidence.signature) + } + + /// Issue a short-lived admission envelope only for complete, clean evidence + /// with successful positive/negative checks and an explicit operation set. + pub fn issue_admission( + &self, + evidence: &SignedPolicyEvidence, + issued_at_unix: i64, + lifetime_seconds: i64, + ) -> Result { + self.verify_evidence(evidence)?; + validate_admission_eligibility(&evidence.payload)?; + if issued_at_unix < evidence.payload.observed_at_unix || issued_at_unix - evidence.payload.observed_at_unix > 60 { + return Err(error("evidence_stale", "Policy evidence must be no more than 60 seconds old when admission is issued.")); + } + if !(1..=60).contains(&lifetime_seconds) { + return Err(error("invalid_admission_lifetime", "Runtime admission envelopes must expire within 1 to 60 seconds.")); + } + let expires_at_unix = issued_at_unix.checked_add(lifetime_seconds) + .ok_or_else(|| error("invalid_admission_lifetime", "The admission expiry timestamp overflowed."))?; + let evidence_bytes = serde_json::to_vec(evidence) + .map_err(|_| error("evidence_serialization_failed", "The signed evidence could not be serialized."))?; + let evidence_sha256 = hex::encode(Sha256::digest(&evidence_bytes)); + let mut admission = SignedPolicyAdmission { + model_version: SECURITY_MODEL_VERSION.into(), + policy_id: evidence.payload.policy_id.clone(), + policy_revision: evidence.payload.policy_revision, + target_id: evidence.payload.target_id.clone(), + tenant_id: evidence.payload.tenant_id.clone(), + issued_at_unix, + expires_at_unix, + evidence_sha256, + signature: String::new(), + }; + admission.signature = sign_bytes(&self.admission_key, &admission_claims_bytes(&admission)?)?; + Ok(admission) + } + + /// Verify the admission signature, exact policy/target/tenant binding, + /// evidence digest, evidence signature and short expiry window. + pub fn verify_admission( + &self, + admission: &SignedPolicyAdmission, + evidence: &SignedPolicyEvidence, + expected: AdmissionExpectation<'_>, + now_unix: i64, + ) -> Result { + self.verify_evidence(evidence)?; + let payload = &evidence.payload; + if admission.model_version != SECURITY_MODEL_VERSION || payload.model_version != SECURITY_MODEL_VERSION { + return Err(error("unsupported_security_model", "The admission or evidence uses an unknown security-model version.")); + } + if payload.database_kind != expected.database_kind { + return Err(error("database_kind_mismatch", "The signed evidence belongs to a different database engine than the requested target.")); + } + if admission.policy_id != expected.policy_id || admission.policy_revision != expected.policy_revision + || payload.policy_id != expected.policy_id || payload.policy_revision != expected.policy_revision { + return Err(error("policy_revision_mismatch", "The admission and evidence do not match the requested policy revision.")); + } + if admission.target_id != expected.target_id || payload.target_id != expected.target_id { + return Err(error("target_mismatch", "The admission and evidence are bound to a different database target.")); + } + if admission.tenant_id != expected.tenant_id || payload.tenant_id != expected.tenant_id { + return Err(error("tenant_mismatch", "The admission and evidence are bound to a different tenant.")); + } + if admission.issued_at_unix > now_unix { + return Err(error("admission_not_yet_valid", "The admission envelope is not valid yet.")); + } + if admission.expires_at_unix <= now_unix { + return Err(error("admission_expired", "The admission envelope has expired.")); + } + let lifetime = admission.expires_at_unix.checked_sub(admission.issued_at_unix) + .ok_or_else(|| error("invalid_admission_lifetime", "The admission timestamps are inconsistent."))?; + if !(1..=60).contains(&lifetime) { + return Err(error("invalid_admission_lifetime", "The admission lifetime exceeds the 60-second maximum.")); + } + if payload.observed_at_unix > admission.issued_at_unix + || admission.issued_at_unix.checked_sub(payload.observed_at_unix).map_or(true, |age| age > 60) { + return Err(error("evidence_stale", "The signed evidence was not fresh when this admission was issued.")); + } + let evidence_bytes = serde_json::to_vec(evidence) + .map_err(|_| error("evidence_serialization_failed", "The signed evidence could not be serialized."))?; + let digest = hex::encode(Sha256::digest(&evidence_bytes)); + if admission.evidence_sha256 != digest { + return Err(error("evidence_digest_mismatch", "The admission does not reference this exact signed evidence record.")); + } + verify_bytes(&self.admission_key, &admission_claims_bytes(admission)?, &admission.signature)?; + validate_admission_eligibility(payload)?; + Ok(AccessDecision::Allow) + } +} + +fn admission_claims_bytes(admission: &SignedPolicyAdmission) -> Result, EvidenceError> { + #[derive(Serialize)] + struct Claims<'a> { + model_version: &'a str, + policy_id: &'a str, + policy_revision: u64, + target_id: &'a str, + tenant_id: &'a str, + issued_at_unix: i64, + expires_at_unix: i64, + evidence_sha256: &'a str, + } + serde_json::to_vec(&Claims { + model_version: &admission.model_version, + policy_id: &admission.policy_id, + policy_revision: admission.policy_revision, + target_id: &admission.target_id, + tenant_id: &admission.tenant_id, + issued_at_unix: admission.issued_at_unix, + expires_at_unix: admission.expires_at_unix, + evidence_sha256: &admission.evidence_sha256, + }).map_err(|_| error("admission_serialization_failed", "The admission claims could not be serialized.")) +} + +fn required_semantic_checks( + resources: &[ProtectedResource], +) -> std::collections::HashSet<(ResourceRef, Operation, EvidenceCheckKind)> { + let mut required = std::collections::HashSet::new(); + for protected in resources { + for operation in &protected.operations { + required.insert((protected.resource.clone(), *operation, EvidenceCheckKind::OwnTenantAllow)); + required.insert((protected.resource.clone(), *operation, EvidenceCheckKind::CrossTenantDeny)); + if matches!(operation, Operation::Create | Operation::Update | Operation::Delete) { + // Mutation probes must use an isolated transaction and prove rollback. + required.insert((protected.resource.clone(), *operation, EvidenceCheckKind::MutationRollback)); + } + } + } + required +} + +fn valid_protected_resource(resource: &ProtectedResource) -> bool { + let reference = &resource.resource; + let mut operations = std::collections::HashSet::new(); + !reference.name.trim().is_empty() + && reference.name.len() <= 256 + && !reference.name.contains('\\0') + && reference.namespace.as_ref().map_or(true, |namespace| { + !namespace.trim().is_empty() && namespace.len() <= 128 && !namespace.contains('\\0') + }) + && !resource.tenant_key.trim().is_empty() + && resource.tenant_key.len() <= 128 + && !resource.tenant_key.contains('\\0') + && !resource.operations.is_empty() + && resource.operations.len() <= 5 + && resource.operations.iter().all(|operation| operations.insert(*operation)) +} + +fn validate_evidence_payload(payload: &PolicyEvidencePayload) -> Result<(), EvidenceError> { + if payload.model_version != SECURITY_MODEL_VERSION || payload.policy_id.trim().is_empty() + || payload.policy_revision == 0 || payload.target_id.trim().is_empty() + || payload.tenant_id.trim().is_empty() + || payload.policy_id.len() > 128 || payload.target_id.len() > 256 || payload.tenant_id.len() > 128 + || payload.policy_id.contains('\\0') || payload.target_id.contains('\\0') || payload.tenant_id.contains('\\0') + || payload.fingerprint.len() != 64 + || hex::decode(&payload.fingerprint).map_or(true, |bytes| bytes.len() != 32) + || payload.observed_at_unix < 0 + || payload.findings.len() > 256 + || payload.protected_resources.is_empty() + || payload.protected_resources.len() > 256 + || payload.protected_resources.iter().any(|resource| !valid_protected_resource(resource)) + || payload.findings.iter().any(|finding| finding.code.trim().is_empty() + || finding.code.len() > 128 || finding.code.contains('\\0') + || finding.detail.len() > 2048 || finding.detail.contains('\\0') + || finding.resource.as_ref().is_some_and(|resource| resource.name.len() > 256 + || resource.name.contains('\\0') + || resource.namespace.as_ref().is_some_and(|namespace| namespace.len() > 128 || namespace.contains('\\0')))) + || payload.checks.len() > 3840 + || payload.checks.iter().any(|check| check.detail.len() > 2048 || check.detail.contains('\\0')) + { + return Err(error("invalid_evidence_payload", "The policy evidence is missing a required identity, revision, resource, fingerprint or timestamp, or contains malformed/bounded-check data.")); + } + + let declared_resources: std::collections::HashSet<_> = payload.protected_resources + .iter().map(|resource| resource.resource.clone()).collect(); + if declared_resources.len() != payload.protected_resources.len() { + return Err(error("duplicate_evidence_resource", "Protected resources in evidence must be unique.")); + } + + let declared_operations: std::collections::HashSet<_> = payload.protected_resources + .iter().flat_map(|resource| resource.operations.iter().copied()).collect(); + let verified_operations: std::collections::HashSet<_> = payload.verified_operations.iter().copied().collect(); + if payload.verified_operations.is_empty() + || payload.verified_operations.len() > 5 + || verified_operations.len() != payload.verified_operations.len() + || verified_operations != declared_operations + { + return Err(error("invalid_evidence_operations", "Verified operations must be unique and exactly match the operations declared for protected resources.")); + } + + let required = required_semantic_checks(&payload.protected_resources); + let mut observed = std::collections::HashSet::with_capacity(payload.checks.len()); + for check in &payload.checks { + let key = (check.resource.clone(), check.operation, check.kind); + if !declared_resources.contains(&check.resource) + || !required.contains(&key) + || !observed.insert(key) + { + return Err(error("invalid_evidence_check_scope", "Each evidence check must name one declared resource, an operation required for that resource, and one unique required probe kind.")); + } + } + Ok(()) +} + +fn validate_admission_eligibility(payload: &PolicyEvidencePayload) -> Result<(), EvidenceError> { + let required = required_semantic_checks(&payload.protected_resources); + let observed: std::collections::HashSet<_> = payload.checks.iter() + .map(|check| (check.resource.clone(), check.operation, check.kind)) + .collect(); + let semantic_coverage_complete = !required.is_empty() + && observed == required + && payload.checks.iter().all(|check| check.passed); + if payload.posture != SecurityPosture::Verified || payload.inspection != InspectionCompleteness::Complete + || !payload.findings.is_empty() || !semantic_coverage_complete + { + return Err(error("evidence_not_admissible", "Admission requires complete verified evidence and passing own-tenant allow, cross-tenant deny, and mutation rollback probes for every declared resource operation.")); + } + Ok(()) +} + +#[cfg(test)] +mod tests { + use super::*; + + fn authority() -> PolicyEvidenceAuthority { + PolicyEvidenceAuthority::new(vec![7; 32], vec![9; 32]).unwrap() + } + + fn protected_resource(name: &str) -> ProtectedResource { + ProtectedResource { + resource: ResourceRef { + namespace: Some("public".into()), + name: name.into(), + kind: crate::security_core::ResourceKind::Table, + }, + tenant_key: "tenant_id".into(), + operations: vec![Operation::Read, Operation::Create, Operation::Update, Operation::Delete], + } + } + + fn semantic_checks(resources: &[ProtectedResource]) -> Vec { + let mut checks = Vec::new(); + for resource in resources { + for operation in &resource.operations { + checks.push(EvidenceCheck { + resource: resource.resource.clone(), + operation: *operation, + kind: EvidenceCheckKind::OwnTenantAllow, + passed: true, + detail: format!("own-tenant {operation:?} probe passed"), + }); + checks.push(EvidenceCheck { + resource: resource.resource.clone(), + operation: *operation, + kind: EvidenceCheckKind::CrossTenantDeny, + passed: true, + detail: format!("cross-tenant {operation:?} probe denied"), + }); + if matches!(operation, Operation::Create | Operation::Update | Operation::Delete) { + checks.push(EvidenceCheck { + resource: resource.resource.clone(), + operation: *operation, + kind: EvidenceCheckKind::MutationRollback, + passed: true, + detail: format!("own-tenant {operation:?} mutation was rolled back"), + }); + } + } + } + checks + } + + fn evidence_payload_with_resources(resources: Vec) -> PolicyEvidencePayload { + let mut verified_operations = Vec::new(); + for resource in &resources { + for operation in &resource.operations { + if !verified_operations.contains(operation) { + verified_operations.push(*operation); + } + } + } + let checks = semantic_checks(&resources); + PolicyEvidencePayload { + model_version: SECURITY_MODEL_VERSION.into(), + policy_id: "tenant-data".into(), + policy_revision: 4, + database_kind: DatabaseKind::PostgreSql, + target_id: "db-prod-01".into(), + tenant_id: "tenant-a".into(), + posture: SecurityPosture::Verified, + inspection: InspectionCompleteness::Complete, + findings: vec![], + protected_resources: resources, + verified_operations, + fingerprint: "a".repeat(64), + observed_at_unix: 1_800_000_000, + checks, + } + } + + fn evidence_payload() -> PolicyEvidencePayload { + evidence_payload_with_resources(vec![protected_resource("orders")]) + } + + fn expected() -> AdmissionExpectation<'static> { + AdmissionExpectation { database_kind: DatabaseKind::PostgreSql, policy_id: "tenant-data", policy_revision: 4, target_id: "db-prod-01", tenant_id: "tenant-a" } + } + + #[test] + fn signed_evidence_and_short_lived_admission_verify() { + let authority = authority(); + let evidence = authority.sign_evidence(evidence_payload()).unwrap(); + let admission = authority.issue_admission(&evidence, 1_800_000_010, 30).unwrap(); + assert_eq!(authority.verify_admission(&admission, &evidence, expected(), 1_800_000_020), Ok(AccessDecision::Allow)); + } + + #[test] + fn modified_evidence_is_rejected() { + let authority = authority(); + let mut evidence = authority.sign_evidence(evidence_payload()).unwrap(); + evidence.payload.fingerprint = "b".repeat(64); + assert_eq!(authority.verify_evidence(&evidence).unwrap_err().code, "signature_mismatch"); + } + + #[test] + fn admission_is_bound_to_exact_policy_target_and_tenant() { + let authority = authority(); + let evidence = authority.sign_evidence(evidence_payload()).unwrap(); + let admission = authority.issue_admission(&evidence, 1_800_000_010, 30).unwrap(); + let wrong_tenant = AdmissionExpectation { tenant_id: "tenant-b", ..expected() }; + assert_eq!(authority.verify_admission(&admission, &evidence, wrong_tenant, 1_800_000_020).unwrap_err().code, "tenant_mismatch"); + } + + #[test] + fn admission_rejects_evidence_for_a_different_database_kind() { + let authority = authority(); + let evidence = authority.sign_evidence(evidence_payload()).unwrap(); + let admission = authority.issue_admission(&evidence, 1_800_000_010, 30).unwrap(); + let wrong_database = AdmissionExpectation { database_kind: DatabaseKind::MySql, ..expected() }; + assert_eq!( + authority.verify_admission(&admission, &evidence, wrong_database, 1_800_000_020).unwrap_err().code, + "database_kind_mismatch" + ); + } + + #[test] + fn expired_and_overlong_admissions_are_rejected() { + let authority = authority(); + let evidence = authority.sign_evidence(evidence_payload()).unwrap(); + assert_eq!(authority.issue_admission(&evidence, 1_800_000_010, 61).unwrap_err().code, "invalid_admission_lifetime"); + let admission = authority.issue_admission(&evidence, 1_800_000_010, 30).unwrap(); + assert_eq!(authority.verify_admission(&admission, &evidence, expected(), 1_800_000_040).unwrap_err().code, "admission_expired"); + } + + #[test] + fn incomplete_or_failing_evidence_cannot_issue_admission() { + let authority = authority(); + let mut payload = evidence_payload(); + payload.inspection = InspectionCompleteness::Incomplete; + let evidence = authority.sign_evidence(payload).unwrap(); + assert_eq!(authority.issue_admission(&evidence, 1_800_000_010, 30).unwrap_err().code, "evidence_not_admissible"); + } + + #[test] + fn admission_requires_positive_and_negative_probes_for_every_operation() { + let authority = authority(); + let mut payload = evidence_payload(); + payload.checks.retain(|check| !(check.kind == EvidenceCheckKind::CrossTenantDeny && check.operation == Operation::Delete)); + let evidence = authority.sign_evidence(payload).unwrap(); + assert_eq!( + authority.issue_admission(&evidence, 1_800_000_010, 30).unwrap_err().code, + "evidence_not_admissible" + ); + } + + #[test] + fn admission_requires_mutation_probe_rollback_evidence() { + let authority = authority(); + let mut payload = evidence_payload(); + payload.checks.retain(|check| !(check.kind == EvidenceCheckKind::MutationRollback && check.operation == Operation::Update)); + let evidence = authority.sign_evidence(payload).unwrap(); + assert_eq!( + authority.issue_admission(&evidence, 1_800_000_010, 30).unwrap_err().code, + "evidence_not_admissible" + ); + } + + #[test] + fn duplicate_resource_scoped_semantic_checks_are_rejected_before_signing() { + let authority = authority(); + let mut payload = evidence_payload(); + payload.checks.push(payload.checks[0].clone()); + assert_eq!(authority.sign_evidence(payload).unwrap_err().code, "invalid_evidence_check_scope"); + } + + #[test] + fn evidence_requires_probe_coverage_for_each_protected_resource() { + let authority = authority(); + let resources = vec![protected_resource("orders"), protected_resource("invoices")]; + let mut payload = evidence_payload_with_resources(resources.clone()); + payload.checks = semantic_checks(&resources[..1]); + let evidence = authority.sign_evidence(payload).unwrap(); + assert_eq!( + authority.issue_admission(&evidence, 1_800_000_010, 30).unwrap_err().code, + "evidence_not_admissible" + ); + } + + #[test] + fn fully_probed_multi_resource_evidence_can_be_admitted() { + let authority = authority(); + let resources = vec![protected_resource("orders"), protected_resource("invoices")]; + let evidence = authority.sign_evidence(evidence_payload_with_resources(resources)).unwrap(); + let admission = authority.issue_admission(&evidence, 1_800_000_010, 30).unwrap(); + assert_eq!( + authority.verify_admission(&admission, &evidence, expected(), 1_800_000_020), + Ok(AccessDecision::Allow) + ); + } + + #[test] + fn duplicate_verified_operations_cannot_be_admitted() { + let authority = authority(); + let mut payload = evidence_payload(); + payload.verified_operations.push(Operation::Read); + assert_eq!(authority.sign_evidence(payload).unwrap_err().code, "invalid_evidence_operations"); + } + + #[test] + fn oversized_evidence_identity_and_findings_are_rejected() { + let authority = authority(); + let mut payload = evidence_payload(); + payload.tenant_id = "t".repeat(129); + assert_eq!(authority.sign_evidence(payload).unwrap_err().code, "invalid_evidence_payload"); + + let mut payload = evidence_payload(); + payload.findings.push(SecurityFinding { + code: "finding".into(), + resource: None, + detail: "d".repeat(2049), + }); + assert_eq!(authority.sign_evidence(payload).unwrap_err().code, "invalid_evidence_payload"); + } + + #[test] + fn short_signing_keys_are_rejected() { + let result = PolicyEvidenceAuthority::new(vec![1; 16], vec![2; 32]); + assert!(matches!(result, Err(error) if error.code == "signing_key_too_short")); + } +} diff --git a/crates/proxima-engine/src/postgres_adapter.rs b/crates/proxima-engine/src/postgres_adapter.rs new file mode 100644 index 00000000..b7d37390 --- /dev/null +++ b/crates/proxima-engine/src/postgres_adapter.rs @@ -0,0 +1,878 @@ +//! Concrete PostgreSQL catalog adapter for the database-neutral Security Core. +//! +//! This adapter performs authenticated, read-only catalog inspection and emits +//! reviewable RLS policy plans. It deliberately does not report semantic +//! verification or production support: catalog state cannot prove that an +//! arbitrary policy enforces the intended tenant boundary. A separate +//! adversarial verifier and approved deployment executor are required before +//! this adapter can be registered as production-complete. + +use crate::database_adapter::{ + AdapterError, AdapterFuture, AdapterTarget, CompiledPolicy, DatabaseAdapter, + DriftReport, DiscoveryRequest, DiscoverySnapshot, DiscoveredResource, InspectionRequest, InspectionSnapshot, NativePolicyChange, + ResourceInspection, +}; +use crate::security_core::{ + AdapterCapabilities, AdapterDescriptor, AdapterMaturity, DatabaseKind, + InspectionCompleteness, Operation, ProtectedResource, ResourceKind, + SecurityFinding, SecurityPosture, TenantSecurityPolicy, VerificationReport, + SECURITY_MODEL_VERSION, +}; +use serde_json::json; +use sha2::{Digest, Sha256}; +use std::{sync::Arc, time::Duration}; +use tokio_postgres::Client; + +/// The connector owns credential retrieval, TLS verification, connection +/// timeouts and connection-task supervision. Production callers must inject a +/// connector configured with certificate and hostname verification enabled. +pub type PostgresConnector = + Arc AdapterFuture<'static, Result> + Send + Sync>; + +pub struct PostgresCatalogAdapter { + target_id: String, + database_name: String, + tenant_role_prefix: String, + connect: PostgresConnector, +} + +impl PostgresCatalogAdapter { + pub fn new( + target_id: impl Into, + database_name: impl Into, + tenant_role_prefix: impl Into, + connect: PostgresConnector, + ) -> Result { + let target_id = target_id.into(); + let database_name = database_name.into(); + let tenant_role_prefix = tenant_role_prefix.into(); + if target_id.trim().is_empty() || database_name.trim().is_empty() + || target_id.len() > 256 || database_name.len() > 63 + || target_id.contains('\0') || database_name.contains('\0') + { + return Err(error("invalid_postgres_target", "A bounded target ID and database name are required.")); + } + if tenant_role_prefix.is_empty() || tenant_role_prefix.len() > 27 + || tenant_role_prefix.contains('\0') + || !tenant_role_prefix.bytes().all(|byte| byte.is_ascii_alphanumeric() || byte == b'_') + || !tenant_role_prefix.as_bytes().first().is_some_and(|byte| byte.is_ascii_alphabetic() || *byte == b'_') + { + return Err(error("invalid_tenant_role_prefix", "The tenant role prefix must be a valid PostgreSQL identifier prefix.")); + } + Ok(Self { target_id, database_name, tenant_role_prefix, connect }) + } + + fn validate_target(&self, target: &AdapterTarget) -> Result<(), AdapterError> { + if target.target_id != self.target_id || target.database_name != self.database_name { + return Err(error("postgres_target_mismatch", "The requested target does not match this adapter's configured target.")); + } + Ok(()) + } + + async fn connect_checked(&self) -> Result { + let client = (self.connect)().await?; + client.batch_execute("SET default_transaction_read_only = on; SET statement_timeout = '10s'; SET lock_timeout = '2s'; SET search_path = pg_catalog, pg_temp;") + .await.map_err(db_error)?; + let row = client.query_one( + "WITH RECURSIVE effective_roles(role_oid) AS (\ + SELECT oid FROM pg_catalog.pg_roles WHERE rolname=current_user \ + UNION \ + SELECT membership.roleid FROM pg_catalog.pg_auth_members membership \ + JOIN effective_roles inherited ON membership.member=inherited.role_oid \ + ) \ + SELECT current_database(), EXISTS( \ + SELECT 1 FROM effective_roles inherited \ + JOIN pg_catalog.pg_roles role ON role.oid=inherited.role_oid \ + WHERE role.rolsuper OR role.rolbypassrls OR role.rolcreaterole OR role.rolcreatedb OR role.rolreplication \ + )", + &[], + ).await.map_err(db_error)?; + let actual_database: String = row.get(0); + if actual_database != self.database_name { + return Err(error("postgres_database_mismatch", "The authenticated connection reached a different database.")); + } + if row.get::<_, bool>(1) { + return Err(error("unsafe_inspection_role", "The inspection role or any role it can inherit/set must not be SUPERUSER, BYPASSRLS, CREATEROLE, CREATEDB or REPLICATION.")); + } + let unsafe_privileges: bool = client.query_one( + "SELECT has_database_privilege(current_user,current_database(),'CREATE') OR EXISTS (SELECT 1 FROM pg_catalog.pg_namespace n WHERE n.nspname NOT IN ('pg_catalog','information_schema') AND n.nspname NOT LIKE 'pg_%' AND has_schema_privilege(current_user,n.oid,'CREATE')) OR EXISTS (SELECT 1 FROM pg_catalog.pg_class c JOIN pg_catalog.pg_namespace n ON n.oid=c.relnamespace WHERE c.relkind IN ('r','p','v','m') AND n.nspname NOT IN ('pg_catalog','information_schema') AND (has_table_privilege(current_user,c.oid,'INSERT') OR has_table_privilege(current_user,c.oid,'UPDATE') OR has_table_privilege(current_user,c.oid,'DELETE') OR has_table_privilege(current_user,c.oid,'TRUNCATE')))", + &[], + ).await.map_err(db_error)?.get(0); + if unsafe_privileges { + return Err(error("unsafe_inspection_role", "The inspection role must be read-only and have no database/schema CREATE or table write privileges.")); + } + Ok(client) + } +} + +impl DatabaseAdapter for PostgresCatalogAdapter { + fn descriptor(&self) -> AdapterDescriptor { + AdapterDescriptor { + kind: DatabaseKind::PostgreSql, + name: "PostgreSQL catalog adapter", + maturity: AdapterMaturity::InDevelopment, + capabilities: AdapterCapabilities { + schema_inspection: true, + policy_generation: true, + drift_detection: true, + ..AdapterCapabilities::default() + }, + status_note: "Concrete read-only catalog inspection and review-only RLS policy generation are implemented. Semantic verification, controlled deployment, drift response and runtime admission are not production-complete.", + } + } + + fn discover<'a>( + &'a self, + request: &'a DiscoveryRequest, + ) -> AdapterFuture<'a, Result> { + Box::pin(async move { + tokio::time::timeout(Duration::from_secs(90), async { + self.validate_target(&request.target)?; + if request.namespace.as_ref().is_some_and(|namespace| { + namespace.trim().is_empty() || namespace.len() > 63 || namespace.contains('\\0') + }) { + return Err(error("invalid_discovery_namespace", "The discovery namespace must be a valid bounded PostgreSQL schema name.")); + } + let client = self.connect_checked().await?; + let rows = client.query( + "SELECT n.nspname, c.relname, CASE WHEN c.relkind IN ('r','p','f') THEN 'table' WHEN c.relkind IN ('v','m') THEN 'view' WHEN c.relkind='S' THEN 'sequence' END AS resource_kind, pg_catalog.pg_get_userbyid(c.relowner), jsonb_build_object('relkind',c.relkind::text,'row_security_enabled',c.relrowsecurity,'row_security_forced',c.relforcerowsecurity,'foreign_table',c.relkind='f','is_partition',c.relispartition,'partition_key',CASE WHEN c.relkind='p' THEN pg_catalog.pg_get_partkeydef(c.oid) ELSE NULL END,'partition_parent',(SELECT parent_namespace.nspname || '.' || parent_relation.relname FROM pg_catalog.pg_inherits inheritance JOIN pg_catalog.pg_class parent_relation ON parent_relation.oid=inheritance.inhparent JOIN pg_catalog.pg_namespace parent_namespace ON parent_namespace.oid=parent_relation.relnamespace WHERE inheritance.inhrelid=c.oid ORDER BY parent_namespace.nspname,parent_relation.relname LIMIT 1),'partition_children',COALESCE((SELECT jsonb_agg(jsonb_build_object('schema',child_namespace.nspname,'name',child_relation.relname,'is_partition',child_relation.relispartition,'partition_bound',pg_catalog.pg_get_expr(child_relation.relpartbound,child_relation.oid),'policy_count',(SELECT count(*) FROM pg_catalog.pg_policy child_policy WHERE child_policy.polrelid=child_relation.oid),'policies',COALESCE((SELECT jsonb_agg(jsonb_build_object('name',child_policy.polname,'command',child_policy.polcmd::text,'permissive',child_policy.polpermissive,'using',pg_catalog.pg_get_expr(child_policy.polqual,child_policy.polrelid),'check',pg_catalog.pg_get_expr(child_policy.polwithcheck,child_policy.polrelid)) ORDER BY child_policy.polname) FROM pg_catalog.pg_policy child_policy WHERE child_policy.polrelid=child_relation.oid),'[]'::jsonb),'row_security_enabled',child_relation.relrowsecurity,'row_security_forced',child_relation.relforcerowsecurity,'acl',COALESCE(child_relation.relacl::text,'')) ORDER BY child_namespace.nspname,child_relation.relname) FROM pg_catalog.pg_inherits inheritance JOIN pg_catalog.pg_class child_relation ON child_relation.oid=inheritance.inhrelid JOIN pg_catalog.pg_namespace child_namespace ON child_namespace.oid=child_relation.relnamespace WHERE inheritance.inhparent=c.oid AND child_relation.relispartition),'[]'::jsonb),'acl',COALESCE(c.relacl::text,''),'columns',COALESCE((SELECT jsonb_agg(jsonb_build_object('name',a.attname,'type',pg_catalog.format_type(a.atttypid,a.atttypmod),'not_null',a.attnotnull,'default',pg_catalog.pg_get_expr(d.adbin,d.adrelid)) ORDER BY a.attnum) FROM pg_catalog.pg_attribute a LEFT JOIN pg_catalog.pg_attrdef d ON d.adrelid=a.attrelid AND d.adnum=a.attnum WHERE a.attrelid=c.oid AND a.attnum>0 AND NOT a.attisdropped),'[]'::jsonb),'policies',COALESCE((SELECT jsonb_agg(jsonb_build_object('name',p.polname,'command',p.polcmd::text,'permissive',p.polpermissive,'using',pg_catalog.pg_get_expr(p.polqual,p.polrelid),'check',pg_catalog.pg_get_expr(p.polwithcheck,p.polrelid),'roles',p.polroles) ORDER BY p.polname) FROM pg_catalog.pg_policy p WHERE p.polrelid=c.oid),'[]'::jsonb),'constraints',COALESCE((SELECT jsonb_agg(jsonb_build_object('name',constraint_row.conname,'type',constraint_row.contype::text,'validated',constraint_row.convalidated,'definition',pg_catalog.pg_get_constraintdef(constraint_row.oid)) ORDER BY constraint_row.conname) FROM pg_catalog.pg_constraint constraint_row WHERE constraint_row.conrelid=c.oid),'[]'::jsonb),'indexes',COALESCE((SELECT jsonb_agg(jsonb_build_object('name',index_class.relname,'valid',index_row.indisvalid,'ready',index_row.indisready,'definition',pg_catalog.pg_get_indexdef(index_row.indexrelid)) ORDER BY index_class.relname) FROM pg_catalog.pg_index index_row JOIN pg_catalog.pg_class index_class ON index_class.oid=index_row.indexrelid WHERE index_row.indrelid=c.oid),'[]'::jsonb),'triggers',COALESCE((SELECT jsonb_agg(jsonb_build_object('name',trigger_row.tgname,'enabled',trigger_row.tgenabled::text,'definition',pg_catalog.pg_get_triggerdef(trigger_row.oid,true)) ORDER BY trigger_row.tgname) FROM pg_catalog.pg_trigger trigger_row WHERE trigger_row.tgrelid=c.oid AND NOT trigger_row.tgisinternal),'[]'::jsonb),'view_definition',CASE WHEN c.relkind IN ('v','m') THEN pg_catalog.pg_get_viewdef(c.oid,true) ELSE NULL END,'view_options',COALESCE(c.reloptions,'{}'::text[])) AS attributes FROM pg_catalog.pg_class c JOIN pg_catalog.pg_namespace n ON n.oid=c.relnamespace WHERE c.relkind IN ('r','p','f','v','m','S') AND n.nspname NOT IN ('pg_catalog','information_schema') AND n.nspname NOT LIKE 'pg_%' AND ($1::text IS NULL OR n.nspname=$1) UNION ALL SELECT n.nspname, p.proname, CASE WHEN p.prokind='p' THEN 'procedure' ELSE 'function' END, pg_catalog.pg_get_userbyid(p.proowner), jsonb_build_object('security_definer',p.prosecdef,'execute_acl',COALESCE(p.proacl::text,''),'identity_arguments',pg_catalog.pg_get_function_identity_arguments(p.oid),'configuration',COALESCE(p.proconfig,'{}'::text[]),'definition',pg_catalog.pg_get_functiondef(p.oid),'volatility',p.provolatile::text,'leakproof',p.proleakproof,'parallel_safety',p.proparallel::text) FROM pg_catalog.pg_proc p JOIN pg_catalog.pg_namespace n ON n.oid=p.pronamespace WHERE p.prokind IN ('f','p') AND n.nspname NOT IN ('pg_catalog','information_schema') AND n.nspname NOT LIKE 'pg_%' AND ($1::text IS NULL OR n.nspname=$1) ORDER BY 1,2,3", + &[&request.namespace], + ).await.map_err(db_error)?; + let mut resources = Vec::with_capacity(rows.len()); + for row in rows { + let kind: String = row.get(2); + let kind = match kind.as_str() { + "table" => ResourceKind::Table, + "view" => ResourceKind::View, + "sequence" => ResourceKind::Sequence, + "procedure" => ResourceKind::Procedure, + "function" => ResourceKind::Function, + _ => return Err(error("unknown_discovered_resource_kind", "PostgreSQL returned an unsupported resource kind during discovery.")), + }; + resources.push(DiscoveredResource { + namespace: Some(row.get(0)), + name: row.get(1), + kind, + owner: Some(row.get(3)), + attributes: row.get(4), + }); + } + let clock = client.query_one( + "SELECT to_char(clock_timestamp() AT TIME ZONE 'UTC', 'YYYY-MM-DD\"T\"HH24:MI:SS.US\"Z\"')", + &[], + ).await.map_err(db_error)?; + let observed_at: String = clock.get(0); + let target_row = client.query_one( + "SELECT current_database(), current_user, current_setting('server_version'), current_setting('server_version_num')", + &[], + ).await.map_err(db_error)?; + let roles = client.query( + "SELECT rolname,rolsuper,rolbypassrls,rolcreaterole,rolcreatedb,rolreplication,rolinherit,rolcanlogin,rolconnlimit FROM pg_catalog.pg_roles ORDER BY rolname", + &[], + ).await.map_err(db_error)?; + let role_memberships = client.query( + "SELECT member_role.rolname AS member_role,granted_role.rolname AS granted_role,membership.admin_option FROM pg_catalog.pg_auth_members membership JOIN pg_catalog.pg_roles member_role ON member_role.oid=membership.member JOIN pg_catalog.pg_roles granted_role ON granted_role.oid=membership.roleid ORDER BY member_role.rolname,granted_role.rolname", + &[], + ).await.map_err(db_error)?; + let database_privileges = client.query( + "SELECT database_info.datname,pg_catalog.pg_get_userbyid(database_info.datdba) AS owner,COALESCE(database_info.datacl::text,'') AS acl,database_info.datallowconn,database_info.datistemplate FROM pg_catalog.pg_database database_info ORDER BY database_info.datname", + &[], + ).await.map_err(db_error)?; + let schema_privileges = client.query( + "SELECT namespace.nspname,pg_catalog.pg_get_userbyid(namespace.nspowner) AS owner,COALESCE(namespace.nspacl::text,'') AS acl FROM pg_catalog.pg_namespace namespace WHERE namespace.nspname NOT IN ('pg_catalog','information_schema') AND namespace.nspname NOT LIKE 'pg_%' ORDER BY namespace.nspname", + &[], + ).await.map_err(db_error)?; + let default_privileges = client.query( + "SELECT pg_catalog.pg_get_userbyid(default_acl.defaclrole) AS owner_role,COALESCE(namespace.nspname,'') AS schema_name,default_acl.defaclobjtype::text AS object_type,COALESCE(default_acl.defaclacl::text,'') AS acl FROM pg_catalog.pg_default_acl default_acl LEFT JOIN pg_catalog.pg_namespace namespace ON namespace.oid=default_acl.defaclnamespace ORDER BY 1,2,3", + &[], + ).await.map_err(db_error)?; + let target_attributes = json!({ + "database": target_row.get::<_, String>(0), + "authenticated_role": target_row.get::<_, String>(1), + "server_version": target_row.get::<_, String>(2), + "server_version_num": target_row.get::<_, String>(3), + "inspection_role_is_read_only": true, + "roles": roles.iter().map(|role| json!({ + "name": role.get::<_, String>(0), + "superuser": role.get::<_, bool>(1), + "bypass_rls": role.get::<_, bool>(2), + "create_role": role.get::<_, bool>(3), + "create_database": role.get::<_, bool>(4), + "replication": role.get::<_, bool>(5), + "inherit": role.get::<_, bool>(6), + "can_login": role.get::<_, bool>(7), + "connection_limit": role.get::<_, i32>(8) + })).collect::>(), + "role_memberships": role_memberships.iter().map(|membership| json!({ + "member_role": membership.get::<_, String>(0), + "granted_role": membership.get::<_, String>(1), + "admin_option": membership.get::<_, bool>(2) + })).collect::>(), + "database_privileges": database_privileges.iter().map(|database| json!({ + "database": database.get::<_, String>(0), + "owner": database.get::<_, String>(1), + "acl": database.get::<_, String>(2), + "allow_connections": database.get::<_, bool>(3), + "is_template": database.get::<_, bool>(4) + })).collect::>(), + "schema_privileges": schema_privileges.iter().map(|schema| json!({ + "schema": schema.get::<_, String>(0), + "owner": schema.get::<_, String>(1), + "acl": schema.get::<_, String>(2) + })).collect::>(), + "default_privileges": default_privileges.iter().map(|default_acl| json!({ + "owner_role": default_acl.get::<_, String>(0), + "schema": default_acl.get::<_, String>(1), + "object_type": default_acl.get::<_, String>(2), + "acl": default_acl.get::<_, String>(3) + })).collect::>() + }); + let fingerprint = sha256(&serde_json::to_vec(&json!({"target_id":self.target_id,"database_name":self.database_name,"target":target_attributes,"resources":resources})) + .map_err(|_| error("fingerprint_serialization_failed", "Could not serialize discovered PostgreSQL resources."))?); + Ok(DiscoverySnapshot { + database_kind: DatabaseKind::PostgreSql, + target: request.target.clone(), + completeness: InspectionCompleteness::Complete, + target_attributes, + resources, + findings: Vec::new(), + fingerprint: Some(fingerprint), + observed_at, + }) + }) + .await + .map_err(|_| AdapterError { + code: "postgres_catalog_timeout".into(), + detail: "PostgreSQL catalog discovery exceeded the ninety-second operation deadline.".into(), + retryable: true, + })? + }) + } + + fn inspect<'a>( + &'a self, + request: &'a InspectionRequest, + ) -> AdapterFuture<'a, Result> { + Box::pin(async move { + self.validate_target(&request.target)?; + request.policy.validate().map_err(|_| error("invalid_policy", "The canonical tenant policy failed validation."))?; + let client = self.connect_checked().await?; + let mut resources = Vec::with_capacity(request.policy.resources.len()); + let mut snapshot_findings = Vec::new(); + let mut fingerprint_rows = Vec::new(); + let mut complete = true; + + for protected in &request.policy.resources { + if protected.resource.kind != ResourceKind::Table { + complete = false; + snapshot_findings.push(finding("unsupported_resource_kind", &protected.resource, "The PostgreSQL catalog adapter currently inspects ordinary tables only.")); + continue; + } + let schema = protected.resource.namespace.as_deref().unwrap_or("public"); + let row = client.query_opt( + "SELECT c.relrowsecurity, c.relforcerowsecurity, (WITH RECURSIVE owner_roles(role_oid) AS (SELECT c.relowner UNION SELECT am.roleid FROM pg_catalog.pg_auth_members am JOIN owner_roles parent ON am.member=parent.role_oid) SELECT EXISTS(SELECT 1 FROM owner_roles roles JOIN pg_catalog.pg_roles inherited ON inherited.oid=roles.role_oid WHERE inherited.rolsuper OR inherited.rolbypassrls)), (SELECT count(*)::bigint FROM pg_catalog.pg_policies p WHERE p.schemaname=n.nspname AND p.tablename=c.relname), c.relkind::text, COALESCE((SELECT string_agg(concat_ws(':',p.polname,p.polcmd,p.polpermissive::text,COALESCE(pg_catalog.pg_get_expr(p.polqual,p.polrelid),''),COALESCE(pg_catalog.pg_get_expr(p.polwithcheck,p.polrelid),''),COALESCE((SELECT string_agg(COALESCE(role_name.rolname,'PUBLIC'),',' ORDER BY COALESCE(role_name.rolname,'PUBLIC')) FROM unnest(p.polroles) policy_role(role_oid) LEFT JOIN pg_catalog.pg_roles role_name ON role_name.oid=policy_role.role_oid),'')), E'\\n' ORDER BY p.polname) FROM pg_catalog.pg_policy p WHERE p.polrelid=c.oid),''), COALESCE(c.relacl::text,''), pg_catalog.pg_get_userbyid(c.relowner), EXISTS(SELECT 1 FROM aclexplode(COALESCE(c.relacl,acldefault(CASE WHEN c.relkind='S' THEN 'S'::\"char\" ELSE 'r'::\"char\" END,c.relowner))) acl WHERE acl.grantee<>0 AND EXISTS(WITH RECURSIVE granted_roles(role_oid) AS (SELECT acl.grantee UNION SELECT am.roleid FROM pg_catalog.pg_auth_members am JOIN granted_roles parent ON am.member=parent.role_oid) SELECT 1 FROM granted_roles granted JOIN pg_catalog.pg_roles role ON role.oid=granted.role_oid WHERE role.rolsuper OR role.rolbypassrls)), EXISTS(SELECT 1 FROM aclexplode(COALESCE(c.relacl,acldefault(CASE WHEN c.relkind='S' THEN 'S'::\"char\" ELSE 'r'::\"char\" END,c.relowner))) acl WHERE acl.grantee=0 AND acl.privilege_type='SELECT'), EXISTS(SELECT 1 FROM aclexplode(COALESCE(c.relacl,acldefault(CASE WHEN c.relkind='S' THEN 'S'::\"char\" ELSE 'r'::\"char\" END,c.relowner))) acl WHERE acl.grantee=0 AND acl.privilege_type IN ('INSERT','UPDATE','DELETE','TRUNCATE')), EXISTS(SELECT 1 FROM pg_catalog.pg_attribute tenant_column WHERE tenant_column.attrelid=c.oid AND tenant_column.attname::text=$3 AND tenant_column.attnum>0 AND NOT tenant_column.attisdropped), COALESCE((SELECT tenant_column.attnotnull FROM pg_catalog.pg_attribute tenant_column WHERE tenant_column.attrelid=c.oid AND tenant_column.attname::text=$3 AND tenant_column.attnum>0 AND NOT tenant_column.attisdropped),false),COALESCE((SELECT jsonb_agg(jsonb_build_object('schema',child_namespace.nspname,'name',child_relation.relname,'is_partition',child_relation.relispartition,'partition_bound',pg_catalog.pg_get_expr(child_relation.relpartbound,child_relation.oid),'policy_count',(SELECT count(*) FROM pg_catalog.pg_policy child_policy WHERE child_policy.polrelid=child_relation.oid),'policies',COALESCE((SELECT jsonb_agg(jsonb_build_object('name',child_policy.polname,'command',child_policy.polcmd::text,'using',pg_catalog.pg_get_expr(child_policy.polqual,child_policy.polrelid),'check',pg_catalog.pg_get_expr(child_policy.polwithcheck,child_policy.polrelid)) ORDER BY child_policy.polname) FROM pg_catalog.pg_policy child_policy WHERE child_policy.polrelid=child_relation.oid),'[]'::jsonb),'row_security_enabled',child_relation.relrowsecurity,'row_security_forced',child_relation.relforcerowsecurity,'acl',COALESCE(child_relation.relacl::text,'')) ORDER BY child_namespace.nspname,child_relation.relname) FROM pg_catalog.pg_inherits inheritance JOIN pg_catalog.pg_class child_relation ON child_relation.oid=inheritance.inhrelid JOIN pg_catalog.pg_namespace child_namespace ON child_namespace.oid=child_relation.relnamespace WHERE inheritance.inhparent=c.oid AND child_relation.relispartition),'[]'::jsonb) FROM pg_catalog.pg_class c JOIN pg_catalog.pg_namespace n ON n.oid=c.relnamespace WHERE n.nspname=$1 AND c.relname=$2 AND c.relkind IN ('r','p')", + &[&schema, &protected.resource.name.as_str(), &protected.tenant_key.as_str()], + ).await.map_err(db_error)?; + + let Some(row) = row else { + complete = false; + snapshot_findings.push(finding("protected_resource_not_found", &protected.resource, "The requested relation was not found as a table or partitioned table.")); + resources.push(ResourceInspection { + resource: protected.clone(), + completeness: InspectionCompleteness::Incomplete, + posture: SecurityPosture::Blocked, + verified_operations: Vec::new(), + findings: vec![finding("protected_resource_not_found", &protected.resource, "The requested relation was not found.")], + fingerprint: None, + }); + continue; + }; + + let rls_enabled: bool = row.get(0); + let rls_forced: bool = row.get(1); + let owner_bypasses_rls: bool = row.get(2); + let policy_count: i64 = row.get(3); + let relkind: String = row.get(4); + let policy_definitions: String = row.get(5); + let relation_acl: String = row.get(6); + let owner_name: String = row.get(7); + let bypass_grantee: bool = row.get(8); + let public_select: bool = row.get(9); + let public_write: bool = row.get(10); + let tenant_column_exists: bool = row.get(11); + let tenant_column_not_null: bool = row.get(12); + let partition_children: serde_json::Value = row.get(13); + let unsafe_dependent_views: i64 = client.query_one( + "WITH RECURSIVE target_relation(oid) AS (SELECT c.oid FROM pg_catalog.pg_class c JOIN pg_catalog.pg_namespace n ON n.oid=c.relnamespace WHERE n.nspname=$1 AND c.relname=$2), dependent_views(view_oid) AS (SELECT rewrite.ev_class FROM pg_catalog.pg_depend dependency JOIN pg_catalog.pg_rewrite rewrite ON dependency.classid='pg_rewrite'::regclass AND dependency.objid=rewrite.oid CROSS JOIN target_relation target WHERE dependency.refclassid='pg_class'::regclass AND dependency.refobjid=target.oid UNION SELECT rewrite.ev_class FROM pg_catalog.pg_depend dependency JOIN pg_catalog.pg_rewrite rewrite ON dependency.classid='pg_rewrite'::regclass AND dependency.objid=rewrite.oid JOIN dependent_views parent ON dependency.refobjid=parent.view_oid WHERE dependency.refclassid='pg_class'::regclass) SELECT count(*)::bigint FROM dependent_views dependency JOIN pg_catalog.pg_class view_relation ON view_relation.oid=dependency.view_oid JOIN pg_catalog.pg_namespace view_namespace ON view_namespace.oid=view_relation.relnamespace WHERE view_relation.relkind IN ('v','m') AND view_namespace.nspname NOT IN ('pg_catalog','information_schema') AND view_namespace.nspname NOT LIKE 'pg_%' AND (view_relation.relkind='m' OR NOT COALESCE(view_relation.reloptions @> ARRAY['security_invoker=true'],false))", + &[&schema, &protected.resource.name.as_str()], + ).await.map_err(db_error)?.get(0); + let security_definer_routines: i64 = client.query_one( + "SELECT count(*)::bigint FROM pg_catalog.pg_proc routine JOIN pg_catalog.pg_namespace routine_schema ON routine_schema.oid=routine.pronamespace WHERE routine.prosecdef AND routine.prokind IN ('f','p') AND routine_schema.nspname NOT IN ('pg_catalog','information_schema') AND routine_schema.nspname NOT LIKE 'pg_%'", + &[], + ).await.map_err(db_error)?.get(0); + + let mut findings = Vec::new(); + if partition_children.as_array().is_some_and(|children| children.iter().any(|child| child["row_security_enabled"].as_bool() != Some(true))) { + findings.push(finding("partition_child_without_rls", &protected.resource, "One or more directly addressable PostgreSQL partitions do not have row-level security enabled; parent-table policies do not protect queries that address a partition directly.")); + } + if partition_children.as_array().is_some_and(|children| children.iter().any(|child| child["row_security_enabled"].as_bool() == Some(true) && child["row_security_forced"].as_bool() != Some(true))) { + findings.push(finding("partition_child_rls_not_forced", &protected.resource, "One or more PostgreSQL partitions have RLS enabled but not forced; table owners may bypass their policies when accessing the partition directly.")); + } + if partition_children.as_array().is_some_and(|children| children.iter().any(|child| child["row_security_enabled"].as_bool() == Some(true) && child["policy_count"].as_i64().unwrap_or(0) == 0)) { + findings.push(finding("partition_child_policy_missing", &protected.resource, "One or more directly addressable PostgreSQL partitions enable RLS but have no local policies; parent policies do not protect direct child access.")); + } + if partition_children.as_array().is_some_and(|children| children.iter().any(|child| { + child["policies"].as_array().is_some_and(|policies| !policies.is_empty() && !policies.iter().all(|policy| { + policy["using"].as_str().is_some_and(|expression| expression.contains(protected.tenant_key.as_str())) + || policy["check"].as_str().is_some_and(|expression| expression.contains(protected.tenant_key.as_str())) + })) + })) { + findings.push(finding("partition_child_tenant_policy_unverified", &protected.resource, "One or more PostgreSQL partition-local policy expressions do not visibly reference the registered tenant key; verify the partition's tenant predicate independently.")); + } + if unsafe_dependent_views > 0 { findings.push(finding("unsafe_dependent_view", &protected.resource, "A dependent view is not security-invoker or is materialized; it requires separate protection and review.")); } + if security_definer_routines > 0 { findings.push(finding("security_definer_routine_requires_review", &protected.resource, "Application SECURITY DEFINER routines exist and require explicit privilege and tenant-boundary review.")); } + if !rls_enabled { findings.push(finding("rls_disabled", &protected.resource, "Row-level security is disabled.")); } + if !rls_forced { findings.push(finding("rls_not_forced", &protected.resource, "Table-owner access is not forced through row-level security.")); } + if owner_bypasses_rls { findings.push(finding("owner_bypasses_rls", &protected.resource, "The relation owner or an inherited role has SUPERUSER or BYPASSRLS.")); } + if bypass_grantee { findings.push(finding("bypass_role_has_table_grant", &protected.resource, "A table grantee or inherited role has SUPERUSER or BYPASSRLS.")); } + if public_select || public_write { findings.push(finding("public_table_grant", &protected.resource, "PUBLIC has direct SELECT or write privileges on this relation.")); } + if !tenant_column_exists { findings.push(finding("tenant_ownership_column_missing", &protected.resource, "The policy's tenant ownership column does not exist on this relation.")); } + else if !tenant_column_not_null { findings.push(finding("tenant_ownership_column_nullable", &protected.resource, "The policy's tenant ownership column permits NULL values.")); } + if policy_count == 0 { findings.push(finding("no_native_policies", &protected.resource, "No PostgreSQL row-security policies are attached to this relation.")); } + if relkind == "p" { findings.push(finding("partitioned_relation_requires_child_audit", &protected.resource, "Partitioned tables require independent inspection of every directly addressable child partition.")); } + // A policy count is not proof of tenant semantics. Never turn + // catalog presence into verified operations or an allow result. + findings.push(finding("semantic_verification_required", &protected.resource, "Native policy expressions and cross-tenant allow/deny behavior have not been independently verified.")); + let state = json!({ + "schema": schema, "table": protected.resource.name, "rls_enabled": rls_enabled, + "rls_forced": rls_forced, "owner_bypasses_rls": owner_bypasses_rls, + "policy_count": policy_count, "policy_definitions": policy_definitions, + "relation_acl": relation_acl, "owner_name": owner_name, + "bypass_grantee": bypass_grantee, "public_select": public_select, + "public_write": public_write, "tenant_column_exists": tenant_column_exists, + "tenant_column_not_null": tenant_column_not_null, "tenant_column": protected.tenant_key, + "unsafe_dependent_views": unsafe_dependent_views, + "security_definer_routines": security_definer_routines, + "relkind": relkind + }); + let digest = sha256(&serde_json::to_vec(&state).map_err(|_| error("fingerprint_serialization_failed", "Could not serialize PostgreSQL catalog state."))?); + fingerprint_rows.push(state); + resources.push(ResourceInspection { + resource: protected.clone(), + completeness: InspectionCompleteness::Complete, + posture: if rls_enabled && rls_forced && !owner_bypasses_rls && policy_count > 0 { SecurityPosture::NeedsAttention } else { SecurityPosture::Blocked }, + verified_operations: Vec::new(), + findings, + fingerprint: Some(digest), + }); + } + + let clock = client.query_one("SELECT to_char(clock_timestamp() AT TIME ZONE 'UTC', 'YYYY-MM-DD\"T\"HH24:MI:SS.US\"Z\"')", &[]).await.map_err(db_error)?; + let observed_at: String = clock.get(0); + let fingerprint = sha256(&serde_json::to_vec(&json!({ + "target_id": self.target_id, + "database_name": self.database_name, + "resources": fingerprint_rows + })).map_err(|_| error("fingerprint_serialization_failed", "Could not serialize PostgreSQL catalog state."))?); + snapshot_findings.push(SecurityFinding { + code: "semantic_verification_not_performed".into(), + resource: None, + detail: "Read-only catalog inspection is not sufficient to authorize tenant traffic. Run independent positive and cross-tenant negative probes.".into(), + }); + Ok(InspectionSnapshot { + database_kind: DatabaseKind::PostgreSql, + target: request.target.clone(), + completeness: if complete { InspectionCompleteness::Complete } else { InspectionCompleteness::Incomplete }, + posture: SecurityPosture::NeedsAttention, + resources, + findings: snapshot_findings, + fingerprint: Some(fingerprint), + observed_at, + }) + }) + } + + fn compile_policy(&self, policy: &TenantSecurityPolicy) -> Result { + policy.validate().map_err(|_| error("invalid_policy", "The canonical tenant policy failed validation."))?; + let mut changes = Vec::with_capacity(policy.resources.len()); + for protected in &policy.resources { + if protected.resource.kind != ResourceKind::Table { + return Err(error("unsupported_resource_kind", "PostgreSQL RLS plan generation currently supports table resources only.")); + } + let schema = protected.resource.namespace.as_deref().unwrap_or("public"); + let relation = format!("{}.{}", quote_ident(schema), quote_ident(&protected.resource.name)); + let tenant_column = quote_ident(&protected.tenant_key); + // The Engine binds tenant identity to a dedicated PostgreSQL login + // role at startup. Derive the tenant claim from that immutable role + // identity rather than a session GUC: session GUC state is not safe + // to rely on behind transaction-pooling proxies. + let role_prefix = quote_literal(&self.tenant_role_prefix); + let tenant_expression = format!( + "pg_catalog.left(current_user, pg_catalog.char_length({role_prefix})) = {role_prefix} AND pg_catalog.replace(({tenant_column})::text, '-', '_') = pg_catalog.substring(current_user FROM pg_catalog.char_length({role_prefix}) + 1)" + ); + let mut statements = vec![ + format!("ALTER TABLE {relation} ENABLE ROW LEVEL SECURITY"), + format!("ALTER TABLE {relation} FORCE ROW LEVEL SECURITY"), + ]; + for operation in &protected.operations { + let command = match operation { + Operation::Read => "SELECT", + Operation::Create => "INSERT", + Operation::Update => "UPDATE", + Operation::Delete => "DELETE", + Operation::Execute => return Err(error("unsupported_operation", "EXECUTE is not a table-level PostgreSQL RLS operation.")), + }; + let seed = format!("{}:{}:{}:{}:{:?}", policy.policy_id, policy.revision, schema, protected.resource.name, operation); + let digest = sha256(seed.as_bytes()); + let suffix = &digest[..16]; + let policy_name = format!("proxima_{}_{}", safe_name(&policy.policy_id), suffix); + let statement = match operation { + Operation::Read | Operation::Delete => format!("CREATE POLICY {} ON {} AS RESTRICTIVE FOR {} TO PUBLIC USING ({})", quote_ident(&policy_name), relation, command, tenant_expression), + Operation::Create => format!("CREATE POLICY {} ON {} AS RESTRICTIVE FOR {} TO PUBLIC WITH CHECK ({})", quote_ident(&policy_name), relation, command, tenant_expression), + Operation::Update => format!("CREATE POLICY {} ON {} AS RESTRICTIVE FOR {} TO PUBLIC USING ({}) WITH CHECK ({})", quote_ident(&policy_name), relation, command, tenant_expression, tenant_expression), + Operation::Execute => unreachable!(), + }; + statements.push(statement); + } + changes.push(NativePolicyChange { + resource: protected.clone(), + action: "review_only_create_restrictive_rls_policies".into(), + definition: json!({ + "statements": statements, + "preconditions": [ + "Apply only after independent review and explicit approval.", + "Enable and FORCE ROW LEVEL SECURITY on the relation.", + "Ensure the application role cannot own the table and has no BYPASSRLS or SUPERUSER membership.", + "Ensure each requested command has a reviewed permissive baseline policy; restrictive policies intersect with permissive policies and otherwise deny all rows.", + "Route each authenticated tenant through the Engine's dedicated role prefix plus normalized tenant ID; never share a tenant login role across tenant identities.", + "Verify every operation with positive own-tenant and negative cross-tenant probes.", + "Inspect and protect every directly addressable partition and view." + ], + "policy_id": policy.policy_id, + "revision": policy.revision, + "tenant_identity_claim": policy.tenant_identity_claim, + "tenant_setting": "proxima.tenant_id", + "execution": "not_executed" + }), + }); + } + Ok(CompiledPolicy { + database_kind: DatabaseKind::PostgreSql, + policy_id: policy.policy_id.clone(), + revision: policy.revision, + changes, + requires_approval: true, + }) + } + + fn verify<'a>( + &'a self, + _policy: &'a TenantSecurityPolicy, + snapshot: &'a InspectionSnapshot, + ) -> AdapterFuture<'a, Result> { + Box::pin(async move { + if snapshot.database_kind != DatabaseKind::PostgreSql + || snapshot.target.target_id != self.target_id + || snapshot.target.database_name != self.database_name + { + return Err(error("postgres_snapshot_target_mismatch", "The verification snapshot does not belong to this PostgreSQL adapter target.")); + } + _policy.validate().map_err(|_| error("invalid_policy", "The canonical tenant policy failed validation."))?; + let mut findings = snapshot.findings.clone(); + findings.push(SecurityFinding { + code: "independent_tenant_probes_required".into(), + resource: None, + detail: "The adapter does not claim semantic verification until authenticated tenant sessions prove own-tenant access and deny cross-tenant read/write operations.".into(), + }); + Ok(VerificationReport { + model_version: SECURITY_MODEL_VERSION.into(), + posture: SecurityPosture::NeedsAttention, + inspection: snapshot.completeness, + findings, + }) + }) + } + + fn detect_drift<'a>( + &'a self, + target: &'a AdapterTarget, + previous_fingerprint: Option<&'a str>, + ) -> AdapterFuture<'a, Result> { + Box::pin(async move { + self.validate_target(target)?; + if previous_fingerprint.is_some_and(|value| value.len() != 64 || !value.bytes().all(|b| b.is_ascii_hexdigit())) { + return Err(error("invalid_previous_fingerprint", "The previous catalog fingerprint must be a SHA-256 hex digest.")); + } + let client = self.connect_checked().await?; + let rows = client.query( + "SELECT n.nspname, c.relname, pg_catalog.pg_get_userbyid(c.relowner), c.relrowsecurity, c.relforcerowsecurity, COALESCE((SELECT string_agg(concat_ws(':',p.polname,p.polcmd,p.polpermissive::text,COALESCE(pg_catalog.pg_get_expr(p.polqual,p.polrelid),''),COALESCE(pg_catalog.pg_get_expr(p.polwithcheck,p.polrelid),''),COALESCE((SELECT string_agg(COALESCE(role_name.rolname,'PUBLIC'),',' ORDER BY COALESCE(role_name.rolname,'PUBLIC')) FROM unnest(p.polroles) policy_role(role_oid) LEFT JOIN pg_catalog.pg_roles role_name ON role_name.oid=policy_role.role_oid),'')), E'\\n' ORDER BY p.polname) FROM pg_catalog.pg_policy p WHERE p.polrelid=c.oid), ''), COALESCE(c.relacl::text,''), EXISTS(SELECT 1 FROM aclexplode(COALESCE(c.relacl,acldefault(CASE WHEN c.relkind='S' THEN 'S'::\"char\" ELSE 'r'::\"char\" END,c.relowner))) acl WHERE acl.grantee<>0 AND EXISTS(WITH RECURSIVE granted_roles(role_oid) AS (SELECT acl.grantee UNION SELECT am.roleid FROM pg_catalog.pg_auth_members am JOIN granted_roles parent ON am.member=parent.role_oid) SELECT 1 FROM granted_roles granted JOIN pg_catalog.pg_roles role ON role.oid=granted.role_oid WHERE role.rolsuper OR role.rolbypassrls)), (WITH RECURSIVE owner_roles(role_oid) AS (SELECT c.relowner UNION SELECT am.roleid FROM pg_catalog.pg_auth_members am JOIN owner_roles parent ON am.member=parent.role_oid) SELECT EXISTS(SELECT 1 FROM owner_roles roles JOIN pg_catalog.pg_roles inherited ON inherited.oid=roles.role_oid WHERE inherited.rolsuper OR inherited.rolbypassrls)) FROM pg_catalog.pg_class c JOIN pg_catalog.pg_namespace n ON n.oid=c.relnamespace WHERE c.relkind IN ('r','p','S') AND n.nspname NOT IN ('pg_catalog','information_schema') AND n.nspname NOT LIKE 'pg_%' ORDER BY n.nspname,c.relname", + &[], + ).await.map_err(db_error)?; + let mut state: Vec = rows.into_iter().map(|row| json!({ + "kind": "relation", + "schema": row.get::<_, String>(0), "table": row.get::<_, String>(1), + "owner": row.get::<_, String>(2), "rls_enabled": row.get::<_, bool>(3), + "rls_forced": row.get::<_, bool>(4), "policies": row.get::<_, String>(5), + "acl": row.get::<_, String>(6), "bypass_grantee": row.get::<_, bool>(7), + "owner_bypasses_rls": row.get::<_, bool>(8) + })).collect(); + + // A relation-only fingerprint misses security changes that alter + // effective access without changing a table's ACL or RLS policy: + // role attributes, inherited memberships, and persistent role + // settings can all widen access or disable row security. + let role_rows = client.query( + "SELECT r.rolname, r.rolsuper, r.rolbypassrls, r.rolcreaterole, r.rolcreatedb, r.rolreplication, r.rolcanlogin, r.rolinherit, r.rolvaliduntil::text, COALESCE(d.datname, 'ALL_DATABASES'), COALESCE(s.setconfig::text, '') FROM pg_catalog.pg_roles r LEFT JOIN pg_catalog.pg_db_role_setting s ON s.setrole=r.oid LEFT JOIN pg_catalog.pg_database d ON d.oid=s.setdatabase ORDER BY r.rolname, d.datname", + &[], + ).await.map_err(db_error)?; + state.extend(role_rows.into_iter().map(|row| json!({ + "kind": "role", + "name": row.get::<_, String>(0), + "superuser": row.get::<_, bool>(1), + "bypass_rls": row.get::<_, bool>(2), + "create_role": row.get::<_, bool>(3), + "create_database": row.get::<_, bool>(4), + "replication": row.get::<_, bool>(5), + "can_login": row.get::<_, bool>(6), + "inherit": row.get::<_, bool>(7), + "valid_until": row.get::<_, Option>(8), + "settings_database": row.get::<_, String>(9), + "settings": row.get::<_, String>(10) + }))); + + let membership_rows = client.query( + "SELECT granted.rolname, member.rolname, grantor.rolname, membership.admin_option FROM pg_catalog.pg_auth_members membership JOIN pg_catalog.pg_roles granted ON granted.oid=membership.roleid JOIN pg_catalog.pg_roles member ON member.oid=membership.member JOIN pg_catalog.pg_roles grantor ON grantor.oid=membership.grantor ORDER BY granted.rolname, member.rolname, grantor.rolname", + &[], + ).await.map_err(db_error)?; + state.extend(membership_rows.into_iter().map(|row| json!({ + "kind": "role_membership", + "granted_role": row.get::<_, String>(0), + "member_role": row.get::<_, String>(1), + "grantor": row.get::<_, String>(2), + "admin_option": row.get::<_, bool>(3) + }))); + + let routine_rows = client.query( + "SELECT n.nspname, p.proname, pg_catalog.pg_get_userbyid(p.proowner), p.prosecdef, COALESCE(array_to_string(p.proconfig, ','), ''), pg_catalog.pg_get_function_identity_arguments(p.oid), pg_catalog.pg_get_functiondef(p.oid), COALESCE(p.proacl::text,''), p.prokind::text FROM pg_catalog.pg_proc p JOIN pg_catalog.pg_namespace n ON n.oid=p.pronamespace WHERE p.prokind IN ('f','p') AND n.nspname NOT IN ('pg_catalog','information_schema') AND n.nspname NOT LIKE 'pg_%' ORDER BY n.nspname,p.proname,pg_catalog.pg_get_function_identity_arguments(p.oid)", + &[], + ).await.map_err(db_error)?; + state.extend(routine_rows.into_iter().map(|row| json!({ + "kind": "application_routine", + "schema": row.get::<_, String>(0), + "name": row.get::<_, String>(1), + "owner": row.get::<_, String>(2), + "security_definer": row.get::<_, bool>(3), + "settings": row.get::<_, String>(4), + "arguments": row.get::<_, String>(5), + "definition": row.get::<_, String>(6), + "acl": row.get::<_, String>(7), + "routine_kind": row.get::<_, String>(8) + }))); + + let column_rows = client.query( + "SELECT n.nspname, c.relname, a.attname, pg_catalog.format_type(a.atttypid,a.atttypmod), a.attnotnull, COALESCE(pg_catalog.pg_get_expr(d.adbin,d.adrelid),''), a.attidentity::text, a.attgenerated::text FROM pg_catalog.pg_attribute a JOIN pg_catalog.pg_class c ON c.oid=a.attrelid JOIN pg_catalog.pg_namespace n ON n.oid=c.relnamespace LEFT JOIN pg_catalog.pg_attrdef d ON d.adrelid=a.attrelid AND d.adnum=a.attnum WHERE c.relkind IN ('r','p','v','m') AND a.attnum>0 AND NOT a.attisdropped AND n.nspname NOT IN ('pg_catalog','information_schema') AND n.nspname NOT LIKE 'pg_%' ORDER BY n.nspname,c.relname,a.attnum", + &[], + ).await.map_err(db_error)?; + state.extend(column_rows.into_iter().map(|row| json!({ + "kind": "column", + "schema": row.get::<_, String>(0), + "relation": row.get::<_, String>(1), + "name": row.get::<_, String>(2), + "data_type": row.get::<_, String>(3), + "not_null": row.get::<_, bool>(4), + "default": row.get::<_, String>(5), + "identity": row.get::<_, String>(6), + "generated": row.get::<_, String>(7) + }))); + + let constraint_rows = client.query( + "SELECT n.nspname, c.relname, constraint_row.conname, constraint_row.contype::text, constraint_row.convalidated, constraint_row.condeferrable, constraint_row.condeferred, pg_catalog.pg_get_constraintdef(constraint_row.oid,true) FROM pg_catalog.pg_constraint constraint_row JOIN pg_catalog.pg_class c ON c.oid=constraint_row.conrelid JOIN pg_catalog.pg_namespace n ON n.oid=c.relnamespace WHERE n.nspname NOT IN ('pg_catalog','information_schema') AND n.nspname NOT LIKE 'pg_%' ORDER BY n.nspname,c.relname,constraint_row.conname", + &[], + ).await.map_err(db_error)?; + state.extend(constraint_rows.into_iter().map(|row| json!({ + "kind": "constraint", + "schema": row.get::<_, String>(0), + "relation": row.get::<_, String>(1), + "name": row.get::<_, String>(2), + "constraint_type": row.get::<_, String>(3), + "validated": row.get::<_, bool>(4), + "deferrable": row.get::<_, bool>(5), + "initially_deferred": row.get::<_, bool>(6), + "definition": row.get::<_, String>(7) + }))); + + let index_rows = client.query( + "SELECT n.nspname, table_row.relname, index_row.relname, index_meta.indisunique, index_meta.indisvalid, index_meta.indisready, pg_catalog.pg_get_indexdef(index_meta.indexrelid) FROM pg_catalog.pg_index index_meta JOIN pg_catalog.pg_class table_row ON table_row.oid=index_meta.indrelid JOIN pg_catalog.pg_class index_row ON index_row.oid=index_meta.indexrelid JOIN pg_catalog.pg_namespace n ON n.oid=table_row.relnamespace WHERE n.nspname NOT IN ('pg_catalog','information_schema') AND n.nspname NOT LIKE 'pg_%' ORDER BY n.nspname,table_row.relname,index_row.relname", + &[], + ).await.map_err(db_error)?; + state.extend(index_rows.into_iter().map(|row| json!({ + "kind": "index", + "schema": row.get::<_, String>(0), + "relation": row.get::<_, String>(1), + "name": row.get::<_, String>(2), + "unique": row.get::<_, bool>(3), + "valid": row.get::<_, bool>(4), + "ready": row.get::<_, bool>(5), + "definition": row.get::<_, String>(6) + }))); + + let trigger_rows = client.query( + "SELECT n.nspname, c.relname, trigger_row.tgname, trigger_row.tgenabled::text, pg_catalog.pg_get_triggerdef(trigger_row.oid,true) FROM pg_catalog.pg_trigger trigger_row JOIN pg_catalog.pg_class c ON c.oid=trigger_row.tgrelid JOIN pg_catalog.pg_namespace n ON n.oid=c.relnamespace WHERE NOT trigger_row.tgisinternal AND n.nspname NOT IN ('pg_catalog','information_schema') AND n.nspname NOT LIKE 'pg_%' ORDER BY n.nspname,c.relname,trigger_row.tgname", + &[], + ).await.map_err(db_error)?; + state.extend(trigger_rows.into_iter().map(|row| json!({ + "kind": "trigger", + "schema": row.get::<_, String>(0), + "relation": row.get::<_, String>(1), + "name": row.get::<_, String>(2), + "enabled": row.get::<_, String>(3), + "definition": row.get::<_, String>(4) + }))); + + let view_rows = client.query( + "SELECT n.nspname, c.relname, c.relkind::text, pg_catalog.pg_get_userbyid(c.relowner), COALESCE(c.reloptions::text,''), pg_catalog.pg_get_viewdef(c.oid,true), COALESCE(c.relacl::text,'') FROM pg_catalog.pg_class c JOIN pg_catalog.pg_namespace n ON n.oid=c.relnamespace WHERE c.relkind IN ('v','m') AND n.nspname NOT IN ('pg_catalog','information_schema') AND n.nspname NOT LIKE 'pg_%' ORDER BY n.nspname,c.relname", + &[], + ).await.map_err(db_error)?; + state.extend(view_rows.into_iter().map(|row| json!({ + "kind": "view", + "schema": row.get::<_, String>(0), + "name": row.get::<_, String>(1), + "relation_kind": row.get::<_, String>(2), + "owner": row.get::<_, String>(3), + "options": row.get::<_, String>(4), + "definition": row.get::<_, String>(5), + "acl": row.get::<_, String>(6) + }))); + + let schema_rows = client.query( + "SELECT n.nspname, pg_catalog.pg_get_userbyid(n.nspowner), COALESCE(n.nspacl::text,'') FROM pg_catalog.pg_namespace n WHERE n.nspname NOT IN ('pg_catalog','information_schema') AND n.nspname NOT LIKE 'pg_%' ORDER BY n.nspname", + &[], + ).await.map_err(db_error)?; + state.extend(schema_rows.into_iter().map(|row| json!({ + "kind": "schema_privilege", + "schema": row.get::<_, String>(0), + "owner": row.get::<_, String>(1), + "acl": row.get::<_, String>(2) + }))); + + let database_rows = client.query( + "SELECT d.datname, pg_catalog.pg_get_userbyid(d.datdba), COALESCE(d.datacl::text,''), d.datallowconn, d.datistemplate FROM pg_catalog.pg_database d ORDER BY d.datname", + &[], + ).await.map_err(db_error)?; + state.extend(database_rows.into_iter().map(|row| json!({ + "kind": "database_privilege", + "database": row.get::<_, String>(0), + "owner": row.get::<_, String>(1), + "acl": row.get::<_, String>(2), + "allow_connections": row.get::<_, bool>(3), + "is_template": row.get::<_, bool>(4) + }))); + + let default_acl_rows = client.query( + "SELECT pg_catalog.pg_get_userbyid(default_acl.defaclrole), COALESCE(namespace.nspname,''), default_acl.defaclobjtype::text, COALESCE(default_acl.defaclacl::text,'') FROM pg_catalog.pg_default_acl default_acl LEFT JOIN pg_catalog.pg_namespace namespace ON namespace.oid=default_acl.defaclnamespace ORDER BY 1,2,3", + &[], + ).await.map_err(db_error)?; + state.extend(default_acl_rows.into_iter().map(|row| json!({ + "kind": "default_privilege", + "owner_role": row.get::<_, String>(0), + "schema": row.get::<_, String>(1), + "object_type": row.get::<_, String>(2), + "acl": row.get::<_, String>(3) + }))); + + let fingerprint = sha256(&serde_json::to_vec(&json!({ + "target_id": self.target_id, + "database_name": self.database_name, + "catalog": state + })).map_err(|_| error("fingerprint_serialization_failed", "Could not serialize PostgreSQL catalog state."))?); + let clock = client.query_one("SELECT to_char(clock_timestamp() AT TIME ZONE 'UTC', 'YYYY-MM-DD\"T\"HH24:MI:SS.US\"Z\"')", &[]).await.map_err(db_error)?; + let observed_at: String = clock.get(0); + let detected = previous_fingerprint.is_some_and(|previous| previous != fingerprint.as_str()); + Ok(DriftReport { + database_kind: DatabaseKind::PostgreSql, + target: target.clone(), + detected, + completeness: InspectionCompleteness::Complete, + previous_fingerprint: previous_fingerprint.map(str::to_owned), + observed_fingerprint: Some(fingerprint), + findings: if detected { + vec![SecurityFinding { + code: "native_catalog_fingerprint_changed".into(), + resource: None, + detail: "The observed PostgreSQL relation, ownership, ACL, or row-security policy definition differs from the accepted fingerprint.".into(), + }] + } else { Vec::new() }, + observed_at, + }) + }) + } +} + +fn error(code: &str, detail: &str) -> AdapterError { + AdapterError { code: code.into(), detail: detail.into(), retryable: false } +} + +fn db_error(error: tokio_postgres::Error) -> AdapterError { + AdapterError { code: "postgres_catalog_query_failed".into(), detail: error.to_string(), retryable: error.is_closed() } +} + +fn finding(code: &str, resource: &crate::security_core::ResourceRef, detail: &str) -> SecurityFinding { + SecurityFinding { code: code.into(), resource: Some(resource.clone()), detail: detail.into() } +} + +fn sha256(bytes: &[u8]) -> String { + hex::encode(Sha256::digest(bytes)) +} + +fn quote_ident(value: &str) -> String { + format!("\"{}\"", value.replace('"', "\"\"")) +} + +fn quote_literal(value: &str) -> String { + format!("'{}'", value.replace('\'', "''")) +} + +fn safe_name(value: &str) -> String { + let normalized: String = value.chars().map(|character| { + if character.is_ascii_alphanumeric() || character == '_' { character.to_ascii_lowercase() } else { '_' } + }).take(24).collect(); + if normalized.is_empty() { "policy".into() } else { normalized } +} + + +#[cfg(test)] +mod tests { + use super::*; + use crate::security_core::{ResourceRef, SECURITY_MODEL_VERSION}; + + fn policy() -> TenantSecurityPolicy { + TenantSecurityPolicy { + schema_version: SECURITY_MODEL_VERSION.into(), + policy_id: "tenant_boundary".into(), + revision: 7, + tenant_identity_claim: "tenant_id".into(), + resources: vec![ProtectedResource { + resource: ResourceRef { + namespace: Some("customer data".into()), + name: "invoices".into(), + kind: ResourceKind::Table, + }, + tenant_key: "tenant_id".into(), + operations: vec![Operation::Read, Operation::Create, Operation::Update, Operation::Delete], + }], + } + } + + fn adapter() -> PostgresCatalogAdapter { + let connector: PostgresConnector = Arc::new(|| Box::pin(async { + Err(error("test_connector_not_called", "This test exercises compilation only.")) + })); + PostgresCatalogAdapter::new("test-target", "app_db", "proxima_tenant_", connector).unwrap() + } + + #[test] + fn postgres_plan_is_review_only_and_emits_restrictive_operation_policies() { + let compiled = adapter().compile_policy(&policy()).unwrap(); + assert_eq!(compiled.database_kind, DatabaseKind::PostgreSql); + assert_eq!(compiled.revision, 7); + assert!(compiled.requires_approval); + assert_eq!(compiled.changes.len(), 1); + let statements = compiled.changes[0].definition["statements"].as_array().unwrap(); + assert_eq!(statements.len(), 6); + let sql = statements.iter().map(|value| value.as_str().unwrap()).collect::>().join("\n"); + assert!(sql.contains("AS RESTRICTIVE")); + assert!(sql.contains("pg_catalog.left(current_user, pg_catalog.char_length('proxima_tenant_')) = 'proxima_tenant_'")); + assert!(sql.contains("pg_catalog.substring(current_user FROM pg_catalog.char_length('proxima_tenant_') + 1)")); + assert!(!sql.contains("current_setting")); + assert!(sql.contains("\"customer data\".\"invoices\"")); + assert!(sql.contains("WITH CHECK")); + assert_eq!(compiled.changes[0].definition["execution"], "not_executed"); + } + + #[test] + fn postgres_plan_rejects_execute_and_non_table_resources() { + let mut invalid = policy(); + invalid.resources[0].operations.push(Operation::Execute); + assert_eq!(adapter().compile_policy(&invalid).unwrap_err().code, "unsupported_operation"); + + let mut invalid = policy(); + invalid.resources[0].resource.kind = ResourceKind::View; + assert_eq!(adapter().compile_policy(&invalid).unwrap_err().code, "unsupported_resource_kind"); + } + + + #[tokio::test] + async fn catalog_only_verification_never_allows_admission() { + let adapter = adapter(); + let policy = policy(); + let snapshot = InspectionSnapshot { + database_kind: DatabaseKind::PostgreSql, + target: AdapterTarget { + target_id: "test-target".into(), + database_name: "app_db".into(), + namespace: None, + }, + completeness: InspectionCompleteness::Complete, + posture: SecurityPosture::Verified, + resources: Vec::new(), + findings: Vec::new(), + fingerprint: Some("a".repeat(64)), + observed_at: "2026-11-17T00:00:00Z".into(), + }; + let report = adapter.verify(&policy, &snapshot).await.unwrap(); + assert_eq!(report.access_decision(), crate::security_core::AccessDecision::Deny); + assert!(report.findings.iter().any(|item| item.code == "independent_tenant_probes_required")); + } + + #[tokio::test] + async fn discovery_rejects_a_different_registered_target_before_connecting() { + let adapter = adapter(); + let request = DiscoveryRequest { + target: AdapterTarget { + target_id: "other-target".into(), + database_name: "app_db".into(), + namespace: None, + }, + namespace: None, + }; + assert_eq!(adapter.discover(&request).await.unwrap_err().code, "postgres_target_mismatch"); + } + + #[tokio::test] + async fn discovery_rejects_invalid_namespace_before_connecting() { + let adapter = adapter(); + let request = DiscoveryRequest { + target: AdapterTarget { + target_id: "test-target".into(), + database_name: "app_db".into(), + namespace: None, + }, + namespace: Some("x".repeat(64)), + }; + assert_eq!(adapter.discover(&request).await.unwrap_err().code, "invalid_discovery_namespace"); + } + + #[tokio::test] + async fn inspection_rejects_a_different_registered_target_before_connecting() { + let adapter = adapter(); + let request = InspectionRequest { + target: AdapterTarget { + target_id: "other-target".into(), + database_name: "app_db".into(), + namespace: None, + }, + policy: policy(), + }; + let result = adapter.inspect(&request).await; + assert_eq!(result.unwrap_err().code, "postgres_target_mismatch"); + } + + #[test] + fn postgres_adapter_does_not_claim_production_support() { + let descriptor = adapter().descriptor(); + assert_eq!(descriptor.maturity, AdapterMaturity::InDevelopment); + assert!(!descriptor.capabilities.is_production_complete()); + assert!(!descriptor.capabilities.policy_semantic_verification); + assert!(!descriptor.capabilities.controlled_policy_deployment); + } +} diff --git a/crates/proxima-engine/src/redis_adapter.rs b/crates/proxima-engine/src/redis_adapter.rs new file mode 100644 index 00000000..6f1e5294 --- /dev/null +++ b/crates/proxima-engine/src/redis_adapter.rs @@ -0,0 +1,453 @@ +//! Native Redis ACL and key-pattern discovery adapter. +//! Catalog discovery is TLS-only and always fails closed for tenant admission. + +use crate::database_adapter::{ + AdapterError, AdapterFuture, AdapterTarget, CompiledPolicy, DatabaseAdapter, + DiscoveryRequest, DiscoverySnapshot, DiscoveredResource, DriftReport, + InspectionRequest, InspectionSnapshot, ResourceInspection, +}; +use crate::native_policy_plans::compile_redis_acl; +use crate::security_core::{ + AdapterCapabilities, AdapterDescriptor, AdapterMaturity, DatabaseKind, + InspectionCompleteness, Operation, ResourceKind, ResourceRef, SecurityFinding, + SecurityPosture, TenantSecurityPolicy, VerificationReport, SECURITY_MODEL_VERSION, +}; +use redis::{aio::MultiplexedConnection, Client}; +use serde_json::json; +use sha2::{Digest, Sha256}; +use std::time::Duration; + +pub struct RedisCatalogAdapter { + target_id: String, + database_index: u32, + connection_uri: String, +} + +impl RedisCatalogAdapter { + pub fn new(target_id: impl Into, database_index: u32, connection_uri: impl Into) -> Result { + let target_id = target_id.into(); + let connection_uri = connection_uri.into(); + if target_id.trim().is_empty() || target_id.len() > 256 || target_id.contains('\0') + || connection_uri.trim().is_empty() || connection_uri.len() > 4096 { + return Err(error("invalid_redis_target", "A bounded target ID and Redis connection URI are required.")); + } + if !connection_uri.to_ascii_lowercase().starts_with("rediss://") { + return Err(error("redis_tls_required", "Redis catalog connections must use rediss:// with certificate and hostname verification.")); + } + if connection_uri.contains('#') { + return Err(error("redis_tls_verification_required", "Redis URL fragments are forbidden; redis-rs uses #insecure to disable TLS certificate verification.")); + } + Client::open(connection_uri.as_str()) + .map_err(|_| error("invalid_redis_connection_config", "The Redis TLS connection URI could not be parsed."))?; + Ok(Self { target_id, database_index, connection_uri }) + } + + fn validate_target(&self, target: &AdapterTarget) -> Result<(), AdapterError> { + if target.target_id != self.target_id || target.database_name != self.database_index.to_string() { + return Err(error("redis_target_mismatch", "The request does not match this adapter's registered Redis target and database index.")); + } + Ok(()) + } + + async fn connect_checked(&self) -> Result { + let client = Client::open(self.connection_uri.as_str()) + .map_err(|_| error("invalid_redis_connection_config", "The Redis TLS connection URI could not be parsed."))?; + let mut connection = tokio::time::timeout(Duration::from_secs(10), client.get_multiplexed_async_connection()) + .await.map_err(|_| error("redis_connection_timeout", "Redis connection exceeded the ten-second deadline."))? + .map_err(db_error)?; + let client_info = redis::cmd("CLIENT").arg("INFO").query_async::(&mut connection).await.map_err(db_error)?; + let selected_db = client_info.split_whitespace().find_map(|field| field.strip_prefix("db=")) + .and_then(|value| value.parse::().ok()) + .ok_or_else(|| error("redis_database_identity_unavailable", "Redis CLIENT INFO did not expose a numeric database index."))?; + if selected_db != self.database_index { + return Err(error("redis_database_mismatch", "The authenticated Redis connection selected a different logical database.")); + } + let pong = redis::cmd("PING").query_async::(&mut connection).await.map_err(db_error)?; + if !pong.eq_ignore_ascii_case("PONG") { + return Err(error("redis_ping_failed", "Redis did not return PONG for the authenticated connection.")); + } + Ok(connection) + } + + async fn discover_bounded(&self, request: &DiscoveryRequest) -> Result { + tokio::time::timeout(Duration::from_secs(60), self.discover_inner(request)) + .await + .map_err(|_| AdapterError { + code: "redis_catalog_timeout".into(), + detail: "Redis ACL and keyspace discovery exceeded the sixty-second operation deadline.".into(), + retryable: true, + })? + } + + async fn discover_inner(&self, request: &DiscoveryRequest) -> Result { + self.validate_target(&request.target)?; + if request.namespace.as_ref().is_some_and(|namespace| namespace != &self.database_index.to_string()) { + return Err(error("invalid_discovery_namespace", "Redis namespace must be the registered logical database index.")); + } + let mut connection = self.connect_checked().await?; + let whoami = redis::cmd("ACL").arg("WHOAMI").query_async::(&mut connection).await.map_err(db_error)?; + let acl_lines = redis::cmd("ACL").arg("LIST").query_async::>(&mut connection).await.map_err(db_error)?; + let acl_rule_count = acl_lines.len(); + let acl_inventory_truncated = acl_rule_count > 10_000; + let acl_digest = digest(&serde_json::to_vec(&acl_lines).map_err(|_| error("redis_acl_serialization_failed", "Could not serialize Redis ACL rules."))?); + let acl_lines = acl_lines.into_iter().take(10_000).collect::>(); + let categories = redis::cmd("ACL").arg("CAT").query_async::>(&mut connection).await.map_err(db_error)?; + let server_info = redis::cmd("INFO").arg("server").query_async::(&mut connection).await.map_err(db_error)?; + let keyspace_info = redis::cmd("INFO").arg("keyspace").query_async::(&mut connection).await.map_err(db_error)?; + let mut resources = Vec::new(); + let mut broad_users = Vec::new(); + let mut resource_inventory_truncated = false; + 'acl_users: for line in &acl_lines { + let Some((username, tokens)) = parse_acl_line(line) else { continue }; + let patterns = tokens.iter().filter_map(|token| { + if let Some(pattern) = token.strip_prefix("%R~") { + Some((pattern.to_owned(), "read")) + } else if let Some(pattern) = token.strip_prefix("%W~") { + Some((pattern.to_owned(), "write")) + } else if let Some(pattern) = token.strip_prefix('~') { + Some((pattern.to_owned(), "read_write")) + } else if token == "allkeys" { + Some(("*".into(), "read_write")) + } else { + None + } + }).collect::>(); + let command_rules = tokens.iter().filter(|token| token.starts_with('+') || token.starts_with('-')).cloned().collect::>(); + let channel_rules = tokens.iter().filter(|token| token.starts_with('&')).cloned().collect::>(); + for (pattern, pattern_mode) in patterns { + if pattern == "*" || pattern == "**" { broad_users.push(username.to_owned()); } + resources.push(DiscoveredResource { + namespace: Some(self.database_index.to_string()), + name: pattern.clone(), + kind: ResourceKind::Keyspace, + owner: Some(username.to_owned()), + attributes: json!({ + "acl_username": username, + "key_pattern": pattern, + "key_pattern_mode": pattern_mode, + "command_rules": command_rules, + "channel_rules": channel_rules, + "user_flags": tokens.iter().filter(|token| !token.starts_with('#') && !token.starts_with('>') && !token.starts_with('~') && !token.starts_with('&') && !token.starts_with('%') && !token.starts_with('+') && !token.starts_with('-')).cloned().collect::>() + }), + }); + } + } + let sanitized_acl = acl_lines.iter().map(|line| sanitize_acl_line(line)).collect::>(); + let target_attributes = json!({ + "target_id": self.target_id, + "database_index": self.database_index, + "authenticated_acl_user": whoami, + "server_version": info_field(&server_info, "redis_version").unwrap_or_else(|| "unknown".into()), + "server_info": server_info, + "keyspace_info": keyspace_info, + "acl_users": sanitized_acl, + "acl_categories": categories, + "acl_rule_fingerprint": acl_digest, + "acl_rule_count": acl_rule_count, + "acl_inventory_truncated": acl_inventory_truncated, + "resource_inventory_truncated": resource_inventory_truncated, + "tls_certificate_and_hostname_verification_required": true + }); + // Exclude volatile INFO server uptime/client metrics and INFO keyspace key counts. + // Fingerprint only ACL/identity/version state relevant to authorization posture. + let fingerprint = digest(&serde_json::to_vec(&json!({ + "target_id": self.target_id, + "database_index": self.database_index, + "authenticated_acl_user": whoami, + "server_version": info_field(&server_info, "redis_version").unwrap_or_else(|| "unknown".into()), + "acl_users": sanitized_acl, + "acl_categories": categories, + "acl_rule_fingerprint": acl_digest, + "resources": resources + })).map_err(|_| error("fingerprint_serialization_failed", "Could not serialize Redis discovery results."))?); + let mut findings = vec![SecurityFinding { + code: "redis_keyspace_inventory_is_acl_scoped".into(), + resource: None, + detail: "Discovery inventories ACL key patterns and command rules. It does not enumerate all stored keys or prove every application operation is tenant-bound.".into(), + }]; + if acl_inventory_truncated || resource_inventory_truncated { + findings.push(SecurityFinding { + code: "redis_acl_inventory_truncated".into(), + resource: None, + detail: "Redis ACL or key-pattern inventory exceeded the 10,000-user or 50,000-pattern safety bound; the displayed inventory is bounded and cannot be treated as complete.".into(), + }); + } + if !broad_users.is_empty() { + broad_users.sort(); + broad_users.dedup(); + findings.push(SecurityFinding { + code: "redis_acl_unrestricted_key_pattern".into(), + resource: None, + detail: format!("Redis ACL users have unrestricted key access: {}. Replace wildcard access with tenant-specific patterns.", broad_users.join(", ")), + }); + } + Ok(DiscoverySnapshot { + database_kind: DatabaseKind::Redis, + target: request.target.clone(), + completeness: InspectionCompleteness::Incomplete, + target_attributes, + resources, + findings, + fingerprint: Some(fingerprint), + observed_at: chrono::Utc::now().to_rfc3339(), + }) + } +} + +impl DatabaseAdapter for RedisCatalogAdapter { + fn descriptor(&self) -> AdapterDescriptor { + AdapterDescriptor { + kind: DatabaseKind::Redis, + name: "Redis ACL adapter", + maturity: AdapterMaturity::InDevelopment, + capabilities: AdapterCapabilities { schema_inspection: true, policy_generation: true, drift_detection: true, ..AdapterCapabilities::default() }, + status_note: "TLS-verified ACL users, command rules, key patterns and keyspace metadata are inspected. Runtime tenant binding, keyless-command mediation, semantic probes, controlled ACL deployment and signed admission are not implemented.", + } + } + + fn discover<'a>(&'a self, request: &'a DiscoveryRequest) -> AdapterFuture<'a, Result> { + Box::pin(async move { self.discover_bounded(request).await }) + } + + fn inspect<'a>(&'a self, request: &'a InspectionRequest) -> AdapterFuture<'a, Result> { + Box::pin(async move { + self.validate_target(&request.target)?; + request.policy.validate().map_err(|_| error("invalid_policy", "The canonical tenant policy failed validation."))?; + let _compiled_plan = compile_redis_acl(&request.policy)?; + let discovery = self.discover_inner(&DiscoveryRequest { target: request.target.clone(), namespace: None }).await?; + let mut findings = discovery.findings.clone(); + let mut resources = Vec::with_capacity(request.policy.resources.len()); + let placeholder = concat!("$", "{tenant_id}"); + for protected in &request.policy.resources { + if !matches!(protected.resource.kind, ResourceKind::Keyspace | ResourceKind::Table) { + return Err(error("unsupported_redis_resource_kind", "Redis policies must target a keyspace or logical key collection.")); + } + if protected.operations.contains(&Operation::Execute) { + return Err(error("unsupported_redis_execute_operation", "Redis script and function execution requires a separate native command policy.")); + } + let Some((prefix, suffix)) = protected.tenant_key.split_once(placeholder) else { + return Err(error("redis_tenant_key_pattern_required", "Redis policy key patterns must contain a tenant placeholder.")); + }; + if protected.tenant_key.matches(placeholder).count() != 1 { + return Err(error("unsafe_redis_tenant_pattern", "Redis policy key patterns must contain exactly one tenant placeholder.")); + } + let matching: Vec<_> = discovery.resources.iter().filter(|resource| { + resource.name.starts_with(prefix) && resource.name.ends_with(suffix) && resource.owner.is_some() + }).collect(); + let mut resource_findings = Vec::new(); + if matching.is_empty() { + resource_findings.push(finding("redis_tenant_key_pattern_not_registered", &protected.resource, "No Redis ACL user currently exposes a key pattern matching the registered tenant key template.")); + } + if discovery.resources.iter().any(|resource| resource.name == "*" || resource.name == "**") { + resource_findings.push(finding("redis_unrestricted_key_pattern", &protected.resource, "At least one Redis ACL user has unrestricted key access.")); + } + let needs_read_scope = protected.operations.contains(&Operation::Read); + let needs_write_scope = protected.operations.iter().any(|operation| matches!(operation, Operation::Create | Operation::Update | Operation::Delete)); + let key_scope_coverage = matching.iter().any(|resource| { + let Some(owner) = resource.owner.as_deref() else { return false }; + let same_user = matching.iter().filter(|other| other.owner.as_deref() == Some(owner)); + let mut read_scope = false; + let mut write_scope = false; + for candidate in same_user { + match candidate.attributes["key_pattern_mode"].as_str() { + Some("read_write") => { read_scope = true; write_scope = true; } + Some("read") => read_scope = true, + Some("write") => write_scope = true, + _ => {} + } + } + (!needs_read_scope || read_scope) && (!needs_write_scope || write_scope) + }); + if !key_scope_coverage { + resource_findings.push(finding("redis_acl_key_scope_incomplete", &protected.resource, "No single ACL user has key-pattern permissions covering every read and write scope required by this policy.")); + } + let required_commands = required_commands(&protected.operations); + let explicit_command_coverage = matching.iter().any(|resource| { + let rules = resource.attributes["command_rules"].as_array(); + rules.is_some_and(|rules| { + required_commands.iter().all(|command| rules.iter().any(|rule| rule.as_str().is_some_and(|value| value == format!("+{command}").as_str()))) + && !rules.iter().filter_map(|rule| rule.as_str()).any(|rule| rule.starts_with("-@") || required_commands.iter().any(|command| rule == format!("-{command}").as_str())) + }) + }); + if !explicit_command_coverage { + resource_findings.push(finding("redis_acl_command_coverage_incomplete", &protected.resource, "No single tenant ACL user explicitly grants every command required by this policy; command categories are not treated as proof of least-privilege coverage.")); + } + if matching.iter().any(|resource| resource.attributes["command_rules"].as_array().is_some_and(|rules| { + rules.iter().filter_map(|rule| rule.as_str()).any(|rule| matches!(rule, "+@all" | "+@write" | "+@admin")) + })) { + resource_findings.push(finding("redis_acl_broad_command_category", &protected.resource, "A matching ACL user grants a broad command category; review and replace category grants with an explicit command allowlist.")); + } + resource_findings.push(finding("redis_tenant_operation_probe_required", &protected.resource, "ACL inspection cannot prove that scripts, functions, modules and keyless commands respect tenant boundaries.")); + let resource_fingerprint = digest(&serde_json::to_vec(&matching.iter().map(|resource| &resource.attributes).collect::>()) + .map_err(|_| error("fingerprint_serialization_failed", "Could not serialize Redis ACL resource metadata."))?); + findings.extend(resource_findings.clone()); + resources.push(ResourceInspection { + resource: protected.clone(), + completeness: InspectionCompleteness::Incomplete, + posture: SecurityPosture::NeedsAttention, + verified_operations: Vec::new(), + findings: resource_findings, + fingerprint: Some(resource_fingerprint), + }); + } + Ok(InspectionSnapshot { + database_kind: DatabaseKind::Redis, + target: request.target.clone(), + completeness: discovery.completeness, + posture: SecurityPosture::NeedsAttention, + resources, + findings, + fingerprint: discovery.fingerprint, + observed_at: discovery.observed_at, + }) + }) + } + + fn compile_policy(&self, policy: &TenantSecurityPolicy) -> Result { compile_redis_acl(policy) } + + fn verify<'a>(&'a self, policy: &'a TenantSecurityPolicy, snapshot: &'a InspectionSnapshot) -> AdapterFuture<'a, Result> { + Box::pin(async move { + if snapshot.database_kind != DatabaseKind::Redis || snapshot.target.target_id != self.target_id + || snapshot.target.database_name != self.database_index.to_string() { + return Err(error("redis_snapshot_target_mismatch", "The inspection snapshot does not belong to this Redis adapter target.")); + } + let mut findings = snapshot.findings.clone(); + findings.push(SecurityFinding { + code: "independent_tenant_probes_required".into(), + resource: None, + detail: format!("{} protected keyspaces require own-tenant allow and cross-tenant deny probes across every declared command.", policy.resources.len()), + }); + findings.push(SecurityFinding { + code: "redis_runtime_tenant_binding_unavailable".into(), + resource: None, + detail: "No trusted Redis protocol gateway binds authenticated tenant identity to the matching ACL user and mediates keyless commands.".into(), + }); + Ok(VerificationReport { model_version: SECURITY_MODEL_VERSION.into(), posture: SecurityPosture::Blocked, inspection: snapshot.completeness, findings }) + }) + } + + fn detect_drift<'a>(&'a self, target: &'a AdapterTarget, previous_fingerprint: Option<&'a str>) -> AdapterFuture<'a, Result> { + Box::pin(async move { + self.validate_target(target)?; + if previous_fingerprint.is_some_and(|value| value.len() != 64 || hex::decode(value).map_or(true, |bytes| bytes.len() != 32)) { + return Err(error("invalid_previous_fingerprint", "The previous fingerprint must be a 32-byte hexadecimal SHA-256 digest.")); + } + let snapshot = self.discover_bounded(&DiscoveryRequest { target: target.clone(), namespace: None }).await?; + Ok(DriftReport { + database_kind: DatabaseKind::Redis, + target: target.clone(), + detected: previous_fingerprint.is_some_and(|previous| Some(previous) != snapshot.fingerprint.as_deref()), + completeness: snapshot.completeness, + previous_fingerprint: previous_fingerprint.map(str::to_owned), + observed_fingerprint: snapshot.fingerprint, + findings: snapshot.findings, + observed_at: snapshot.observed_at, + }) + }) + } +} + +fn required_commands(operations: &[Operation]) -> Vec<&'static str> { + let mut commands = Vec::new(); + for operation in operations { + let required: &[&str] = match operation { + Operation::Read => &["get","mget","exists","ttl","pttl","type","strlen","getrange","hget","hmget","hgetall","hexists","hlen","lrange","llen","lindex","scard","smembers","sismember","zrange","zscore","zcard","xrange","xlen"], + Operation::Create => &["set","mset","hset","lpush","rpush","sadd","zadd","xadd"], + Operation::Update => &["set","mset","expire","pexpire","persist","incr","decr","hset","lpush","rpush","sadd","zadd","xadd"], + Operation::Delete => &["del","unlink","hdel","lpop","rpop","srem","zrem","xdel"], + Operation::Execute => &[], + }; + commands.extend_from_slice(required); + } + commands.sort_unstable(); + commands.dedup(); + commands +} + +fn parse_acl_line(line: &str) -> Option<(&str, Vec)> { + let mut parts = line.split_whitespace(); + if parts.next()? != "user" { return None; } + Some((parts.next()?, parts.map(str::to_owned).collect())) +} + +fn sanitize_acl_line(line: &str) -> String { + line.split_whitespace().map(|token| if token.starts_with('#') || token.starts_with('>') { + "" + } else { token }).collect::>().join(" ") +} + +fn info_field(info: &str, key: &str) -> Option { + info.lines().find_map(|line| line.strip_prefix(&format!("{key}:")).map(str::to_owned)) +} + +fn finding(code: &str, resource: &ResourceRef, detail: &str) -> SecurityFinding { + SecurityFinding { code: code.into(), resource: Some(resource.clone()), detail: detail.into() } +} + +fn digest(bytes: &[u8]) -> String { + let mut hash = Sha256::new(); + hash.update(bytes); + hex::encode(hash.finalize()) +} + +fn error(code: &str, detail: &str) -> AdapterError { + AdapterError { code: code.into(), detail: detail.into(), retryable: false } +} + +fn db_error(error: redis::RedisError) -> AdapterError { + AdapterError { + code: "redis_catalog_command_failed".into(), + detail: "The authenticated Redis ACL/catalog command failed; grant the inspection principal the required read-only ACL commands.".into(), + retryable: error.is_io_error() || error.is_timeout(), + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn requires_tls_and_validates_target() { + assert!(RedisCatalogAdapter::new("target", 0, "redis://localhost/0").is_err()); + assert!(RedisCatalogAdapter::new("target", 0, "rediss://localhost/0").is_ok()); + assert!(RedisCatalogAdapter::new("target", 0, "rediss://localhost/0#insecure").is_err()); + assert!(RedisCatalogAdapter::new("", 0, "rediss://localhost/0").is_err()); + } + + #[test] + fn parses_acl_key_patterns_and_sanitizes_credentials() { + let line = "user tenant-a on #secret-hash ~tenant:tenant-a:* +get +set"; + let (username, tokens) = parse_acl_line(line).unwrap(); + assert_eq!(username, "tenant-a"); + assert!(tokens.iter().any(|token| token == "~tenant:tenant-a:*")); + let sanitized = sanitize_acl_line(line); + assert!(!sanitized.contains("secret-hash")); + assert!(sanitized.contains("")); + } + + #[test] + fn parses_read_only_and_write_only_key_patterns_separately() { + let (_, read_tokens) = parse_acl_line("user reader on %R~tenant:* +get").unwrap(); + let (_, write_tokens) = parse_acl_line("user writer on %W~tenant:* +set").unwrap(); + assert!(read_tokens.iter().any(|token| token == "%R~tenant:*")); + assert!(write_tokens.iter().any(|token| token == "%W~tenant:*")); + } + + #[test] + fn maps_policy_operations_to_explicit_redis_commands() { + let commands = required_commands(&[Operation::Read, Operation::Delete]); + assert!(commands.contains(&"get")); + assert!(commands.contains(&"del")); + assert!(!commands.contains(&"set")); + } + + #[test] + fn rejects_target_database_index_mismatch_without_connecting() { + let adapter = RedisCatalogAdapter::new("target", 2, "rediss://localhost/2").unwrap(); + let request = DiscoveryRequest { + target: AdapterTarget { target_id: "target".into(), database_name: "1".into(), namespace: None }, + namespace: None, + }; + assert_eq!(adapter.validate_target(&request.target).unwrap_err().code, "redis_target_mismatch"); + } +} diff --git a/crates/proxima-engine/src/security_core.rs b/crates/proxima-engine/src/security_core.rs new file mode 100644 index 00000000..f9d5324d --- /dev/null +++ b/crates/proxima-engine/src/security_core.rs @@ -0,0 +1,495 @@ +//! Database-independent tenant-security contracts used by Proxima Engine. +//! +//! Database adapters translate this contract into native database controls. The +//! catalog deliberately distinguishes implemented work from planned adapters; +//! listing a database never implies that its adapter is production-supported. + +use serde::{Deserialize, Serialize}; +use std::collections::HashSet; + +pub const SECURITY_MODEL_VERSION: &str = "proxima.security.v1"; + +#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)] +#[serde(rename_all = "snake_case")] +pub enum DatabaseKind { + #[serde(rename = "postgresql")] + PostgreSql, + #[serde(rename = "mysql")] + MySql, + #[serde(rename = "mariadb")] + MariaDb, + #[serde(rename = "sql_server")] + SqlServer, + #[serde(rename = "mongodb")] + MongoDb, + #[serde(rename = "cockroachdb")] + CockroachDb, + #[serde(rename = "vaultdb")] + VaultDb, + #[serde(rename = "redis")] + Redis, + #[serde(rename = "sqlite")] + Sqlite, + #[serde(rename = "oracle")] + Oracle, + #[serde(rename = "dynamodb")] + DynamoDb, + #[serde(rename = "cassandra")] + Cassandra, + #[serde(rename = "elasticsearch")] + Elasticsearch, +} + +#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)] +#[serde(rename_all = "snake_case")] +pub enum AdapterMaturity { + InDevelopment, + Planned, + Supported, +} + +#[derive(Clone, Copy, Debug, Default, Eq, PartialEq, Serialize, Deserialize)] +pub struct AdapterCapabilities { + pub schema_inspection: bool, + pub tenant_identity_enforcement: bool, + pub policy_semantic_verification: bool, + pub policy_generation: bool, + pub controlled_policy_deployment: bool, + pub drift_detection: bool, + pub runtime_fail_closed_admission: bool, + pub signed_security_evidence: bool, +} + +impl AdapterCapabilities { + /// Production support is an end-to-end claim. A compiler or a successful + /// connection test is not sufficient to mark an adapter supported. + pub fn is_production_complete(&self) -> bool { + self.schema_inspection + && self.tenant_identity_enforcement + && self.policy_semantic_verification + && self.policy_generation + && self.controlled_policy_deployment + && self.drift_detection + && self.runtime_fail_closed_admission + && self.signed_security_evidence + } +} + +#[derive(Clone, Debug, Eq, PartialEq, Serialize)] +pub struct AdapterDescriptor { + pub kind: DatabaseKind, + pub name: &'static str, + pub maturity: AdapterMaturity, + pub capabilities: AdapterCapabilities, + pub status_note: &'static str, +} + +/// The public catalog is a statement of actual implementation maturity, not a +/// marketing list. Planned adapters expose no capabilities until implemented. +pub fn adapter_catalog() -> Vec { + vec![ + AdapterDescriptor { + kind: DatabaseKind::PostgreSql, + name: "PostgreSQL", + maturity: AdapterMaturity::InDevelopment, + capabilities: AdapterCapabilities { + schema_inspection: true, + tenant_identity_enforcement: true, + policy_semantic_verification: false, + policy_generation: true, + controlled_policy_deployment: false, + drift_detection: true, + runtime_fail_closed_admission: true, + signed_security_evidence: true, + }, + status_note: "PostgreSQL protocol startup and active sessions can require fresh signed Control Plane admission; signed per-registration admission evidence is persisted. Independent positive/negative semantic verification and Engine-native deployment remain incomplete.", + }, + AdapterDescriptor { + kind: DatabaseKind::MySql, + name: "MySQL", + maturity: AdapterMaturity::InDevelopment, + capabilities: AdapterCapabilities { schema_inspection: true, policy_generation: true, drift_detection: true, ..AdapterCapabilities::default() }, + status_note: "TLS-verified native discovery covers tables/views, columns, grants, constraints, indexes, partitions, triggers, routines, views and account privileges; fingerprint drift comparison is implemented. Database-per-tenant grant plans remain review-only; runtime principal binding, semantic verification and controlled deployment are not implemented.", + }, + AdapterDescriptor { + kind: DatabaseKind::MariaDb, + name: "MariaDB", + maturity: AdapterMaturity::InDevelopment, + capabilities: AdapterCapabilities { schema_inspection: true, policy_generation: true, drift_detection: true, ..AdapterCapabilities::default() }, + status_note: "TLS-verified native discovery uses the shared MySQL/MariaDB catalog adapter for tables/views, columns, grants, constraints, indexes, partitions, triggers, routines and account privileges; fingerprint drift comparison is implemented. Database-per-tenant grant plans remain review-only; runtime principal binding, semantic verification and controlled deployment are not implemented.", + }, + AdapterDescriptor { + kind: DatabaseKind::SqlServer, + name: "Microsoft SQL Server", + maturity: AdapterMaturity::InDevelopment, + capabilities: AdapterCapabilities { schema_inspection: true, policy_generation: true, drift_detection: true, ..AdapterCapabilities::default() }, + status_note: "Encrypted TDS discovery and fingerprint drift comparison are implemented. A dedicated tenant-session connector now binds verified tenant, principal, target and policy context into read-only SESSION_CONTEXT before returning the connection. The TDS application gateway, controlled RLS deployment, independent semantic probes and fail-closed runtime admission are not yet integrated.", + }, + AdapterDescriptor { + kind: DatabaseKind::MongoDb, + name: "MongoDB", + maturity: AdapterMaturity::InDevelopment, + capabilities: AdapterCapabilities { schema_inspection: true, policy_generation: true, drift_detection: true, ..AdapterCapabilities::default() }, + status_note: "TLS-verified collection, validator, view and effective privilege discovery are implemented. Document ownership enforcement, independent tenant probes, controlled deployment and runtime admission are not implemented.", + }, + AdapterDescriptor { + kind: DatabaseKind::CockroachDb, + name: "CockroachDB", + maturity: AdapterMaturity::InDevelopment, + capabilities: AdapterCapabilities { schema_inspection: true, drift_detection: true, ..AdapterCapabilities::default() }, + status_note: "TLS-verified PostgreSQL-wire discovery inspects non-system tables, views, columns and table grants with bounded catalog fingerprints. CockroachDB-native tenant enforcement, policy deployment, independent semantic probes and runtime admission are not implemented; PostgreSQL RLS behavior is not assumed.", + }, + AdapterDescriptor { + kind: DatabaseKind::Redis, + name: "Redis", + maturity: AdapterMaturity::InDevelopment, + capabilities: AdapterCapabilities { schema_inspection: true, policy_generation: true, drift_detection: true, ..AdapterCapabilities::default() }, + status_note: "TLS-verified Redis ACL user, key-pattern, command-rule and keyspace metadata discovery with fingerprint drift comparison are implemented. Tenant identity binding, keyless-command mediation, independent semantic probes, controlled ACL deployment and runtime admission are not implemented; ACLs cannot distinguish create-only from update-only upsert semantics.", + }, + AdapterDescriptor { + kind: DatabaseKind::VaultDb, + name: "VAULTDB (Agata-native research engine)", + maturity: AdapterMaturity::Planned, + capabilities: AdapterCapabilities::default(), + status_note: "Agata-owned embedded relational research engine; tenant identity, resource authorization, isolation enforcement and security acceptance are not implemented.", + }, + AdapterDescriptor { kind: DatabaseKind::Sqlite, name: "SQLite", maturity: AdapterMaturity::InDevelopment, capabilities: AdapterCapabilities { schema_inspection: true, drift_detection: true, ..AdapterCapabilities::default() }, status_note: "Read-only schema and filesystem-permission discovery is implemented. SQLite has no native users or RLS; file-per-tenant OS isolation, trusted file selection, independent access probes and runtime admission are not implemented." }, + AdapterDescriptor { kind: DatabaseKind::Oracle, name: "Oracle Database", maturity: AdapterMaturity::InDevelopment, capabilities: AdapterCapabilities { policy_generation: true, ..AdapterCapabilities::default() }, status_note: "Oracle DBMS_RLS VPD policy-plan compilation is implemented for table SELECT/INSERT/UPDATE/DELETE predicates using a secure application context and fail-closed missing-context behavior. Native catalog discovery, trusted signed-context verifier integration, controlled deployment, effective semantic probes, drift monitoring and runtime admission remain incomplete; Oracle is not production-supported." }, + AdapterDescriptor { kind: DatabaseKind::DynamoDb, name: "Amazon DynamoDB", maturity: AdapterMaturity::Planned, capabilities: AdapterCapabilities::default(), status_note: "Partition-key and IAM LeadingKeys enforcement are not implemented." }, + AdapterDescriptor { kind: DatabaseKind::Cassandra, name: "Apache Cassandra", maturity: AdapterMaturity::Planned, capabilities: AdapterCapabilities::default(), status_note: "Keyspace-per-tenant isolation is not implemented." }, + AdapterDescriptor { kind: DatabaseKind::Elasticsearch, name: "Elasticsearch / OpenSearch", maturity: AdapterMaturity::InDevelopment, capabilities: AdapterCapabilities { schema_inspection: true, drift_detection: true, ..AdapterCapabilities::default() }, status_note: "Verified-HTTPS discovery inventories matching indices, mappings, settings, aliases and native security roles/users where visible. DLS/FLS enforcement, trusted tenant-principal binding, policy deployment, independent document probes and runtime admission are not implemented." }, + ] +} + +#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)] +#[serde(rename_all = "snake_case")] +pub enum ResourceKind { + Table, + View, + Sequence, + Collection, + Procedure, + Function, + Keyspace, +} + +#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)] +#[serde(rename_all = "snake_case")] +pub enum Operation { + Read, + Create, + Update, + Delete, + Execute, +} + +#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +pub struct ResourceRef { + pub namespace: Option, + pub name: String, + pub kind: ResourceKind, +} + +#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +pub struct ProtectedResource { + pub resource: ResourceRef, + /// Native tenant ownership attribute (column, field, or equivalent). + pub tenant_key: String, + pub operations: Vec, +} + +#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +pub struct TenantSecurityPolicy { + pub schema_version: String, + pub policy_id: String, + pub revision: u64, + pub tenant_identity_claim: String, + pub resources: Vec, +} + +#[derive(Clone, Debug, Eq, PartialEq)] +pub enum PolicyValidationError { + UnsupportedSchemaVersion, + EmptyPolicyId, + PolicyIdTooLong, + ZeroRevision, + EmptyTenantIdentityClaim, + TenantIdentityClaimTooLong, + NoProtectedResources, + TooManyResources, + EmptyResourceName, + ResourceNameTooLong, + EmptyNamespace, + NamespaceTooLong, + EmptyTenantKey, + TenantKeyTooLong, + NoOperations, + DuplicateResource, + DuplicateOperation, +} + +impl TenantSecurityPolicy { + /// Validate the database-neutral policy envelope before an adapter compiles it. + pub fn validate(&self) -> Result<(), PolicyValidationError> { + if self.schema_version != SECURITY_MODEL_VERSION { + return Err(PolicyValidationError::UnsupportedSchemaVersion); + } + if self.policy_id.trim().is_empty() || self.policy_id.contains('\0') { + return Err(PolicyValidationError::EmptyPolicyId); + } + if self.policy_id.chars().count() > 128 { + return Err(PolicyValidationError::PolicyIdTooLong); + } + if self.revision == 0 { + return Err(PolicyValidationError::ZeroRevision); + } + if self.tenant_identity_claim.trim().is_empty() || self.tenant_identity_claim.contains('\0') { + return Err(PolicyValidationError::EmptyTenantIdentityClaim); + } + if self.tenant_identity_claim.chars().count() > 128 { + return Err(PolicyValidationError::TenantIdentityClaimTooLong); + } + if self.resources.is_empty() { + return Err(PolicyValidationError::NoProtectedResources); + } + if self.resources.len() > 1000 { + return Err(PolicyValidationError::TooManyResources); + } + + let mut resources = HashSet::new(); + for item in &self.resources { + if item.resource.name.trim().is_empty() || item.resource.name.contains('\0') { + return Err(PolicyValidationError::EmptyResourceName); + } + if item.resource.name.chars().count() > 256 { + return Err(PolicyValidationError::ResourceNameTooLong); + } + if let Some(namespace) = item.resource.namespace.as_deref() { + if namespace.trim().is_empty() || namespace.contains('\0') { + return Err(PolicyValidationError::EmptyNamespace); + } + if namespace.chars().count() > 256 { + return Err(PolicyValidationError::NamespaceTooLong); + } + } + if item.tenant_key.trim().is_empty() || item.tenant_key.contains('\0') { + return Err(PolicyValidationError::EmptyTenantKey); + } + if item.tenant_key.chars().count() > 256 { + return Err(PolicyValidationError::TenantKeyTooLong); + } + if item.operations.is_empty() { + return Err(PolicyValidationError::NoOperations); + } + if !resources.insert(item.resource.clone()) { + return Err(PolicyValidationError::DuplicateResource); + } + let mut operations = HashSet::new(); + if item.operations.iter().any(|operation| !operations.insert(*operation)) { + return Err(PolicyValidationError::DuplicateOperation); + } + } + Ok(()) + } +} + +#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)] +#[serde(rename_all = "snake_case")] +pub enum InspectionCompleteness { + Complete, + Incomplete, + Unavailable, +} + +#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)] +#[serde(rename_all = "snake_case")] +pub enum SecurityPosture { + Verified, + NeedsAttention, + Blocked, + Unknown, + Degraded, +} + +#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)] +#[serde(rename_all = "snake_case")] +pub enum AccessDecision { + Allow, + Deny, +} + +#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)] +pub struct SecurityFinding { + pub code: String, + pub resource: Option, + pub detail: String, +} + +#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)] +pub struct VerificationReport { + pub model_version: String, + pub posture: SecurityPosture, + pub inspection: InspectionCompleteness, + pub findings: Vec, +} + +impl VerificationReport { + /// Fail closed: an incomplete, unavailable, degraded, unknown, or failing + /// inspection can never be converted into an allow decision. + pub fn access_decision(&self) -> AccessDecision { + if self.model_version == SECURITY_MODEL_VERSION + && self.posture == SecurityPosture::Verified + && self.inspection == InspectionCompleteness::Complete + && self.findings.is_empty() + { + AccessDecision::Allow + } else { + AccessDecision::Deny + } + } +} + +#[cfg(test)] +mod tests { + use super::*; + + fn valid_policy() -> TenantSecurityPolicy { + TenantSecurityPolicy { + schema_version: SECURITY_MODEL_VERSION.into(), + policy_id: "invoices".into(), + revision: 1, + tenant_identity_claim: "tenant_id".into(), + resources: vec![ProtectedResource { + resource: ResourceRef { + namespace: Some("public".into()), + name: "invoices".into(), + kind: ResourceKind::Table, + }, + tenant_key: "tenant_id".into(), + operations: vec![Operation::Read, Operation::Create, Operation::Update, Operation::Delete], + }], + } + } + + #[test] + fn accepts_a_valid_database_neutral_policy() { + assert!(valid_policy().validate().is_ok()); + } + + #[test] + fn rejects_duplicate_resources_and_operations() { + let mut policy = valid_policy(); + policy.resources.push(policy.resources[0].clone()); + assert_eq!(policy.validate(), Err(PolicyValidationError::DuplicateResource)); + + let mut policy = valid_policy(); + policy.resources[0].operations.push(Operation::Read); + assert_eq!(policy.validate(), Err(PolicyValidationError::DuplicateOperation)); + } + + #[test] + fn rejects_unknown_schema_and_empty_ownership_key() { + let mut policy = valid_policy(); + policy.schema_version = "future.version".into(); + assert_eq!(policy.validate(), Err(PolicyValidationError::UnsupportedSchemaVersion)); + + let mut policy = valid_policy(); + policy.resources[0].tenant_key.clear(); + assert_eq!(policy.validate(), Err(PolicyValidationError::EmptyTenantKey)); + } + + #[test] + fn enforces_the_shared_schema_limits_and_rejects_unknown_fields() { + let mut policy = valid_policy(); + policy.policy_id = "x".repeat(129); + assert_eq!(policy.validate(), Err(PolicyValidationError::PolicyIdTooLong)); + + let mut policy = valid_policy(); + policy.resources[0].resource.namespace = Some(" ".into()); + assert_eq!(policy.validate(), Err(PolicyValidationError::EmptyNamespace)); + + let mut policy = valid_policy(); + policy.resources[0].tenant_key = "k".repeat(257); + assert_eq!(policy.validate(), Err(PolicyValidationError::TenantKeyTooLong)); + + let unknown_field = r#"{ + "schema_version":"proxima.security.v1","policy_id":"p","revision":1, + "tenant_identity_claim":"tenant_id","unexpected":true, + "resources":[{"resource":{"name":"invoices","kind":"table"},"tenant_key":"tenant_id","operations":["read"]}] + }"#; + assert!(serde_json::from_str::(unknown_field).is_err()); + } + + #[test] + fn only_complete_verified_inspection_can_allow_access() { + let verified = VerificationReport { + model_version: SECURITY_MODEL_VERSION.into(), + posture: SecurityPosture::Verified, + inspection: InspectionCompleteness::Complete, + findings: vec![], + }; + assert_eq!(verified.access_decision(), AccessDecision::Allow); + + let mut unknown_model = verified.clone(); + unknown_model.model_version = "future.security.model".into(); + assert_eq!(unknown_model.access_decision(), AccessDecision::Deny); + + for (posture, inspection) in [ + (SecurityPosture::Verified, InspectionCompleteness::Unavailable), + (SecurityPosture::Verified, InspectionCompleteness::Incomplete), + (SecurityPosture::Unknown, InspectionCompleteness::Complete), + (SecurityPosture::Degraded, InspectionCompleteness::Complete), + (SecurityPosture::NeedsAttention, InspectionCompleteness::Complete), + (SecurityPosture::Blocked, InspectionCompleteness::Complete), + ] { + let report = VerificationReport { + model_version: SECURITY_MODEL_VERSION.into(), + posture, + inspection, + findings: vec![], + }; + assert_eq!(report.access_decision(), AccessDecision::Deny); + } + } + + #[test] + fn supported_maturity_requires_the_complete_end_to_end_capability_set() { + let complete = AdapterCapabilities { + schema_inspection: true, + tenant_identity_enforcement: true, + policy_semantic_verification: true, + policy_generation: true, + controlled_policy_deployment: true, + drift_detection: true, + runtime_fail_closed_admission: true, + signed_security_evidence: true, + }; + assert!(complete.is_production_complete()); + for field in 0..8 { + let mut partial = complete; + match field { + 0 => partial.schema_inspection = false, + 1 => partial.tenant_identity_enforcement = false, + 2 => partial.policy_semantic_verification = false, + 3 => partial.policy_generation = false, + 4 => partial.controlled_policy_deployment = false, + 5 => partial.drift_detection = false, + 6 => partial.runtime_fail_closed_admission = false, + _ => partial.signed_security_evidence = false, + } + assert!(!partial.is_production_complete()); + } + } + + #[test] + fn planned_adapters_make_no_unsupported_capability_claims() { + let catalog = adapter_catalog(); + assert_eq!(catalog.len(), 13); + for adapter in catalog.iter().filter(|adapter| adapter.maturity == AdapterMaturity::Planned) { + assert_eq!(adapter.capabilities, AdapterCapabilities::default()); + } + } +} diff --git a/crates/proxima-engine/src/security_core_coordinator.rs b/crates/proxima-engine/src/security_core_coordinator.rs new file mode 100644 index 00000000..71e45860 --- /dev/null +++ b/crates/proxima-engine/src/security_core_coordinator.rs @@ -0,0 +1,629 @@ +//! Fail-closed orchestration for the database-independent Security Core. +//! +//! This module centralizes the inspection, compilation and drift lifecycle. It +//! deliberately does not apply generated policy: native changes require a +//! separately authorized deployment workflow. + +use crate::connection_admission::ConnectionAdmissionGate; +use crate::database_adapter::{AdapterError, AdapterRegistry, AdapterTarget, CompiledPolicy, DriftReport, InspectionRequest, InspectionSnapshot}; +use crate::policy_evidence::{EvidenceError, PolicyEvidenceAuthority, SignedPolicyAdmission, SignedPolicyEvidence}; +use crate::tenant_identity::VerifiedTenantIdentity; +use crate::security_core::{AccessDecision, DatabaseKind, InspectionCompleteness, SecurityFinding, SecurityPosture, TenantSecurityPolicy, VerificationReport, SECURITY_MODEL_VERSION}; +use std::collections::HashSet; + +#[derive(Clone, Debug, Eq, PartialEq)] +pub enum SecurityCoreError { + AdapterUnavailable(DatabaseKind), + InvalidPolicy, + Adapter(AdapterError), + SnapshotTargetMismatch, + SnapshotKindMismatch, + IncompleteInspection, + DuplicateInspectedResource(String), + InvalidCompilation, + DriftInspectionIncomplete, + DriftFingerprintMismatch, + InvalidFingerprint, + DuplicateCompiledResource(String), + Admission(EvidenceError), + IdentityScopeMismatch, + EvidenceScopeMismatch, + EvidenceCoverageIncomplete, +} + +impl From for SecurityCoreError { + fn from(error: AdapterError) -> Self { Self::Adapter(error) } +} + +impl From for SecurityCoreError { + fn from(error: EvidenceError) -> Self { Self::Admission(error) } +} + +pub struct SecurityCoreCoordinator { registry: AdapterRegistry } + +impl SecurityCoreCoordinator { + pub fn new(registry: AdapterRegistry) -> Self { Self { registry } } + pub fn registry(&self) -> &AdapterRegistry { &self.registry } + + /// Generate a reviewable native plan. Applying it is intentionally separate. + pub fn compile(&self, kind: DatabaseKind, policy: &TenantSecurityPolicy) -> Result { + policy.validate().map_err(|_| SecurityCoreError::InvalidPolicy)?; + let adapter = self.registry.get(kind).ok_or(SecurityCoreError::AdapterUnavailable(kind))?; + let compiled = adapter.compile_policy(policy)?; + if compiled.database_kind != kind || compiled.policy_id != policy.policy_id || compiled.revision != policy.revision || !compiled.requires_approval || compiled.changes.is_empty() { + return Err(SecurityCoreError::InvalidCompilation); + } + let mut covered = HashSet::new(); + for change in &compiled.changes { + if change.action.trim().is_empty() || change.definition.is_null() { return Err(SecurityCoreError::InvalidCompilation); } + if !covered.insert(change.resource.resource.clone()) { + return Err(SecurityCoreError::DuplicateCompiledResource(change.resource.resource.name.clone())); + } + } + if covered.len() != policy.resources.len() + || policy.resources.iter().any(|item| !covered.contains(&item.resource)) + { + return Err(SecurityCoreError::InvalidCompilation); + } + for change in &compiled.changes { + let Some(required) = policy.resources.iter().find(|item| item.resource == change.resource.resource) else { + return Err(SecurityCoreError::InvalidCompilation); + }; + if change.resource.tenant_key != required.tenant_key + || required.operations.iter().any(|operation| !change.resource.operations.contains(operation)) + { + return Err(SecurityCoreError::InvalidCompilation); + } + } + Ok(compiled) + } + + /// Inspect and semantically verify native state. Any missing resource or + /// operation, incomplete inspection, finding, or identity mismatch denies. + pub async fn inspect_and_verify(&self, kind: DatabaseKind, request: &InspectionRequest) -> Result { + self.inspect_and_verify_snapshot(kind, request).await.map(|(report, _)| report) + } + + /// Inspect and semantically verify native state. Any missing resource or + /// operation, incomplete inspection, finding, or identity mismatch denies. + async fn inspect_and_verify_snapshot(&self, kind: DatabaseKind, request: &InspectionRequest) -> Result<(VerificationReport, InspectionSnapshot), SecurityCoreError> { + request.policy.validate().map_err(|_| SecurityCoreError::InvalidPolicy)?; + let adapter = self.registry.get(kind).ok_or(SecurityCoreError::AdapterUnavailable(kind))?; + let snapshot = adapter.inspect(request).await?; + self.validate_snapshot(kind, request, &snapshot)?; + let mut report = adapter.verify(&request.policy, &snapshot).await?; + let mut failures = Vec::new(); + if snapshot.completeness != InspectionCompleteness::Complete || snapshot.posture != SecurityPosture::Verified || !snapshot.findings.is_empty() { + failures.push(SecurityFinding { code: "native_inspection_not_clean".into(), resource: None, detail: "Native inspection is incomplete or reports an unverified posture.".into() }); + failures.extend(snapshot.findings.iter().cloned()); + } + let mut seen = HashSet::new(); + for item in &snapshot.resources { + if !seen.insert(item.resource.resource.clone()) { return Err(SecurityCoreError::DuplicateInspectedResource(item.resource.resource.name.clone())); } + } + for required in &request.policy.resources { + let Some(actual) = snapshot.resources.iter().find(|item| item.resource.resource == required.resource) else { + failures.push(SecurityFinding { code: "required_resource_not_inspected".into(), resource: Some(required.resource.clone()), detail: "A protected resource is absent from the inspection snapshot.".into() }); + continue; + }; + if actual.completeness != InspectionCompleteness::Complete || actual.posture != SecurityPosture::Verified || !actual.findings.is_empty() { + failures.push(SecurityFinding { code: "resource_posture_not_verified".into(), resource: Some(required.resource.clone()), detail: "The protected resource is incomplete or has native findings.".into() }); + failures.extend(actual.findings.iter().cloned()); + } + if actual.resource.tenant_key != required.tenant_key { + failures.push(SecurityFinding { code: "tenant_ownership_key_mismatch".into(), resource: Some(required.resource.clone()), detail: "The inspected native tenant ownership key differs from the approved policy.".into() }); + } + for operation in &required.operations { + if !actual.verified_operations.contains(operation) { + failures.push(SecurityFinding { code: "operation_not_verified".into(), resource: Some(required.resource.clone()), detail: format!("Native enforcement for {operation:?} was not verified.") }); + } + } + } + if report.model_version != SECURITY_MODEL_VERSION || report.posture != SecurityPosture::Verified || report.inspection != InspectionCompleteness::Complete || !report.findings.is_empty() { + failures.push(SecurityFinding { code: "semantic_verification_denied".into(), resource: None, detail: "The adapter did not return a clean, complete semantic verification.".into() }); + } + if !failures.is_empty() { + report.posture = SecurityPosture::Blocked; + report.inspection = InspectionCompleteness::Incomplete; + report.findings.extend(failures); + } + // Preserve the adapter's model version: an unknown version must never + // be normalized into the current model and accidentally accepted. + if report.access_decision() != AccessDecision::Allow { + return Ok((report, snapshot)); + } + Ok((report, snapshot)) + } + + /// Perform current native inspection, bind signed probe evidence to that + /// exact inspection and consume both the verified tenant identity and the + /// admission exactly once. The generic evidence format is resource-agnostic, + /// so this path fails closed for multi-resource policies until per-resource + /// semantic evidence is available. + pub async fn inspect_and_admit( + &self, + kind: DatabaseKind, + request: &InspectionRequest, + identity: &VerifiedTenantIdentity, + evidence_authority: &PolicyEvidenceAuthority, + evidence: &SignedPolicyEvidence, + admission: &SignedPolicyAdmission, + gate: &ConnectionAdmissionGate, + connection_id: &str, + now_unix: i64, + ) -> Result { + if identity.database_kind() != kind + || identity.target_id() != request.target.target_id + || identity.policy_id() != request.policy.policy_id + || identity.policy_revision() != request.policy.revision + { + return Err(SecurityCoreError::IdentityScopeMismatch); + } + let (report, snapshot) = self.inspect_and_verify_snapshot(kind, request).await?; + if report.access_decision() != AccessDecision::Allow { + return Ok(AccessDecision::Deny); + } + evidence_authority.verify_evidence(evidence)?; + let payload = &evidence.payload; + let current_fingerprint = snapshot.fingerprint.as_deref() + .ok_or(SecurityCoreError::EvidenceScopeMismatch)?; + if payload.database_kind != kind + || payload.policy_id != request.policy.policy_id + || payload.policy_revision != request.policy.revision + || payload.target_id != request.target.target_id + || payload.tenant_id != identity.tenant_id() + || payload.fingerprint != current_fingerprint + { + return Err(SecurityCoreError::EvidenceScopeMismatch); + } + if !same_protected_resource_scope(&request.policy.resources, &payload.protected_resources) { + return Err(SecurityCoreError::EvidenceCoverageIncomplete); + } + let required_operations: HashSet<_> = request.policy.resources.iter() + .flat_map(|resource| resource.operations.iter().copied()) + .collect(); + let evidenced_operations: HashSet<_> = payload.verified_operations.iter().copied().collect(); + let declared_operation_count: usize = request.policy.resources.iter() + .map(|resource| resource.operations.len()) + .sum(); + if required_operations.len() != declared_operation_count + || evidenced_operations.len() != payload.verified_operations.len() + || evidenced_operations != required_operations + { + return Err(SecurityCoreError::EvidenceCoverageIncomplete); + } + gate.consume_for_identity( + evidence_authority, + admission, + evidence, + identity, + connection_id, + now_unix, + ).map_err(SecurityCoreError::Admission) + } + + + pub async fn detect_drift(&self, kind: DatabaseKind, target: &AdapterTarget, previous_fingerprint: Option<&str>) -> Result { + let adapter = self.registry.get(kind).ok_or(SecurityCoreError::AdapterUnavailable(kind))?; + let report = adapter.detect_drift(target, previous_fingerprint).await?; + if report.database_kind != kind || report.target != *target { return Err(SecurityCoreError::SnapshotTargetMismatch); } + if report.completeness != InspectionCompleteness::Complete { return Err(SecurityCoreError::DriftInspectionIncomplete); } + if report.previous_fingerprint.as_deref() != previous_fingerprint { + return Err(SecurityCoreError::DriftFingerprintMismatch); + } + if previous_fingerprint.is_some_and(|value| !is_sha256(value)) { + return Err(SecurityCoreError::DriftFingerprintMismatch); + } + if report.observed_at.trim().is_empty() || report.observed_fingerprint.as_deref().map_or(true, |value| !is_sha256(value)) { + return Err(SecurityCoreError::DriftInspectionIncomplete); + } + if let (Some(previous), Some(observed)) = (previous_fingerprint, report.observed_fingerprint.as_deref()) { + let actual_drift = previous != observed; + if report.detected != actual_drift { return Err(SecurityCoreError::DriftFingerprintMismatch); } + } else if report.detected { + // Without a trusted baseline, an adapter cannot assert that drift + // was or was not detected. Establish the first baseline as clean only. + return Err(SecurityCoreError::DriftFingerprintMismatch); + } + if report.detected && report.findings.is_empty() { + return Err(SecurityCoreError::DriftFingerprintMismatch); + } + Ok(report) + } + + fn validate_snapshot(&self, kind: DatabaseKind, request: &InspectionRequest, snapshot: &InspectionSnapshot) -> Result<(), SecurityCoreError> { + if snapshot.database_kind != kind { return Err(SecurityCoreError::SnapshotKindMismatch); } + if snapshot.target != request.target { return Err(SecurityCoreError::SnapshotTargetMismatch); } + if snapshot.observed_at.trim().is_empty() { return Err(SecurityCoreError::IncompleteInspection); } + if snapshot.fingerprint.as_deref().map_or(true, |value| !is_sha256(value)) { + return Err(SecurityCoreError::InvalidFingerprint); + } + for resource in &snapshot.resources { + if resource.fingerprint.as_deref().map_or(true, |value| !is_sha256(value)) { + return Err(SecurityCoreError::InvalidFingerprint); + } + } + Ok(()) + } +} + + +fn same_protected_resource_scope( + expected: &[crate::security_core::ProtectedResource], + observed: &[crate::security_core::ProtectedResource], +) -> bool { + expected.len() == observed.len() + && expected.iter().all(|resource| observed.contains(resource)) +} + +fn is_sha256(value: &str) -> bool { + value.len() == 64 && value.bytes().all(|byte| byte.is_ascii_hexdigit()) +} + + +#[cfg(test)] +mod tests { + use super::*; + use crate::connection_admission::ConnectionAdmissionGate; + use crate::database_adapter::{AdapterFuture, DatabaseAdapter, ResourceInspection}; + use crate::policy_evidence::{EvidenceCheck, EvidenceCheckKind, PolicyEvidenceAuthority, PolicyEvidencePayload}; + use crate::tenant_identity::{TenantIdentityAuthority, TenantIdentityClaims, TenantIdentityExpectation}; + use crate::security_core::{ + AdapterCapabilities, AdapterDescriptor, AdapterMaturity, Operation, + ProtectedResource, ResourceKind, ResourceRef, SECURITY_MODEL_VERSION, + }; + + struct FixtureAdapter { omit_read: bool, wrong_tenant_key: bool, lie_about_previous: bool, omit_fingerprint: bool } + + impl DatabaseAdapter for FixtureAdapter { + fn descriptor(&self) -> AdapterDescriptor { + AdapterDescriptor { + kind: DatabaseKind::PostgreSql, + name: "fixture-postgresql", + maturity: AdapterMaturity::Supported, + capabilities: AdapterCapabilities { + schema_inspection: true, + tenant_identity_enforcement: true, + policy_semantic_verification: true, + policy_generation: true, + controlled_policy_deployment: true, + drift_detection: true, + runtime_fail_closed_admission: true, + signed_security_evidence: true, + }, + status_note: "test fixture", + } + } + + fn inspect<'a>(&'a self, request: &'a InspectionRequest) -> AdapterFuture<'a, Result> { + let resources = request.policy.resources.iter().cloned().map(|mut resource| { + if self.wrong_tenant_key { + resource.tenant_key = "account_id".into(); + } + let mut operations = resource.operations.clone(); + if self.omit_read { + operations.retain(|operation| *operation != Operation::Read); + } + ResourceInspection { + resource, + completeness: InspectionCompleteness::Complete, + posture: SecurityPosture::Verified, + verified_operations: operations, + findings: Vec::new(), + fingerprint: if self.omit_fingerprint { None } else { Some("a".repeat(64)) }, + } + }).collect(); + let omit_fingerprint = self.omit_fingerprint; + Box::pin(async move { + Ok(InspectionSnapshot { + database_kind: DatabaseKind::PostgreSql, + target: request.target.clone(), + completeness: InspectionCompleteness::Complete, + posture: SecurityPosture::Verified, + resources, + findings: Vec::new(), + fingerprint: if omit_fingerprint { None } else { Some("a".repeat(64)) }, + observed_at: "2026-11-17T00:00:00Z".into(), + }) + }) + } + + fn compile_policy(&self, policy: &TenantSecurityPolicy) -> Result { + Ok(CompiledPolicy { + database_kind: DatabaseKind::PostgreSql, + policy_id: policy.policy_id.clone(), + revision: policy.revision, + changes: policy.resources.iter().map(|resource| { + let mut resource = resource.clone(); + if self.wrong_tenant_key { resource.tenant_key = "account_id".into(); } + crate::database_adapter::NativePolicyChange { + resource, + action: "reviewed_change".into(), + definition: serde_json::json!({"kind":"fixture"}), + } + }).collect(), + requires_approval: true, + }) + } + + fn verify<'a>(&'a self, _policy: &'a TenantSecurityPolicy, _snapshot: &'a InspectionSnapshot) -> AdapterFuture<'a, Result> { + Box::pin(async { + Ok(VerificationReport { + model_version: SECURITY_MODEL_VERSION.into(), + posture: SecurityPosture::Verified, + inspection: InspectionCompleteness::Complete, + findings: Vec::new(), + }) + }) + } + + fn detect_drift<'a>(&'a self, target: &'a AdapterTarget, previous_fingerprint: Option<&'a str>) -> AdapterFuture<'a, Result> { + Box::pin(async move { + Ok(DriftReport { + database_kind: DatabaseKind::PostgreSql, + target: target.clone(), + detected: previous_fingerprint.is_some_and(|value| value != "a".repeat(64)), + completeness: InspectionCompleteness::Complete, + previous_fingerprint: if self.lie_about_previous { Some("f".repeat(64)) } else { previous_fingerprint.map(str::to_owned) }, + observed_fingerprint: Some("a".repeat(64)), + findings: Vec::new(), + observed_at: "2026-11-17T00:00:00Z".into(), + }) + }) + } + } + + fn request() -> InspectionRequest { + InspectionRequest { + target: AdapterTarget { + target_id: "fixture-target".into(), + database_name: "app".into(), + namespace: Some("public".into()), + }, + policy: TenantSecurityPolicy { + schema_version: SECURITY_MODEL_VERSION.into(), + policy_id: "tenant-boundary".into(), + revision: 1, + tenant_identity_claim: "tenant_id".into(), + resources: vec![ProtectedResource { + resource: ResourceRef { + namespace: Some("public".into()), + name: "records".into(), + kind: ResourceKind::Table, + }, + tenant_key: "tenant_id".into(), + operations: vec![Operation::Read, Operation::Create, Operation::Update, Operation::Delete], + }], + }, + } + } + + fn identity(request: &InspectionRequest, now: i64) -> crate::tenant_identity::VerifiedTenantIdentity { + let authority = TenantIdentityAuthority::new(vec![31; 32]).unwrap(); + let claims = TenantIdentityClaims { + schema_version: "proxima.tenant-identity.v1".into(), + tenant_id: "tenant-a".into(), + principal_id: "app-service".into(), + target_id: request.target.target_id.clone(), + database_kind: DatabaseKind::PostgreSql, + policy_id: request.policy.policy_id.clone(), + policy_revision: request.policy.revision, + request_id: "550e8400-e29b-41d4-a716-446655440001".into(), + issued_at_unix: now, + expires_at_unix: now + 30, + }; + let expected = TenantIdentityExpectation { + tenant_id: "tenant-a", + principal_id: "app-service", + target_id: &request.target.target_id, + database_kind: DatabaseKind::PostgreSql, + policy_id: &request.policy.policy_id, + policy_revision: request.policy.revision, + }; + let token = authority.sign(&claims, now).unwrap(); + authority.verify(&token, expected, now).unwrap() + } + + fn signed_evidence( + request: &InspectionRequest, + resources: Vec, + now: i64, + ) -> ( + PolicyEvidenceAuthority, + crate::policy_evidence::SignedPolicyEvidence, + crate::policy_evidence::SignedPolicyAdmission, + ) { + let mut operations = Vec::new(); + let mut checks = Vec::new(); + for resource in &resources { + for operation in &resource.operations { + if !operations.contains(operation) { + operations.push(*operation); + } + checks.push(EvidenceCheck { + resource: resource.resource.clone(), + operation: *operation, + kind: EvidenceCheckKind::OwnTenantAllow, + passed: true, + detail: "own-tenant operation probe passed".into(), + }); + checks.push(EvidenceCheck { + resource: resource.resource.clone(), + operation: *operation, + kind: EvidenceCheckKind::CrossTenantDeny, + passed: true, + detail: "cross-tenant operation probe denied".into(), + }); + if matches!(operation, Operation::Create | Operation::Update | Operation::Delete) { + checks.push(EvidenceCheck { + resource: resource.resource.clone(), + operation: *operation, + kind: EvidenceCheckKind::MutationRollback, + passed: true, + detail: "mutation probe rolled back".into(), + }); + } + } + } + let authority = PolicyEvidenceAuthority::new(vec![41; 32], vec![43; 32]).unwrap(); + let evidence = authority.sign_evidence(PolicyEvidencePayload { + model_version: SECURITY_MODEL_VERSION.into(), + policy_id: request.policy.policy_id.clone(), + policy_revision: request.policy.revision, + database_kind: DatabaseKind::PostgreSql, + target_id: request.target.target_id.clone(), + tenant_id: "tenant-a".into(), + posture: SecurityPosture::Verified, + inspection: InspectionCompleteness::Complete, + findings: Vec::new(), + protected_resources: resources, + verified_operations: operations, + fingerprint: "a".repeat(64), + observed_at_unix: now - 1, + checks, + }).unwrap(); + let admission = authority.issue_admission(&evidence, now, 30).unwrap(); + (authority, evidence, admission) + } + + fn two_resource_request() -> InspectionRequest { + let mut request = request(); + let mut second = request.policy.resources[0].clone(); + second.resource.name = "invoices".into(); + request.policy.resources.push(second); + request + } + + fn coordinator(omit_read: bool) -> SecurityCoreCoordinator { + let mut registry = AdapterRegistry::default(); + registry.register(std::sync::Arc::new(FixtureAdapter { omit_read, wrong_tenant_key: false, lie_about_previous: false, omit_fingerprint: false })).unwrap(); + SecurityCoreCoordinator::new(registry) + } + + #[test] + fn fingerprint_validator_rejects_malformed_digests() { + assert!(!is_sha256("")); + assert!(!is_sha256("not-a-digest")); + assert!(!is_sha256(&"g".repeat(64))); + assert!(is_sha256(&"a".repeat(64))); + } + + #[tokio::test] + async fn missing_native_fingerprint_fails_closed() { + let mut registry = AdapterRegistry::default(); + registry.register(std::sync::Arc::new(FixtureAdapter { + omit_read: false, + wrong_tenant_key: false, + lie_about_previous: false, + omit_fingerprint: true, + })).unwrap(); + let coordinator = SecurityCoreCoordinator::new(registry); + assert_eq!( + coordinator.inspect_and_verify(DatabaseKind::PostgreSql, &request()).await, + Err(SecurityCoreError::InvalidFingerprint) + ); + } + + #[tokio::test] + async fn complete_native_operation_coverage_allows() { + let coordinator = coordinator(false); + let report = coordinator.inspect_and_verify(DatabaseKind::PostgreSql, &request()).await.unwrap(); + assert_eq!(report.access_decision(), AccessDecision::Allow); + } + + #[tokio::test] + async fn missing_native_operation_coverage_denies() { + let coordinator = coordinator(true); + let report = coordinator.inspect_and_verify(DatabaseKind::PostgreSql, &request()).await.unwrap(); + assert_eq!(report.access_decision(), AccessDecision::Deny); + assert!(report.findings.iter().any(|finding| finding.code == "operation_not_verified")); + } + + #[test] + fn compilation_rejects_a_different_tenant_ownership_key() { + let mut registry = AdapterRegistry::default(); + registry.register(std::sync::Arc::new(FixtureAdapter { omit_read: false, wrong_tenant_key: true, lie_about_previous: false, omit_fingerprint: false })).unwrap(); + let coordinator = SecurityCoreCoordinator::new(registry); + assert_eq!(coordinator.compile(DatabaseKind::PostgreSql, &request().policy), Err(SecurityCoreError::InvalidCompilation)); + } + + #[tokio::test] + async fn mismatched_native_tenant_key_denies_admission() { + let mut registry = AdapterRegistry::default(); + registry.register(std::sync::Arc::new(FixtureAdapter { omit_read: false, wrong_tenant_key: true, lie_about_previous: false, omit_fingerprint: false })).unwrap(); + let coordinator = SecurityCoreCoordinator::new(registry); + let report = coordinator.inspect_and_verify(DatabaseKind::PostgreSql, &request()).await.unwrap(); + assert_eq!(report.access_decision(), AccessDecision::Deny); + assert!(report.findings.iter().any(|finding| finding.code == "tenant_ownership_key_mismatch")); + } + + #[tokio::test] + async fn drift_report_cannot_substitute_the_previous_fingerprint() { + let mut registry = AdapterRegistry::default(); + registry.register(std::sync::Arc::new(FixtureAdapter { + omit_read: false, + wrong_tenant_key: false, + lie_about_previous: true, + omit_fingerprint: false, + })).unwrap(); + let coordinator = SecurityCoreCoordinator::new(registry); + let target = request().target; + assert_eq!( + coordinator.detect_drift(DatabaseKind::PostgreSql, &target, Some(&"a".repeat(64))).await, + Err(SecurityCoreError::DriftFingerprintMismatch) + ); + } + + #[tokio::test] + async fn multi_resource_admission_requires_per_resource_probe_evidence() { + let request = two_resource_request(); + let now = 1_900_000_010; + let identity = identity(&request, now); + let coordinator = coordinator(false); + let gate = ConnectionAdmissionGate::new(); + let (authority, evidence, admission) = + signed_evidence(&request, vec![request.policy.resources[0].clone()], now); + + assert_eq!( + coordinator.inspect_and_admit( + DatabaseKind::PostgreSql, &request, &identity, &authority, + &evidence, &admission, &gate, "fixture-connection", now, + ).await, + Err(SecurityCoreError::EvidenceCoverageIncomplete) + ); + } + + #[tokio::test] + async fn complete_multi_resource_admission_consumes_identity_once() { + let request = two_resource_request(); + let now = 1_900_000_010; + let identity = identity(&request, now); + let coordinator = coordinator(false); + let gate = ConnectionAdmissionGate::new(); + let (authority, evidence, admission) = + signed_evidence(&request, request.policy.resources.clone(), now); + + assert_eq!( + coordinator.inspect_and_admit( + DatabaseKind::PostgreSql, &request, &identity, &authority, + &evidence, &admission, &gate, "fixture-connection", now, + ).await, + Ok(AccessDecision::Allow) + ); + assert!(matches!( + coordinator.inspect_and_admit( + DatabaseKind::PostgreSql, &request, &identity, &authority, + &evidence, &admission, &gate, "fixture-connection-2", now, + ).await, + Err(SecurityCoreError::Admission(error)) if error.code == "admission_replay_detected" + )); + } + + #[test] + fn compilation_requires_approval_and_covers_each_policy_resource() { + let coordinator = coordinator(false); + let compiled = coordinator.compile(DatabaseKind::PostgreSql, &request().policy).unwrap(); + assert!(compiled.requires_approval); + assert_eq!(compiled.changes.len(), 1); + } +} diff --git a/crates/proxima-engine/src/session.rs b/crates/proxima-engine/src/session.rs index 8ef65e07..186ba83d 100644 --- a/crates/proxima-engine/src/session.rs +++ b/crates/proxima-engine/src/session.rs @@ -3,6 +3,7 @@ use crate::protocol::{ AUTHENTICATION_TAG, AUTH_OK, ERROR_RESPONSE_TAG, READY_FOR_QUERY_TAG, }; use crate::tenant::{TenantContext, TenantTokenVerifier}; +use crate::sql_guard; use std::io; use tokio::io::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt}; @@ -18,6 +19,10 @@ const POSTGRES_IDENTIFIER_MAX_BYTES: usize = 63; #[derive(Debug, Clone, PartialEq, Eq)] pub struct EstablishedSession { pub tenant_context: Option, + /// Database selected by the PostgreSQL startup packet after Engine role routing. + pub database_name: String, + /// Withheld until policy admission and durable emergency audit complete. + pub ready_for_query: Option>, } pub async fn establish( @@ -35,13 +40,14 @@ pub async fn establish( } => { let (startup, tenant_context) = prepare_startup(protocol_version, parameters, verifier, tenant_role_prefix)?; + let database_name = database_name_from_startup(&startup); debug!( tenant_bound = tenant_context.is_some(), "PostgreSQL startup packet received" ); forward_startup(&mut upstream, &startup).await?; - broker_startup_authentication(&mut client, &mut upstream).await?; - Ok((client, upstream, EstablishedSession { tenant_context })) + let ready_for_query = broker_startup_authentication(&mut client, &mut upstream).await?; + Ok((client, upstream, EstablishedSession { tenant_context, database_name, ready_for_query: Some(ready_for_query) })) } StartupPacket::SslRequest => { upstream @@ -63,6 +69,8 @@ pub async fn establish( upstream, EstablishedSession { tenant_context: None, + database_name: String::new(), + ready_for_query: None, }, )); } @@ -79,9 +87,10 @@ pub async fn establish( verifier, tenant_role_prefix, )?; + let database_name = database_name_from_startup(&startup); forward_startup(&mut upstream, &startup).await?; - broker_startup_authentication(&mut client, &mut upstream).await?; - Ok((client, upstream, EstablishedSession { tenant_context })) + let ready_for_query = broker_startup_authentication(&mut client, &mut upstream).await?; + Ok((client, upstream, EstablishedSession { tenant_context, database_name, ready_for_query: Some(ready_for_query) })) } other => Err(io::Error::new( io::ErrorKind::InvalidData, @@ -106,6 +115,8 @@ pub async fn establish( upstream, EstablishedSession { tenant_context: None, + database_name: String::new(), + ready_for_query: None, }, )) } @@ -116,6 +127,17 @@ pub async fn establish( } } +fn database_name_from_startup(startup: &StartupPacket) -> String { + match startup { + StartupPacket::Startup { parameters, .. } => parameters.iter() + .find(|(key, _)| key == "database") + .map(|(_, value)| value.clone()) + .or_else(|| parameters.iter().find(|(key, _)| key == "user").map(|(_, value)| value.clone())) + .unwrap_or_default(), + _ => String::new(), + } +} + fn prepare_startup( protocol_version: i32, parameters: Vec<(String, String)>, @@ -170,6 +192,26 @@ fn prepare_startup( None => None, }; + if tenant_context.is_some() { + for (key, value) in &forwarded { + let key = key.to_ascii_lowercase(); + let value = value.trim().to_ascii_lowercase(); + let blocked = key == "role" + || key == "session_authorization" + || key == "replication" + || key == "row_security" + || key == "session_replication_role" + || key == "search_path" + || key == "options" && sql_guard::blocks_tenant_startup_options(value.as_str()); + if blocked { + return Err(io::Error::new( + io::ErrorKind::PermissionDenied, + "tenant-bound PostgreSQL startup options cannot change roles, row security, or search_path", + )); + } + } + } + if let Some(context) = tenant_context.as_ref() { let normalized_tenant_id = context.tenant_id.replace('-', "_"); let role = format!("{tenant_role_prefix}{normalized_tenant_id}"); @@ -243,12 +285,11 @@ fn extract_tenant_token_from_options(value: &str) -> io::Result<(String, Option< async fn broker_startup_authentication( client: &mut dyn PgStream, upstream: &mut dyn PgStream, -) -> io::Result<()> { +) -> io::Result> { let mut authenticated = false; loop { let frame = read_backend_frame(upstream).await?; - client.write_all(&frame).await?; let message = parse_backend_frame(&frame) .map_err(|error| io::Error::new(io::ErrorKind::InvalidData, error.to_string()))? @@ -258,6 +299,7 @@ async fn broker_startup_authentication( .0; if message.tag == ERROR_RESPONSE_TAG { + client.write_all(&frame).await?; return Err(io::Error::new( io::ErrorKind::PermissionDenied, "PostgreSQL authentication/startup failed", @@ -289,8 +331,10 @@ async fn broker_startup_authentication( "PostgreSQL session became ready without AuthenticationOk", )); } - return Ok(()); + return Ok(frame); } + + client.write_all(&frame).await?; } } @@ -491,6 +535,30 @@ mod tests { assert_eq!(error.kind(), io::ErrorKind::PermissionDenied); } + #[test] + fn rejects_replication_and_security_startup_parameters() { + let verifier=verifier(); + let token=verifier.sign_for_test("tenant_a",u64::MAX); + for (key,value) in [ + ("replication","database"), + ("row_security","on"), + ("row_security","off"), + ("session_replication_role","origin"), + ("session_replication_role","replica"), + ("search_path","public"), + ("role","proxima_tenant_other"), + ("session_authorization","other_user"), + ] { + let error=prepare_startup( + crate::protocol::PROTOCOL_3_0, + vec![(TENANT_TOKEN_PARAMETER.into(),token.clone()),(key.into(),value.into())], + Some(&verifier), + "proxima_tenant_", + ).unwrap_err(); + assert_eq!(error.kind(),io::ErrorKind::PermissionDenied,"parameter {key}"); + } + } + #[test] fn extracts_token_from_libpq_options() { let verifier = verifier(); diff --git a/crates/proxima-engine/src/sql_guard.rs b/crates/proxima-engine/src/sql_guard.rs new file mode 100644 index 00000000..23ddcd37 --- /dev/null +++ b/crates/proxima-engine/src/sql_guard.rs @@ -0,0 +1,205 @@ +use sqlparser::{dialect::PostgreSqlDialect, parser::Parser}; + +/// Conservatively rejects statements that can change the effective PostgreSQL +/// identity, weaken row security, bypass RLS operations, or alter the policy +/// boundary for a tenant-bound session. PostgreSQL remains the syntax authority. +pub fn blocks_tenant_session_mutation(sql: &str) -> bool { + let dialect = PostgreSqlDialect {}; + if Parser::parse_sql(&dialect, sql).is_err() { + // Never forward tenant-bound SQL that the PostgreSQL dialect parser cannot validate. + return true; + } + let Ok(tokens) = sqlparser::tokenizer::Tokenizer::new(&dialect, sql).tokenize() else { + // A tenant-bound session must not forward SQL the guard cannot tokenize. + return true; + }; + let tokens: Vec = tokens.iter().map(|token| { + token.to_string().to_ascii_lowercase().replace('"', "") + }).collect(); + let at = |index: usize, expected: &str| tokens.get(index).is_some_and(|value| value == expected); + + if tokens.iter().any(|token| token.trim_matches('"').ends_with("set_config")) { + return true; + } + + for index in 0..tokens.len() { + let statement_start = index == 0 || at(index - 1, ";"); + if !statement_start { continue; } + + if at(index,"do") || at(index,"call") || at(index,"truncate") + || at(index,"grant") || at(index,"revoke") + || at(index,"discard") && at(index+1,"all") + || at(index,"comment") && at(index+1,"on") + || at(index,"refresh") && at(index+1,"materialized") && at(index+2,"view") + || at(index,"reset") && (at(index+1,"all") || at(index+1,"role") + || at(index+1,"row_security") || at(index+1,"search_path") || at(index+1,"schema") + || at(index+1,"session") && at(index+2,"authorization")) { + return true; + } + + if at(index,"set") { + let mut cursor=index+1; + if at(cursor,"session") && at(cursor+1,"authorization") { return true; } + if at(cursor,"session") || at(cursor,"local") { cursor+=1; } + if at(cursor,"session") && at(cursor+1,"authorization") { return true; } + if at(cursor,"role") || at(cursor,"session_authorization") + || at(cursor,"row_security") || at(cursor,"session_replication_role") + || at(cursor,"search_path") || at(cursor,"schema") { + return true; + } + } + + // Tenant-bound sessions are not database-administration sessions. Reject + // DDL wholesale so CREATE/ALTER/DROP variants cannot introduce views, + // routines, rules, triggers, schemas, extensions, or new privilege paths. + if at(index,"create") || at(index,"alter") || at(index,"drop") { + return true; + } + } + false +} + +/// Reject client startup options that could set a different role, disable RLS, +/// change replication semantics, or redirect object resolution before SQL is inspected. +pub fn blocks_tenant_startup_options(options: &str) -> bool { + let compact: String = options.chars() + .filter(|character| !character.is_whitespace() && *character!='\'' && *character!='"') + .collect::().to_ascii_lowercase(); + if compact.contains("role=") || compact.contains("session_authorization=") + || compact.contains("row_security=") || compact.contains("session_replication_role=") + || compact.contains("search_path=") { + return true; + } + let tokens: Vec<&str> = options.split_whitespace().collect(); + let mut index=0; + while index Result { + if value.trim().is_empty() || value.len() > max_bytes || value.chars().any(|character| character == char::from(0)) { + return Err(error("invalid_tenant_context", "A tenant context value is empty, too long, or contains NUL.")); + } + Ok(format!("N'{}'", value.replace('\'', "''"))) +} + +/// Bind a verified tenant scope to a dedicated SQL Server connection before +/// forwarding any application statement. The tenant key is marked read-only +/// for the life of this physical connection; never return that connection to a +/// pool that can serve another tenant. +pub async fn bind_verified_tenant_context( + client: &mut Client>, + target: &AdapterTarget, + identity: &VerifiedTenantIdentity, +) -> Result<(), AdapterError> { + let now = std::time::SystemTime::now() + .duration_since(std::time::UNIX_EPOCH) + .map_err(|_| error("tenant_identity_clock_invalid", "The system clock is before the Unix epoch."))? + .as_secs() as i64; + if identity.database_kind() != DatabaseKind::SqlServer + || identity.target_id() != target.target_id + || identity.expires_at_unix() <= now + || identity.issued_at_unix() > now + { + return Err(error("tenant_identity_scope_mismatch", "The verified tenant identity is expired or belongs to a different SQL Server target.")); + } + + let tenant = sql_server_unicode_literal(identity.tenant_id(), 128)?; + let target_id = sql_server_unicode_literal(identity.target_id(), 256)?; + let policy_id = sql_server_unicode_literal(identity.policy_id(), 128)?; + let principal_id = sql_server_unicode_literal(identity.principal_id(), 256)?; + let policy_revision = identity.policy_revision(); + let statement = format!( + "EXEC sys.sp_set_session_context @key=N'tenant_id', @value={tenant}, @read_only=1; \ + EXEC sys.sp_set_session_context @key=N'proxima_target_id', @value={target_id}, @read_only=1; \ + EXEC sys.sp_set_session_context @key=N'proxima_policy_id', @value={policy_id}, @read_only=1; \ + EXEC sys.sp_set_session_context @key=N'proxima_principal_id', @value={principal_id}, @read_only=1; \ + EXEC sys.sp_set_session_context @key=N'proxima_policy_revision', @value={policy_revision}, @read_only=1; \ + SELECT CONVERT(nvarchar(128),SESSION_CONTEXT(N'tenant_id')) AS tenant_id, \ + CONVERT(nvarchar(256),SESSION_CONTEXT(N'proxima_target_id')) AS target_id, \ + CONVERT(nvarchar(128),SESSION_CONTEXT(N'proxima_policy_id')) AS policy_id, \ + CONVERT(nvarchar(256),SESSION_CONTEXT(N'proxima_principal_id')) AS principal_id, \ + TRY_CONVERT(bigint,SESSION_CONTEXT(N'proxima_policy_revision')) AS policy_revision;" + ); + let rows = client.simple_query(statement).await.map_err(db_error)? + .into_first_result().await.map_err(db_error)?; + let row = rows.first().ok_or_else(|| error( + "tenant_context_verification_failed", + "SQL Server did not return the read-back tenant context.", + ))?; + let tenant: Option<&str> = row.get("tenant_id"); + let target_id: Option<&str> = row.get("target_id"); + let policy_id: Option<&str> = row.get("policy_id"); + let principal_id: Option<&str> = row.get("principal_id"); + let revision: Option = row.get("policy_revision"); + if tenant != Some(identity.tenant_id()) + || target_id != Some(identity.target_id()) + || policy_id != Some(identity.policy_id()) + || principal_id != Some(identity.principal_id()) + || revision != i64::try_from(identity.policy_revision()).ok() + { + return Err(error( + "tenant_context_verification_failed", + "SQL Server session context did not match the verified tenant, target, and policy revision.", + )); + } + Ok(()) +} + +/// Open a dedicated SQL Server session for one verified tenant. This +/// connects with the application's least-privilege database principal, checks +/// the selected database, binds read-only SESSION_CONTEXT values, and only then +/// returns the connection for application statements. +pub async fn connect_tenant_session( + connection_string: &str, + target: &AdapterTarget, + identity: &VerifiedTenantIdentity, +) -> Result>, AdapterError> { + // Reuse the catalog adapter's strict connection-string validation, but do + // not use its read-only inspection login checks for the application login. + let _validated = SqlServerCatalogAdapter::new( + target.target_id.clone(), + target.database_name.clone(), + connection_string.to_owned(), + )?; + if identity.database_kind() != DatabaseKind::SqlServer + || identity.target_id() != target.target_id + || identity.expires_at_unix() <= std::time::SystemTime::now() + .duration_since(std::time::UNIX_EPOCH) + .map_err(|_| error("tenant_identity_clock_invalid", "The system clock is before the Unix epoch."))? + .as_secs() as i64 + { + return Err(error("tenant_identity_scope_mismatch", "The verified tenant identity is expired or belongs to a different SQL Server target.")); + } + + let mut config = Config::from_ado_string(connection_string) + .map_err(|_| error("invalid_sql_server_connection_config", "The SQL Server connection string could not be parsed."))?; + config.encryption(EncryptionLevel::Required); + let tcp = tokio::time::timeout(Duration::from_secs(10), TcpStream::connect(config.get_addr())) + .await + .map_err(|_| error("sql_server_connection_timeout", "SQL Server TCP connection exceeded the ten-second deadline."))? + .map_err(db_error)?; + tcp.set_nodelay(true).map_err(db_error)?; + let mut client = tokio::time::timeout(Duration::from_secs(15), Client::connect(config, tcp.compat_write())) + .await + .map_err(|_| error("sql_server_tls_login_timeout", "SQL Server encrypted login exceeded the fifteen-second deadline."))? + .map_err(db_error)?; + + let rows = client.simple_query("SELECT DB_NAME() AS database_name") + .await.map_err(db_error)? + .into_first_result().await.map_err(db_error)?; + let connected_database = rows.first() + .and_then(|row| row.get::<&str, _>("database_name")) + .ok_or_else(|| error("sql_server_identity_unavailable", "SQL Server did not return the selected database name."))?; + if connected_database != target.database_name { + return Err(error("sql_server_database_mismatch", "The tenant session connected to a different SQL Server database than requested.")); + } + + bind_verified_tenant_context(&mut client, target, identity).await?; + Ok(client) +} + +pub struct SqlServerCatalogAdapter { + target_id: String, + database_name: String, + connection_string: String, +} + +impl SqlServerCatalogAdapter { + pub fn new(target_id: impl Into, database_name: impl Into, connection_string: impl Into) -> Result { + let target_id = target_id.into(); + let database_name = database_name.into(); + let connection_string = connection_string.into(); + if target_id.trim().is_empty() || target_id.len() > 256 || target_id.contains('\0') + || database_name.trim().is_empty() || database_name.len() > 128 || database_name.contains('\0') + || connection_string.trim().is_empty() || connection_string.len() > 4096 { + return Err(error("invalid_sql_server_target", "A bounded target ID, database name and connection string are required.")); + } + let normalized = connection_string.to_ascii_lowercase().replace(' ', ""); + if ["trustservercertificate=true","trustservercertificate=yes","trustservercertificate=1","encrypt=false","encrypt=no","encrypt=0"].iter().any(|option| normalized.contains(option)) { + return Err(error("sql_server_tls_verification_required", "SQL Server connections must require encryption and certificate/hostname verification; TrustServerCertificate=true and Encrypt=false are forbidden.")); + } + if ["integratedsecurity=true","integratedsecurity=yes"].iter().any(|option| normalized.contains(option)) { + return Err(error("sql_server_authentication_mode_unsupported", "This adapter build requires SQL Server username/password authentication; integrated Windows/Kerberos authentication is not enabled.")); + } + Config::from_ado_string(&connection_string) + .map_err(|_| error("invalid_sql_server_connection_config", "The SQL Server connection string could not be parsed."))?; + Ok(Self { target_id, database_name, connection_string }) + } + + fn validate_target(&self, target: &AdapterTarget) -> Result<(), AdapterError> { + if target.target_id != self.target_id || target.database_name != self.database_name { + return Err(error("sql_server_target_mismatch", "The request does not match this adapter's registered SQL Server target.")); + } + Ok(()) + } + + async fn connect_checked(&self) -> Result>, AdapterError> { + let mut config = Config::from_ado_string(&self.connection_string) + .map_err(|_| error("invalid_sql_server_connection_config", "The SQL Server connection string could not be parsed."))?; + config.encryption(EncryptionLevel::Required); + let address = config.get_addr(); + let tcp = tokio::time::timeout(Duration::from_secs(10), TcpStream::connect(address)) + .await.map_err(|_| error("sql_server_connection_timeout", "SQL Server TCP connection exceeded the ten-second deadline."))? + .map_err(db_error)?; + tcp.set_nodelay(true).map_err(db_error)?; + let mut client = tokio::time::timeout(Duration::from_secs(15), Client::connect(config, tcp.compat_write())) + .await.map_err(|_| error("sql_server_tls_login_timeout", "SQL Server encrypted login exceeded the fifteen-second deadline."))? + .map_err(db_error)?; + let rows = client.simple_query( + "SELECT DB_NAME() AS database_name, ORIGINAL_LOGIN() AS login_name, USER_NAME() AS database_user, CONVERT(nvarchar(128), SERVERPROPERTY('ProductVersion')) AS server_version, CONVERT(int,SERVERPROPERTY('ProductMajorVersion')) AS product_major_version, CONVERT(int,SERVERPROPERTY('EngineEdition')) AS engine_edition, CONVERT(bit,HAS_PERMS_BY_NAME(DB_NAME(), 'DATABASE', 'VIEW DEFINITION')) AS can_view_definition, IS_SRVROLEMEMBER('sysadmin') AS is_sysadmin, IS_SRVROLEMEMBER('securityadmin') AS is_securityadmin, IS_SRVROLEMEMBER('serveradmin') AS is_serveradmin, IS_SRVROLEMEMBER('setupadmin') AS is_setupadmin, IS_SRVROLEMEMBER('dbcreator') AS is_dbcreator, IS_SRVROLEMEMBER('processadmin') AS is_processadmin, IS_SRVROLEMEMBER('diskadmin') AS is_diskadmin, IS_SRVROLEMEMBER('bulkadmin') AS is_bulkadmin, IS_MEMBER('db_owner') AS is_db_owner, IS_MEMBER('db_ddladmin') AS is_db_ddladmin, IS_MEMBER('db_securityadmin') AS is_db_securityadmin, IS_MEMBER('db_accessadmin') AS is_db_accessadmin, IS_MEMBER('db_datawriter') AS is_db_datawriter, CONVERT(bit,CASE WHEN (HAS_PERMS_BY_NAME(NULL, 'SERVER', 'CONTROL SERVER')=1 OR HAS_PERMS_BY_NAME(NULL, 'SERVER', 'ALTER ANY LOGIN')=1 OR HAS_PERMS_BY_NAME(NULL, 'SERVER', 'ALTER ANY SERVER ROLE')=1 OR HAS_PERMS_BY_NAME(NULL, 'SERVER', 'ALTER ANY DATABASE')=1 OR EXISTS(SELECT 1 FROM sys.server_principals login_principal WHERE HAS_PERMS_BY_NAME(login_principal.name, 'LOGIN', 'IMPERSONATE')=1)) THEN 1 ELSE 0 END) AS has_server_mutation_privileges, CONVERT(bit,CASE WHEN (HAS_PERMS_BY_NAME(DB_NAME(), 'DATABASE', 'CREATE TABLE')=1 OR HAS_PERMS_BY_NAME(DB_NAME(), 'DATABASE', 'ALTER ANY SCHEMA')=1 OR HAS_PERMS_BY_NAME(DB_NAME(), 'DATABASE', 'CONTROL')=1 OR HAS_PERMS_BY_NAME(DB_NAME(), 'DATABASE', 'ALTER ANY USER')=1 OR HAS_PERMS_BY_NAME(DB_NAME(), 'DATABASE', 'ALTER ANY ROLE')=1 OR EXISTS(SELECT 1 FROM sys.schemas schema_principal WHERE HAS_PERMS_BY_NAME(schema_principal.name, 'SCHEMA', 'ALTER')=1 OR HAS_PERMS_BY_NAME(schema_principal.name, 'SCHEMA', 'CONTROL')=1 OR HAS_PERMS_BY_NAME(schema_principal.name, 'SCHEMA', 'TAKE OWNERSHIP')=1)) THEN 1 ELSE 0 END) AS has_database_mutation_privileges, CONVERT(bit,CASE WHEN EXISTS(SELECT 1 FROM sys.tables t JOIN sys.schemas s ON s.schema_id=t.schema_id WHERE HAS_PERMS_BY_NAME(QUOTENAME(s.name)+'.'+QUOTENAME(t.name), 'OBJECT', 'INSERT')=1 OR HAS_PERMS_BY_NAME(QUOTENAME(s.name)+'.'+QUOTENAME(t.name), 'OBJECT', 'UPDATE')=1 OR HAS_PERMS_BY_NAME(QUOTENAME(s.name)+'.'+QUOTENAME(t.name), 'OBJECT', 'DELETE')=1 OR HAS_PERMS_BY_NAME(QUOTENAME(s.name)+'.'+QUOTENAME(t.name), 'OBJECT', 'ALTER')=1 OR HAS_PERMS_BY_NAME(QUOTENAME(s.name)+'.'+QUOTENAME(t.name), 'OBJECT', 'CONTROL')=1 OR HAS_PERMS_BY_NAME(QUOTENAME(s.name)+'.'+QUOTENAME(t.name), 'OBJECT', 'TAKE OWNERSHIP')=1) THEN 1 ELSE 0 END) AS has_object_mutation_privileges" + ).await.map_err(db_error)?.into_first_result().await.map_err(db_error)?; + let row = rows.first().ok_or_else(|| error("sql_server_identity_unavailable", "SQL Server did not return authenticated connection identity metadata."))?; + let database = row.get::<&str,_>("database_name").unwrap_or_default(); + if database != self.database_name { + return Err(error("sql_server_database_mismatch", "The authenticated connection reached a different SQL Server database.")); + } + let sysadmin = row.get::("is_sysadmin").unwrap_or(0) == 1; + let elevated_server_role = ["is_securityadmin", "is_serveradmin", "is_setupadmin", "is_dbcreator", "is_processadmin", "is_diskadmin", "is_bulkadmin"] + .iter() + .any(|column| row.get::(*column).unwrap_or(0) == 1); + let elevated_database_role = ["is_db_owner", "is_db_ddladmin", "is_db_securityadmin", "is_db_accessadmin", "is_db_datawriter"] + .iter() + .any(|column| row.get::(*column).unwrap_or(0) == 1); + let mutation_privileges = row.get::("has_server_mutation_privileges").unwrap_or(true) + || row.get::("has_database_mutation_privileges").unwrap_or(true) + || row.get::("has_object_mutation_privileges").unwrap_or(true); + if sysadmin || elevated_server_role || elevated_database_role || mutation_privileges { + return Err(error("unsafe_sql_server_inspection_principal", "Use a dedicated read-only SQL Server inspection principal; sysadmin, elevated fixed server/database roles and effective database/object mutation privileges are rejected.")); + } + Ok(client) + } + + async fn discover_inner(&self, request: &DiscoveryRequest) -> Result { + self.validate_target(&request.target)?; + if request.namespace.as_ref().is_some_and(|schema| schema.trim().is_empty() || schema.len() > 128 || schema.contains('\0')) { + return Err(error("invalid_sql_server_schema", "The requested SQL Server schema name is invalid.")); + } + let mut client = self.connect_checked().await?; + let identity_rows = client.simple_query( + "SELECT DB_NAME() AS database_name, ORIGINAL_LOGIN() AS login_name, USER_NAME() AS database_user, CONVERT(nvarchar(128), SERVERPROPERTY('ProductVersion')) AS server_version, CONVERT(int,SERVERPROPERTY('ProductMajorVersion')) AS product_major_version, CONVERT(int,SERVERPROPERTY('EngineEdition')) AS engine_edition, CONVERT(bit,HAS_PERMS_BY_NAME(DB_NAME(), 'DATABASE', 'VIEW DEFINITION')) AS can_view_definition, IS_SRVROLEMEMBER('sysadmin') AS is_sysadmin" + ).await.map_err(db_error)?.into_first_result().await.map_err(db_error)?; + let identity = identity_rows.first().ok_or_else(|| error("sql_server_identity_unavailable", "SQL Server identity metadata was unavailable."))?; + let can_view_definition = identity.get::("can_view_definition").unwrap_or(false); + let is_sysadmin = identity.get::("is_sysadmin").unwrap_or(0) == 1; + let product_major_version = identity.get::("product_major_version").unwrap_or(0); + let engine_edition = identity.get::("engine_edition").unwrap_or(0); + if product_major_version < 13 && !matches!(engine_edition, 5 | 8) { + return Err(error("sql_server_version_unsupported", "The SQL Server adapter requires SQL Server 2016+ or Azure SQL Database/Managed Instance for native row-level security catalog support.")); + } + let mut resources = Vec::new(); + + let table_rows = client.simple_query( + "SELECT TOP (10001) s.name AS schema_name,t.name AS object_name,t.object_id,COALESCE(USER_NAME(t.principal_id),USER_NAME(s.principal_id)) AS owner_name,t.temporal_type_desc,t.is_memory_optimized,t.is_filetable,t.is_tracked_by_cdc FROM sys.tables t JOIN sys.schemas s ON s.schema_id=t.schema_id ORDER BY s.name,t.name" + ).await.map_err(db_error)?.into_first_result().await.map_err(db_error)?; + let table_inventory_truncated = table_rows.len() > 10_000; + for row in table_rows.into_iter().take(10_000) { + let schema = row.get::<&str,_>("schema_name").unwrap_or_default().to_owned(); + if request.namespace.as_deref().is_some_and(|wanted| wanted != schema.as_str()) { continue; } + let name = row.get::<&str,_>("object_name").unwrap_or_default().to_owned(); + let object_id = row.get::("object_id").unwrap_or_default(); + let columns = client.query( + "SELECT c.name,TYPE_NAME(c.user_type_id) AS data_type,c.is_nullable,c.is_computed,c.is_identity FROM sys.columns c WHERE c.object_id=@P1 ORDER BY c.column_id", + &[&object_id], + ).await.map_err(db_error)?.into_first_result().await.map_err(db_error)?; + let permissions = client.query( + "SELECT principal.name AS grantee,permission.permission_name,permission.state_desc,CONVERT(int,permission.minor_id) AS minor_id,column_info.name AS column_name FROM sys.database_permissions permission LEFT JOIN sys.database_principals principal ON principal.principal_id=permission.grantee_principal_id LEFT JOIN sys.columns column_info ON column_info.object_id=permission.major_id AND column_info.column_id=permission.minor_id WHERE permission.class_desc='OBJECT_OR_COLUMN' AND permission.major_id=@P1 ORDER BY principal.name,permission.permission_name,permission.minor_id", + &[&object_id], + ).await.map_err(db_error)?.into_first_result().await.map_err(db_error)?; + let indexes = client.query( + "SELECT index_info.name,index_info.type_desc,index_info.is_unique,index_info.is_primary_key,index_info.is_unique_constraint,index_info.is_disabled,index_info.has_filter,index_info.filter_definition,CONVERT(int,index_column.key_ordinal) AS key_ordinal,index_column.is_included_column,column_info.name AS column_name FROM sys.indexes index_info LEFT JOIN sys.index_columns index_column ON index_column.object_id=index_info.object_id AND index_column.index_id=index_info.index_id LEFT JOIN sys.columns column_info ON column_info.object_id=index_column.object_id AND column_info.column_id=index_column.column_id WHERE index_info.object_id=@P1 AND index_info.index_id > 0 ORDER BY index_info.index_id,index_column.key_ordinal,index_column.index_column_id", + &[&object_id], + ).await.map_err(db_error)?.into_first_result().await.map_err(db_error)?; + let partition_metadata = client.query( + "SELECT partition_info.index_id,partition_info.partition_number,partition_info.data_compression_desc,data_space.name AS data_space_name,partition_scheme.name AS partition_scheme,partition_function.name AS partition_function,partition_function.type_desc AS partition_function_type,partition_function.boundary_value_on_right,CONVERT(int,partition_parameter.parameter_id) AS partition_parameter_id,TYPE_NAME(partition_parameter.user_type_id) AS partition_parameter_type,partition_value.boundary_id,CONVERT(nvarchar(4000),partition_value.value) AS boundary_value FROM sys.partitions partition_info JOIN sys.indexes index_info ON index_info.object_id=partition_info.object_id AND index_info.index_id=partition_info.index_id JOIN sys.data_spaces data_space ON data_space.data_space_id=index_info.data_space_id LEFT JOIN sys.partition_schemes partition_scheme ON partition_scheme.data_space_id=data_space.data_space_id LEFT JOIN sys.partition_functions partition_function ON partition_function.function_id=partition_scheme.function_id LEFT JOIN sys.partition_parameters partition_parameter ON partition_parameter.function_id=partition_function.function_id LEFT JOIN sys.partition_range_values partition_value ON partition_value.function_id=partition_function.function_id WHERE partition_info.object_id=@P1 ORDER BY partition_info.index_id,partition_info.partition_number,partition_value.boundary_id", + &[&object_id], + ).await.map_err(db_error)?.into_first_result().await.map_err(db_error)?; + let foreign_keys = client.query( + "SELECT fk.name,fk.is_disabled,fk.is_not_trusted,fk.delete_referential_action_desc,fk.update_referential_action_desc,parent_column.name AS parent_column,OBJECT_SCHEMA_NAME(fkc.referenced_object_id) AS referenced_schema,OBJECT_NAME(fkc.referenced_object_id) AS referenced_table,referenced_column.name AS referenced_column FROM sys.foreign_keys fk JOIN sys.foreign_key_columns fkc ON fkc.constraint_object_id=fk.object_id JOIN sys.columns parent_column ON parent_column.object_id=fkc.parent_object_id AND parent_column.column_id=fkc.parent_column_id JOIN sys.columns referenced_column ON referenced_column.object_id=fkc.referenced_object_id AND referenced_column.column_id=fkc.referenced_column_id WHERE fk.parent_object_id=@P1 ORDER BY fk.name,fkc.constraint_column_id", + &[&object_id], + ).await.map_err(db_error)?.into_first_result().await.map_err(db_error)?; + let check_constraints = client.query( + "SELECT name,definition,is_disabled,is_not_trusted FROM sys.check_constraints WHERE parent_object_id=@P1 ORDER BY name", + &[&object_id], + ).await.map_err(db_error)?.into_first_result().await.map_err(db_error)?; + let default_constraints = client.query( + "SELECT name,definition,parent_column_id FROM sys.default_constraints WHERE parent_object_id=@P1 ORDER BY name", + &[&object_id], + ).await.map_err(db_error)?.into_first_result().await.map_err(db_error)?; + let predicates = client.query( + "SELECT policy.name AS policy_name,policy.is_enabled,policy.is_schema_bound,predicate.predicate_type_desc,predicate.operation_desc,predicate.predicate_definition FROM sys.security_policies policy JOIN sys.security_predicates predicate ON predicate.object_id=policy.object_id WHERE predicate.target_object_id=@P1 ORDER BY policy.name,predicate.operation_desc", + &[&object_id], + ).await.map_err(db_error)?.into_first_result().await.map_err(db_error)?; + let triggers = client.query( + "SELECT trigger_info.name,trigger_info.is_disabled,trigger_info.is_instead_of_trigger,module.definition,module.execute_as_principal_id FROM sys.triggers trigger_info LEFT JOIN sys.sql_modules module ON module.object_id=trigger_info.object_id WHERE trigger_info.parent_id=@P1 ORDER BY trigger_info.name", + &[&object_id], + ).await.map_err(db_error)?.into_first_result().await.map_err(db_error)?; + resources.push(DiscoveredResource { + namespace: Some(schema), + name, + kind: ResourceKind::Table, + owner: row.get::<&str,_>("owner_name").map(str::to_owned), + attributes: json!({ + "temporal_type": row.get::<&str,_>("temporal_type_desc").unwrap_or_default(), + "memory_optimized": row.get::("is_memory_optimized").unwrap_or(false), + "is_filetable": row.get::("is_filetable").unwrap_or(false), + "change_data_capture": row.get::("is_tracked_by_cdc").unwrap_or(false), + "columns": columns.iter().map(|column| json!({ + "name": column.get::<&str,_>("name").unwrap_or_default(), + "type": column.get::<&str,_>("data_type").unwrap_or_default(), + "nullable": column.get::("is_nullable").unwrap_or(true), + "computed": column.get::("is_computed").unwrap_or(false), + "identity": column.get::("is_identity").unwrap_or(false) + })).collect::>(), + "indexes": indexes.iter().map(|index| json!({ + "name": index.get::<&str,_>("name").unwrap_or_default(), + "type": index.get::<&str,_>("type_desc").unwrap_or_default(), + "unique": index.get::("is_unique").unwrap_or(false), + "primary_key": index.get::("is_primary_key").unwrap_or(false), + "unique_constraint": index.get::("is_unique_constraint").unwrap_or(false), + "disabled": index.get::("is_disabled").unwrap_or(false), + "has_filter": index.get::("has_filter").unwrap_or(false), + "filter": index.get::<&str,_>("filter_definition"), + "key_ordinal": index.get::("key_ordinal"), + "included": index.get::("is_included_column").unwrap_or(false), + "column": index.get::<&str,_>("column_name") + })).collect::>(), + "partitions": partition_metadata.iter().map(|partition| json!({ + "index_id": partition.get::("index_id").unwrap_or_default(), + "partition_number": partition.get::("partition_number").unwrap_or_default(), + "compression": partition.get::<&str,_>("data_compression_desc").unwrap_or_default(), + "data_space": partition.get::<&str,_>("data_space_name").unwrap_or_default(), + "partition_scheme": partition.get::<&str,_>("partition_scheme"), + "partition_function": partition.get::<&str,_>("partition_function"), + "partition_function_type": partition.get::<&str,_>("partition_function_type"), + "boundary_value_on_right": partition.get::("boundary_value_on_right"), + "partition_parameter_id": partition.get::("partition_parameter_id"), + "partition_parameter_type": partition.get::<&str,_>("partition_parameter_type"), + "boundary_id": partition.get::("boundary_id"), + "boundary_value": partition.get::<&str,_>("boundary_value") + })).collect::>(), + "foreign_keys": foreign_keys.iter().map(|foreign_key| json!({ + "name": foreign_key.get::<&str,_>("name").unwrap_or_default(), + "disabled": foreign_key.get::("is_disabled").unwrap_or(false), + "not_trusted": foreign_key.get::("is_not_trusted").unwrap_or(false), + "on_delete": foreign_key.get::<&str,_>("delete_referential_action_desc").unwrap_or_default(), + "on_update": foreign_key.get::<&str,_>("update_referential_action_desc").unwrap_or_default(), + "parent_column": foreign_key.get::<&str,_>("parent_column"), + "referenced_schema": foreign_key.get::<&str,_>("referenced_schema"), + "referenced_table": foreign_key.get::<&str,_>("referenced_table"), + "referenced_column": foreign_key.get::<&str,_>("referenced_column") + })).collect::>(), + "check_constraints": check_constraints.iter().map(|constraint| json!({ + "name": constraint.get::<&str,_>("name").unwrap_or_default(), + "definition": constraint.get::<&str,_>("definition"), + "disabled": constraint.get::("is_disabled").unwrap_or(false), + "not_trusted": constraint.get::("is_not_trusted").unwrap_or(false) + })).collect::>(), + "default_constraints": default_constraints.iter().map(|constraint| json!({ + "name": constraint.get::<&str,_>("name").unwrap_or_default(), + "definition": constraint.get::<&str,_>("definition"), + "column_id": constraint.get::("parent_column_id").unwrap_or_default() + })).collect::>(), + "permissions": permissions.iter().map(|permission| json!({ + "grantee": permission.get::<&str,_>("grantee").unwrap_or_default(), + "permission": permission.get::<&str,_>("permission_name").unwrap_or_default(), + "state": permission.get::<&str,_>("state_desc").unwrap_or_default(), + "column_id": permission.get::("minor_id").unwrap_or_default(), + "column": permission.get::<&str,_>("column_name") + })).collect::>(), + "security_predicates": predicates.iter().map(|predicate| json!({ + "policy": predicate.get::<&str,_>("policy_name").unwrap_or_default(), + "enabled": predicate.get::("is_enabled").unwrap_or(false), + "schema_bound": predicate.get::("is_schema_bound").unwrap_or(false), + "predicate_type": predicate.get::<&str,_>("predicate_type_desc").unwrap_or_default(), + "operation": predicate.get::<&str,_>("operation_desc").unwrap_or_default(), + "definition": predicate.get::<&str,_>("predicate_definition") + })).collect::>(), + "triggers": triggers.iter().map(|trigger| json!({ + "name": trigger.get::<&str,_>("name").unwrap_or_default(), + "disabled": trigger.get::("is_disabled").unwrap_or(false), + "instead_of": trigger.get::("is_instead_of_trigger").unwrap_or(false), + "definition": trigger.get::<&str,_>("definition"), + "execute_as_principal_id": trigger.get::("execute_as_principal_id") + })).collect::>() + }), + }); + } + + let view_rows = client.simple_query( + "SELECT TOP (10001) s.name AS schema_name,v.name AS object_name,v.object_id,v.with_check_option,CONVERT(bit,OBJECTPROPERTY(v.object_id,'IsSchemaBound')) AS is_schema_bound,m.definition,USER_NAME(o.principal_id) AS owner_name FROM sys.views v JOIN sys.schemas s ON s.schema_id=v.schema_id JOIN sys.objects o ON o.object_id=v.object_id LEFT JOIN sys.sql_modules m ON m.object_id=v.object_id ORDER BY s.name,v.name" + ).await.map_err(db_error)?.into_first_result().await.map_err(db_error)?; + let view_inventory_truncated = view_rows.len() > 10_000; + for row in view_rows.into_iter().take(10_000) { + let schema = row.get::<&str,_>("schema_name").unwrap_or_default().to_owned(); + if request.namespace.as_deref().is_some_and(|wanted| wanted != schema.as_str()) { continue; } + resources.push(DiscoveredResource { + namespace: Some(schema), + name: row.get::<&str,_>("object_name").unwrap_or_default().to_owned(), + kind: ResourceKind::View, + owner: row.get::<&str,_>("owner_name").map(str::to_owned), + attributes: json!({ + "with_check_option": row.get::("with_check_option").unwrap_or(false), + "schema_bound": row.get::("is_schema_bound").unwrap_or(false), + "definition": row.get::<&str,_>("definition") + }), + }); + } + + let routine_rows = client.simple_query( + "SELECT TOP (10001) s.name AS schema_name,o.name AS object_name,o.type_desc,USER_NAME(o.principal_id) AS owner_name,m.definition,m.execute_as_principal_id,m.is_schema_bound FROM sys.objects o JOIN sys.schemas s ON s.schema_id=o.schema_id LEFT JOIN sys.sql_modules m ON m.object_id=o.object_id WHERE o.type IN ('P','FN','IF','TF','FS','FT') ORDER BY s.name,o.name" + ).await.map_err(db_error)?.into_first_result().await.map_err(db_error)?; + let routine_inventory_truncated = routine_rows.len() > 10_000; + for row in routine_rows.into_iter().take(10_000) { + let schema = row.get::<&str,_>("schema_name").unwrap_or_default().to_owned(); + if request.namespace.as_deref().is_some_and(|wanted| wanted != schema.as_str()) { continue; } + let type_desc = row.get::<&str,_>("type_desc").unwrap_or_default(); + let kind = if type_desc.contains("PROCEDURE") { ResourceKind::Procedure } else { ResourceKind::Function }; + resources.push(DiscoveredResource { + namespace: Some(schema), + name: row.get::<&str,_>("object_name").unwrap_or_default().to_owned(), + kind, + owner: row.get::<&str,_>("owner_name").map(str::to_owned), + attributes: json!({ + "type": type_desc, + "definition": row.get::<&str,_>("definition"), + "execute_as_principal_id": row.get::("execute_as_principal_id"), + "schema_bound": row.get::("is_schema_bound").unwrap_or(false) + }), + }); + } + + let database_options_rows = client.simple_query( + "SELECT database_info.name,owner.name AS owner_name,database_info.is_trustworthy_on,database_info.is_db_chaining_on,database_info.is_read_committed_snapshot_on,CONVERT(int,database_info.compatibility_level) AS compatibility_level,database_info.containment_desc FROM sys.databases database_info LEFT JOIN sys.server_principals owner ON owner.sid=database_info.owner_sid WHERE database_info.database_id=DB_ID()" + ).await.map_err(db_error)?.into_first_result().await.map_err(db_error)?; + let database_options = database_options_rows.first(); + let principals = client.simple_query( + "SELECT principal.name,principal.type_desc,principal.authentication_type_desc,principal.is_fixed_role,principal.default_schema_name FROM sys.database_principals principal WHERE principal.principal_id = 1 OR principal.principal_id > 4 ORDER BY principal.name" + ).await.map_err(db_error)?.into_first_result().await.map_err(db_error)?; + let role_memberships = client.simple_query( + "SELECT role_principal.name AS role_name,member_principal.name AS member_name FROM sys.database_role_members membership JOIN sys.database_principals role_principal ON role_principal.principal_id=membership.role_principal_id JOIN sys.database_principals member_principal ON member_principal.principal_id=membership.member_principal_id ORDER BY role_principal.name,member_principal.name" + ).await.map_err(db_error)?.into_first_result().await.map_err(db_error)?; + let object_permissions = client.simple_query( + "SELECT OBJECT_SCHEMA_NAME(permission.major_id) AS schema_name,OBJECT_NAME(permission.major_id) AS object_name,principal.name AS grantee,permission.permission_name,permission.state_desc,CONVERT(int,permission.minor_id) AS minor_id FROM sys.database_permissions permission LEFT JOIN sys.database_principals principal ON principal.principal_id=permission.grantee_principal_id WHERE permission.class_desc='OBJECT_OR_COLUMN' ORDER BY schema_name,object_name,principal.name,permission.permission_name" + ).await.map_err(db_error)?.into_first_result().await.map_err(db_error)?; + let schema_permissions = client.simple_query( + "SELECT schema_info.name AS schema_name,principal.name AS grantee,permission.permission_name,permission.state_desc FROM sys.database_permissions permission JOIN sys.database_principals principal ON principal.principal_id=permission.grantee_principal_id JOIN sys.schemas schema_info ON schema_info.schema_id=permission.major_id WHERE permission.class_desc='SCHEMA' ORDER BY schema_info.name,principal.name,permission.permission_name" + ).await.map_err(db_error)?.into_first_result().await.map_err(db_error)?; + let database_permissions = client.simple_query( + "SELECT principal.name AS grantee,permission.permission_name,permission.state_desc FROM sys.database_permissions permission JOIN sys.database_principals principal ON principal.principal_id=permission.grantee_principal_id WHERE permission.class_desc='DATABASE' ORDER BY principal.name,permission.permission_name" + ).await.map_err(db_error)?.into_first_result().await.map_err(db_error)?; + let can_view_definition = identity.get::("can_view_definition").unwrap_or(false); + let is_sysadmin = identity.get::("is_sysadmin").unwrap_or(0) == 1; + let target_attributes = json!({ + "database": identity.get::<&str,_>("database_name").unwrap_or_default(), + "original_login": identity.get::<&str,_>("login_name").unwrap_or_default(), + "database_user": identity.get::<&str,_>("database_user").unwrap_or_default(), + "server_version": identity.get::<&str,_>("server_version").unwrap_or_default(), + "product_major_version": product_major_version, + "engine_edition": engine_edition, + "can_view_definition": can_view_definition, + "is_sysadmin": is_sysadmin, + "principals": principals.iter().map(|principal| json!({ + "name": principal.get::<&str,_>("name").unwrap_or_default(), + "type": principal.get::<&str,_>("type_desc").unwrap_or_default(), + "authentication": principal.get::<&str,_>("authentication_type_desc").unwrap_or_default(), + "fixed_role": principal.get::("is_fixed_role").unwrap_or(false), + "default_schema": principal.get::<&str,_>("default_schema_name") + })).collect::>(), + "role_memberships": role_memberships.iter().map(|membership| json!({ + "role": membership.get::<&str,_>("role_name").unwrap_or_default(), + "member": membership.get::<&str,_>("member_name").unwrap_or_default() + })).collect::>(), + "object_permissions": object_permissions.iter().map(|permission| json!({ + "schema": permission.get::<&str,_>("schema_name"), + "object": permission.get::<&str,_>("object_name"), + "grantee": permission.get::<&str,_>("grantee").unwrap_or_default(), + "permission": permission.get::<&str,_>("permission_name").unwrap_or_default(), + "state": permission.get::<&str,_>("state_desc").unwrap_or_default(), + "column_id": permission.get::("minor_id").unwrap_or_default() + })).collect::>(), + "schema_permissions": schema_permissions.iter().map(|permission| json!({ + "schema": permission.get::<&str,_>("schema_name").unwrap_or_default(), + "grantee": permission.get::<&str,_>("grantee").unwrap_or_default(), + "permission": permission.get::<&str,_>("permission_name").unwrap_or_default(), + "state": permission.get::<&str,_>("state_desc").unwrap_or_default() + })).collect::>(), + "database_permissions": database_permissions.iter().map(|permission| json!({ + "grantee": permission.get::<&str,_>("grantee").unwrap_or_default(), + "permission": permission.get::<&str,_>("permission_name").unwrap_or_default(), + "state": permission.get::<&str,_>("state_desc").unwrap_or_default() + })).collect::>(), + "database_options": database_options.map(|row| json!({ + "owner": row.get::<&str,_>("owner_name"), + "trustworthy": row.get::("is_trustworthy_on").unwrap_or(false), + "database_chaining": row.get::("is_db_chaining_on").unwrap_or(false), + "read_committed_snapshot": row.get::("is_read_committed_snapshot_on").unwrap_or(false), + "compatibility_level": row.get::("compatibility_level").unwrap_or_default(), + "containment": row.get::<&str,_>("containment_desc").unwrap_or_default() + })), + "catalog_inventory_truncated": table_inventory_truncated || view_inventory_truncated || routine_inventory_truncated, + "encrypted_transport_required": true + }); + let fingerprint = digest(&serde_json::to_vec(&json!({"target_id":self.target_id,"database_name":self.database_name,"target":target_attributes,"resources":resources})) + .map_err(|_| error("fingerprint_serialization_failed", "Could not serialize SQL Server catalog state."))?); + let mut findings = Vec::new(); + if table_inventory_truncated || view_inventory_truncated || routine_inventory_truncated { + findings.push(SecurityFinding { + code: "sql_server_catalog_inventory_truncated".into(), + resource: None, + detail: "The visible catalog exceeded the 10,000-table, 10,000-view or 10,000-routine safety bound; discovery is truncated.".into(), + }); + } + if !can_view_definition && !is_sysadmin { + findings.push(SecurityFinding { + code: "sql_server_catalog_visibility_incomplete".into(), + resource: None, + detail: "The inspection principal lacks database VIEW DEFINITION and is not sysadmin; catalog visibility may be filtered.".into(), + }); + } + if database_options.is_some_and(|row| row.get::("is_trustworthy_on").unwrap_or(false)) { + findings.push(SecurityFinding { + code: "sql_server_database_trustworthy_enabled".into(), + resource: None, + detail: "The database TRUSTWORTHY option is enabled; review ownership and module execution paths for privilege escalation risk.".into(), + }); + } + if database_options.is_some_and(|row| row.get::("is_db_chaining_on").unwrap_or(false)) { + findings.push(SecurityFinding { + code: "sql_server_database_chaining_enabled".into(), + resource: None, + detail: "Cross-database ownership chaining is enabled and requires explicit review of cross-database privilege paths.".into(), + }); + } + if is_sysadmin { + findings.push(SecurityFinding { + code: "sql_server_inspection_principal_sysadmin".into(), + resource: None, + detail: "The catalog inspection principal is sysadmin. Use a dedicated least-privilege inspection identity for production assessments.".into(), + }); + } + Ok(DiscoverySnapshot { + database_kind: DatabaseKind::SqlServer, + target: request.target.clone(), + completeness: if (can_view_definition || is_sysadmin) && !(table_inventory_truncated || view_inventory_truncated || routine_inventory_truncated) { InspectionCompleteness::Complete } else { InspectionCompleteness::Incomplete }, + target_attributes, + resources, + findings, + fingerprint: Some(fingerprint), + observed_at: chrono::Utc::now().to_rfc3339(), + }) + } + + async fn discover_bounded(&self, request: &DiscoveryRequest) -> Result { + tokio::time::timeout(std::time::Duration::from_secs(60), self.discover_inner(request)) + .await + .map_err(|_| AdapterError { + code: "sql_server_catalog_timeout".into(), + detail: "SQL Server catalog discovery exceeded the sixty-second operation deadline.".into(), + retryable: true, + })? + } + +} + +impl DatabaseAdapter for SqlServerCatalogAdapter { + fn descriptor(&self) -> AdapterDescriptor { + AdapterDescriptor { + kind: DatabaseKind::SqlServer, + name: "Microsoft SQL Server catalog adapter", + maturity: AdapterMaturity::InDevelopment, + capabilities: AdapterCapabilities { schema_inspection: true, policy_generation: true, drift_detection: true, ..AdapterCapabilities::default() }, + status_note: "Encrypted TDS catalog discovery covers tables, columns, object permissions, RLS predicates, triggers, views, routines, principals, role membership and database permissions. Trusted SESSION_CONTEXT binding, controlled deployment, independent semantic probes and signed admission remain unavailable.", + } + } + + fn discover<'a>(&'a self, request: &'a DiscoveryRequest) -> AdapterFuture<'a, Result> { + Box::pin(async move { self.discover_bounded(request).await }) + } + + fn inspect<'a>(&'a self, request: &'a InspectionRequest) -> AdapterFuture<'a, Result> { + Box::pin(async move { + self.validate_target(&request.target)?; + request.policy.validate().map_err(|_| error("invalid_policy", "The canonical tenant policy failed validation."))?; + let _compiled_plan = compile_sql_server(&request.policy)?; + let discovery = self.discover_bounded(&DiscoveryRequest { target: request.target.clone(), namespace: None }).await?; + let mut findings = discovery.findings.clone(); + let mut resources = Vec::with_capacity(request.policy.resources.len()); + for protected in &request.policy.resources { + if protected.resource.kind != ResourceKind::Table { + return Err(error("unsupported_sql_server_policy_resource", "The current SQL Server RLS compiler manages tables only.")); + } + let protected_schema = protected.resource.namespace.as_deref().unwrap_or("dbo"); + let found = discovery.resources.iter().find(|resource| { + resource.namespace.as_deref() == Some(protected_schema) && resource.name == protected.resource.name + && resource.kind == ResourceKind::Table + }); + let mut resource_findings = Vec::new(); + let Some(found) = found else { + resource_findings.push(finding("protected_resource_not_found", &protected.resource, "The registered SQL Server table was not visible in sys.tables.")); + findings.extend(resource_findings.clone()); + resources.push(ResourceInspection { + resource: protected.clone(), completeness: InspectionCompleteness::Incomplete, + posture: SecurityPosture::Blocked, verified_operations: Vec::new(), + findings: resource_findings, fingerprint: None, + }); + continue; + }; + let columns = found.attributes["columns"].as_array().cloned().unwrap_or_default(); + let tenant_column = columns.iter().find(|column| column["name"].as_str() == Some(protected.tenant_key.as_str())); + match tenant_column { + None => resource_findings.push(finding("tenant_ownership_column_missing", &protected.resource, "The policy tenant ownership column does not exist.")), + Some(column) if column["nullable"].as_bool() != Some(false) => + resource_findings.push(finding("tenant_ownership_column_nullable", &protected.resource, "The tenant ownership column permits NULL values.")), + _ => {} + } + let predicates = found.attributes["security_predicates"].as_array().cloned().unwrap_or_default(); + let enabled = predicates.iter().any(|predicate| predicate["enabled"].as_bool() == Some(true)); + if !enabled { + resource_findings.push(finding("sql_server_rls_policy_missing_or_disabled", &protected.resource, "No enabled SQL Server security policy predicate protects this table.")); + } + if predicates.iter().any(|predicate| predicate["enabled"].as_bool() == Some(false)) { + resource_findings.push(finding("sql_server_disabled_rls_policy_present", &protected.resource, "One or more SQL Server RLS predicates are disabled and may leave an intended operation unprotected.")); + } + if predicates.iter().any(|predicate| predicate["schema_bound"].as_bool() != Some(true)) { + resource_findings.push(finding("sql_server_rls_policy_not_schema_bound", &protected.resource, "An RLS security policy is not confirmed schema-bound.")); + } + let has_filter = predicates.iter().any(|predicate| predicate["enabled"].as_bool() == Some(true) && predicate["predicate_type"].as_str() == Some("FILTER")); + let has_after_insert = predicates.iter().any(|predicate| predicate["enabled"].as_bool() == Some(true) && predicate["operation"].as_str() == Some("AFTER INSERT")); + let has_before_update = predicates.iter().any(|predicate| predicate["enabled"].as_bool() == Some(true) && predicate["operation"].as_str() == Some("BEFORE UPDATE")); + let has_after_update = predicates.iter().any(|predicate| predicate["enabled"].as_bool() == Some(true) && predicate["operation"].as_str() == Some("AFTER UPDATE")); + let has_before_delete = predicates.iter().any(|predicate| predicate["enabled"].as_bool() == Some(true) && predicate["operation"].as_str() == Some("BEFORE DELETE")); + if protected.operations.contains(&Operation::Read) && !has_filter { + resource_findings.push(finding("sql_server_filter_predicate_missing", &protected.resource, "Read operations require an enabled FILTER predicate.")); + } + if protected.operations.contains(&Operation::Create) && !has_after_insert { + resource_findings.push(finding("sql_server_insert_block_predicate_missing", &protected.resource, "Create operations require an AFTER INSERT block predicate.")); + } + if protected.operations.contains(&Operation::Update) && !(has_before_update && has_after_update) { + resource_findings.push(finding("sql_server_update_block_predicates_incomplete", &protected.resource, "Update isolation requires both BEFORE UPDATE and AFTER UPDATE block predicates to prevent cross-tenant row reassignment.")); + } + if protected.operations.contains(&Operation::Delete) && !has_before_delete { + resource_findings.push(finding("sql_server_delete_block_predicate_missing", &protected.resource, "Delete operations require a BEFORE DELETE block predicate.")); + } + let predicate_function_identities = predicates.iter() + .filter_map(|predicate| predicate["definition"].as_str().and_then(predicate_function_identity)) + .collect::>(); + let predicate_functions = discovery.resources.iter().filter(|resource| { + resource.kind == ResourceKind::Function && predicate_function_identities.iter().any(|(schema, name)| { + name.eq_ignore_ascii_case(&resource.name) + && schema.as_deref().is_none_or(|schema| resource.namespace.as_deref().is_some_and(|actual| actual.eq_ignore_ascii_case(schema))) + }) + }).collect::>(); + let predicate_definitions_visible = predicate_functions.iter().any(|function| function.attributes["definition"].as_str().is_some()); + if !predicates.is_empty() && (predicate_functions.is_empty() || !predicate_definitions_visible) { + resource_findings.push(finding("sql_server_predicate_function_definition_unavailable", &protected.resource, "The RLS predicate function definition was not visible in the catalog; its tenant identity source cannot be inspected.")); + } else if !predicate_functions.is_empty() && !predicate_functions.iter().any(|function| { + function.attributes["definition"].as_str().is_some_and(|definition| definition.to_ascii_uppercase().contains("SESSION_CONTEXT")) + }) { + resource_findings.push(finding("sql_server_tenant_context_predicate_missing", &protected.resource, "The RLS predicate function definitions do not reference SESSION_CONTEXT; verify that they bind rows to authenticated tenant identity.")); + } + if predicate_functions.iter().any(|function| function.attributes["schema_bound"].as_bool() != Some(true)) { + resource_findings.push(finding("sql_server_predicate_function_not_schema_bound", &protected.resource, "A predicate function is not confirmed schema-bound; SQL Server RLS predicate functions should be schema-bound.")); + } + if predicate_functions.iter().any(|function| function.attributes["execute_as_principal_id"].as_i64().is_some()) { + resource_findings.push(finding("sql_server_predicate_function_execute_as", &protected.resource, "An RLS predicate function uses EXECUTE AS; review its effective permissions and tenant-boundary behavior.")); + } + if found.attributes["triggers"].as_array().is_some_and(|triggers| triggers.iter().any(|trigger| trigger["execute_as_principal_id"].as_i64().is_some())) { + resource_findings.push(finding("sql_server_trigger_execute_as", &protected.resource, "A table trigger uses EXECUTE AS and requires review for elevated cross-tenant data access.")); + } + resource_findings.push(finding("sql_server_session_context_trust_unverified", &protected.resource, "SESSION_CONTEXT is settable by a database session unless the application/gateway boundary prevents untrusted callers from setting tenant identity.")); + let resource_fingerprint = digest(&serde_json::to_vec(&found.attributes) + .map_err(|_| error("fingerprint_serialization_failed", "Could not serialize SQL Server resource inspection."))?); + findings.extend(resource_findings.clone()); + resources.push(ResourceInspection { + resource: protected.clone(), + completeness: discovery.completeness, + posture: SecurityPosture::NeedsAttention, + verified_operations: Vec::new(), + findings: resource_findings, + fingerprint: Some(resource_fingerprint), + }); + } + Ok(InspectionSnapshot { + database_kind: DatabaseKind::SqlServer, + target: request.target.clone(), + completeness: discovery.completeness, + posture: SecurityPosture::NeedsAttention, + resources, + findings, + fingerprint: discovery.fingerprint, + observed_at: discovery.observed_at, + }) + }) + } + + fn compile_policy(&self, policy: &TenantSecurityPolicy) -> Result { compile_sql_server(policy) } + + fn verify<'a>(&'a self, policy: &'a TenantSecurityPolicy, snapshot: &'a InspectionSnapshot) -> AdapterFuture<'a, Result> { + Box::pin(async move { + if snapshot.database_kind != DatabaseKind::SqlServer || snapshot.target.target_id != self.target_id + || snapshot.target.database_name != self.database_name { + return Err(error("sql_server_snapshot_target_mismatch", "The inspection snapshot does not belong to this SQL Server adapter target.")); + } + let mut findings = snapshot.findings.clone(); + findings.push(SecurityFinding { + code: "sql_server_independent_tenant_probes_required".into(), + resource: None, + detail: format!("{} protected tables require own-tenant allow and cross-tenant deny probes for read/create/update/delete.", policy.resources.len()), + }); + findings.push(SecurityFinding { + code: "sql_server_runtime_tenant_binding_unavailable".into(), + resource: None, + detail: "No trusted SQL Server protocol gateway currently binds authenticated tenant identity to an unforgeable SESSION_CONTEXT value.".into(), + }); + Ok(VerificationReport { model_version: SECURITY_MODEL_VERSION.into(), posture: SecurityPosture::Blocked, inspection: snapshot.completeness, findings }) + }) + } + + fn detect_drift<'a>(&'a self, target: &'a AdapterTarget, previous_fingerprint: Option<&'a str>) -> AdapterFuture<'a, Result> { + Box::pin(async move { + self.validate_target(target)?; + if previous_fingerprint.is_some_and(|value| value.len() != 64 || hex::decode(value).map_or(true, |bytes| bytes.len() != 32)) { + return Err(error("invalid_previous_fingerprint", "The previous fingerprint must be a 32-byte hexadecimal SHA-256 digest.")); + } + let snapshot = self.discover_bounded(&DiscoveryRequest { target: target.clone(), namespace: None }).await?; + Ok(DriftReport { + database_kind: DatabaseKind::SqlServer, target: target.clone(), + detected: previous_fingerprint.is_some_and(|previous| Some(previous) != snapshot.fingerprint.as_deref()), + completeness: snapshot.completeness, previous_fingerprint: previous_fingerprint.map(str::to_owned), + observed_fingerprint: snapshot.fingerprint, findings: snapshot.findings, observed_at: snapshot.observed_at, + }) + }) + } +} + +fn predicate_function_identity(definition: &str) -> Option<(Option, String)> { + let call = definition.split('(').next()?.trim(); + let normalized = call.replace('[', "").replace(']', ""); + let parts = normalized.split('.').map(str::trim).filter(|part| !part.is_empty()).collect::>(); + let name = parts.last()?.to_string(); + let schema = if parts.len() >= 2 { Some(parts[parts.len() - 2].to_string()) } else { None }; + Some((schema, name)) +} + +fn finding(code: &str, resource: &ResourceRef, detail: &str) -> SecurityFinding { + SecurityFinding { code: code.into(), resource: Some(resource.clone()), detail: detail.into() } +} + +fn digest(bytes: &[u8]) -> String { + let mut hash = Sha256::new(); + hash.update(bytes); + hex::encode(hash.finalize()) +} + +fn error(code: &str, detail: &str) -> AdapterError { + AdapterError { code: code.into(), detail: detail.into(), retryable: false } +} + +fn db_error(_error: impl std::fmt::Display) -> AdapterError { + AdapterError { code: "sql_server_catalog_operation_failed".into(), detail: "The encrypted SQL Server catalog operation failed.".into(), retryable: false } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn rejects_unverified_sql_server_transport_options() { + assert!(SqlServerCatalogAdapter::new("target", "app", "Server=localhost;Database=app;TrustServerCertificate=true").is_err()); + assert!(SqlServerCatalogAdapter::new("target", "app", "Server=localhost;Database=app;Encrypt=false").is_err()); + assert!(SqlServerCatalogAdapter::new("target", "app", "Server=localhost;Database=app;Integrated Security=true").is_err()); + } + + #[test] + fn extracts_schema_qualified_rls_predicate_function_names() { + assert_eq!(predicate_function_identity("[security].[fn_tenant_access]([tenant_id])").as_ref(), Some(&(Some("security".into()), "fn_tenant_access".into()))); + assert_eq!(predicate_function_identity("security.fn_tenant_access([tenant_id])").as_ref(), Some(&(Some("security".into()), "fn_tenant_access".into()))); + assert_eq!(predicate_function_identity(""), None); + } + + #[tokio::test] + async fn verification_never_allows_catalog_only_sql_server_evidence() { + use crate::security_core::{ProtectedResource, ResourceRef}; + let adapter = SqlServerCatalogAdapter::new("target", "app", "Server=localhost;Database=app;User Id=auditor;Password=example;Encrypt=True;TrustServerCertificate=False").unwrap(); + let policy = TenantSecurityPolicy { + schema_version: SECURITY_MODEL_VERSION.into(), + policy_id: "tenant-policy".into(), + revision: 1, + tenant_identity_claim: "tenant_id".into(), + resources: vec![ProtectedResource { + resource: ResourceRef { namespace: Some("dbo".into()), name: "records".into(), kind: ResourceKind::Table }, + tenant_key: "tenant_id".into(), + operations: vec![Operation::Read, Operation::Create, Operation::Update, Operation::Delete], + }], + }; + let snapshot = InspectionSnapshot { + database_kind: DatabaseKind::SqlServer, + target: AdapterTarget { target_id: "target".into(), database_name: "app".into(), namespace: None }, + completeness: InspectionCompleteness::Complete, + posture: SecurityPosture::Verified, + resources: Vec::new(), + findings: Vec::new(), + fingerprint: Some("a".repeat(64)), + observed_at: "2026-11-17T00:00:00Z".into(), + }; + let report = adapter.verify(&policy, &snapshot).await.unwrap(); + assert_eq!(report.posture, SecurityPosture::Blocked); + assert!(!report.findings.is_empty()); + } + + #[test] + fn rejects_invalid_database_target() { + assert!(SqlServerCatalogAdapter::new("", "app", "Server=localhost;Database=app").is_err()); + assert!(SqlServerCatalogAdapter::new("target", "", "Server=localhost;Database=app").is_err()); + } +} + +#[cfg(test)] +mod tenant_context_literal_tests { + use super::sql_server_unicode_literal; + + #[test] + fn unicode_literals_escape_quotes_and_reject_nul() { + assert_eq!(sql_server_unicode_literal("tenant'o", 128).unwrap(), "N'tenant''o'"); + let nul_value = format!("x{}y", char::from(0)); + assert!(sql_server_unicode_literal(&nul_value, 128).is_err()); + assert!(sql_server_unicode_literal(" ", 128).is_err()); + } +} diff --git a/crates/proxima-engine/src/sqlite_adapter.rs b/crates/proxima-engine/src/sqlite_adapter.rs new file mode 100644 index 00000000..e95e5ace --- /dev/null +++ b/crates/proxima-engine/src/sqlite_adapter.rs @@ -0,0 +1,496 @@ +//! SQLite native schema and filesystem discovery adapter. +//! +//! SQLite has no native users, row-level security or tenant-scoped database +//! principals. This adapter opens the file read-only, inspects schema objects +//! and filesystem permission bits, and never claims tenant isolation. +use crate::database_adapter::{ + AdapterError, AdapterFuture, AdapterTarget, CompiledPolicy, DatabaseAdapter, + DiscoveryRequest, DiscoverySnapshot, DiscoveredResource, DriftReport, + InspectionRequest, InspectionSnapshot, ResourceInspection, +}; +use crate::security_core::{ + AdapterCapabilities, AdapterDescriptor, AdapterMaturity, DatabaseKind, + InspectionCompleteness, ResourceKind, ResourceRef, SecurityFinding, + SecurityPosture, TenantSecurityPolicy, VerificationReport, SECURITY_MODEL_VERSION, +}; +use serde_json::json; +use sha2::{Digest, Sha256}; +use sqlx::{ + sqlite::{SqliteConnectOptions, SqliteConnection}, + Connection, Row, +}; +use std::{path::PathBuf, str::FromStr, time::Duration}; + +pub struct SqliteCatalogAdapter { + target_id: String, + database_path: PathBuf, + connection_uri: String, +} + +impl SqliteCatalogAdapter { + pub fn new( + target_id: impl Into, + database_path: impl Into, + connection_uri: impl Into, + ) -> Result { + let target_id = target_id.into(); + let database_path = database_path.into(); + let connection_uri = connection_uri.into(); + if target_id.trim().is_empty() || target_id.len() > 256 || target_id.contains('\0') + || connection_uri.trim().is_empty() || connection_uri.len() > 4096 + || connection_uri.contains('?') || connection_uri.contains('#') + || !database_path.is_absolute() + { + return Err(error("invalid_sqlite_target", "A bounded target ID, absolute database file path and SQLite connection URI are required.")); + } + if !connection_uri.to_ascii_lowercase().starts_with("sqlite:") || connection_uri.to_ascii_lowercase().contains(":memory:") { + return Err(error("sqlite_file_database_required", "SQLite tenant discovery requires a persistent file database; in-memory databases are not accepted.")); + } + let canonical_path = std::fs::canonicalize(&database_path) + .map_err(|_| error("sqlite_database_file_unavailable", "The registered SQLite database file does not exist or cannot be canonicalized."))?; + if !canonical_path.is_file() { + return Err(error("sqlite_database_path_not_file", "The registered SQLite database path must identify a regular file.")); + } + SqliteConnectOptions::from_str(&connection_uri) + .map_err(|_| error("invalid_sqlite_connection_uri", "The SQLite connection URI could not be parsed."))?; + Ok(Self { target_id, database_path: canonical_path, connection_uri }) + } + + fn validate_target(&self, target: &AdapterTarget) -> Result<(), AdapterError> { + if target.target_id != self.target_id { + return Err(error("sqlite_target_mismatch", "The request does not match this registered SQLite target ID.")); + } + let requested = std::fs::canonicalize(&target.database_name) + .map_err(|_| error("sqlite_target_path_unavailable", "The requested SQLite database path cannot be canonicalized."))?; + if requested != self.database_path { + return Err(error("sqlite_target_mismatch", "The request points to a different SQLite database file.")); + } + Ok(()) + } + + async fn connect_checked(&self) -> Result { + let options = SqliteConnectOptions::from_str(&self.connection_uri) + .map_err(|_| error("invalid_sqlite_connection_uri", "The SQLite connection URI could not be parsed."))? + .read_only(true) + .create_if_missing(false) + .busy_timeout(Duration::from_secs(5)) + .pragma("query_only", "ON") + .pragma("trusted_schema", "OFF") + .statement_cache_capacity(32); + let mut connection = tokio::time::timeout( + Duration::from_secs(10), + SqliteConnection::connect_with(&options), + ).await.map_err(|_| AdapterError { + code: "sqlite_connection_timeout".into(), + detail: "Opening the read-only SQLite database exceeded ten seconds.".into(), + retryable: true, + })?.map_err(db_error)?; + let databases = sqlx::query("PRAGMA database_list").fetch_all(&mut connection).await.map_err(db_error)?; + let mut main_path = None; + for database in databases { + let name: String = database.try_get("name").map_err(db_error)?; + let file: String = database.try_get("file").map_err(db_error)?; + if name == "main" { + main_path = Some(file); + } else if name != "temp" { + return Err(error("sqlite_attached_database_rejected", "Attached SQLite databases are not accepted because they expand the inspection boundary.")); + } + } + let actual_path = main_path.ok_or_else(|| error("sqlite_main_database_missing", "SQLite did not report a main database file."))?; + let actual_path = std::fs::canonicalize(actual_path) + .map_err(|_| error("sqlite_database_path_unavailable", "The connected SQLite main database file cannot be canonicalized."))?; + if actual_path != self.database_path { + return Err(error("sqlite_database_mismatch", "The authenticated connection opened a different SQLite database file.")); + } + Ok(connection) + } + + async fn discover_inner(&self, request: &DiscoveryRequest) -> Result { + self.validate_target(&request.target)?; + if request.namespace.is_some() { + return Err(error("sqlite_namespace_unsupported", "SQLite discovery does not accept a schema namespace; use the main database file.")); + } + let mut connection = self.connect_checked().await?; + let schema_rows = sqlx::query( + "SELECT type,name,tbl_name,sql FROM sqlite_master \ + WHERE type IN ('table','view') AND name NOT GLOB 'sqlite_*' \ + ORDER BY type,name LIMIT 10001" + ).fetch_all(&mut connection).await.map_err(db_error)?; + let truncated = schema_rows.len() > 10_000; + let mut resources = Vec::with_capacity(schema_rows.len().min(10_000)); + let mut state = Vec::new(); + let mut findings = Vec::new(); + for row in schema_rows.into_iter().take(10_000) { + let object_type: String = row.try_get("type").map_err(db_error)?; + let name: String = row.try_get("name").map_err(db_error)?; + let table_name: String = row.try_get("tbl_name").map_err(db_error)?; + let definition: Option = row.try_get("sql").map_err(db_error)?; + let kind = if object_type == "view" { ResourceKind::View } else { ResourceKind::Table }; + // SQLite's table-valued PRAGMA functions support both tables and views. + let columns = sqlx::query("SELECT cid,name,type,[notnull],dflt_value,pk,hidden FROM pragma_table_xinfo(?) ORDER BY cid") + .bind(&name).fetch_all(&mut connection).await.map_err(db_error)?; + let indexes = if kind == ResourceKind::Table { + sqlx::query("SELECT seq,name,[unique],origin,partial FROM pragma_index_list(?) ORDER BY seq") + .bind(&name).fetch_all(&mut connection).await.map_err(db_error)? + } else { Vec::new() }; + let foreign_keys = if kind == ResourceKind::Table { + sqlx::query("SELECT id,seq,[table],[from],[to],on_update,on_delete,[match] FROM pragma_foreign_key_list(?) ORDER BY id,seq") + .bind(&name).fetch_all(&mut connection).await.map_err(db_error)? + } else { Vec::new() }; + let mut index_state = Vec::new(); + for index in &indexes { + let index_name: String = index.try_get("name").map_err(db_error)?; + let index_columns = sqlx::query("SELECT seqno,cid,name,[desc],coll,key FROM pragma_index_xinfo(?) ORDER BY seqno") + .bind(&index_name).fetch_all(&mut connection).await.map_err(db_error)?; + index_state.push(json!({ + "sequence": index.try_get::("seq").map_err(db_error)?, + "name": index_name, + "unique": index.try_get::("unique").map_err(db_error)? != 0, + "origin": index.try_get::("origin").map_err(db_error)?, + "partial": index.try_get::("partial").map_err(db_error)? != 0, + "columns": index_columns.iter().map(|column| json!({ + "sequence": column.get::("seqno"), + "column_id": column.get::("cid"), + "name": column.get::,_>("name"), + "descending": column.get::("desc") != 0, + "collation": column.get::,_>("coll"), + "key_column": column.get::("key") != 0 + })).collect::>() + })); + } + let triggers = sqlx::query( + "SELECT name,sql FROM sqlite_master WHERE type='trigger' AND tbl_name=? ORDER BY name" + ).bind(&table_name).fetch_all(&mut connection).await.map_err(db_error)?; + let attributes = json!({ + "sqlite_object_type": object_type, + "definition": definition, + "columns": columns.iter().map(|column| json!({ + "ordinal": column.get::("cid"), + "name": column.get::("name"), + "type": column.get::("type"), + "not_null": column.get::("notnull") != 0, + "default": column.get::,_>("dflt_value"), + "primary_key_ordinal": column.get::("pk"), + "hidden": column.get::("hidden") + })).collect::>(), + "indexes": index_state, + "foreign_keys": foreign_keys.iter().map(|foreign_key| json!({ + "id": foreign_key.get::("id"), + "sequence": foreign_key.get::("seq"), + "referenced_table": foreign_key.get::("table"), + "from": foreign_key.get::("from"), + "to": foreign_key.get::,_>("to"), + "on_update": foreign_key.get::("on_update"), + "on_delete": foreign_key.get::("on_delete"), + "match": foreign_key.get::("match") + })).collect::>(), + "triggers": triggers.iter().map(|trigger| json!({ + "name": trigger.get::("name"), + "definition": trigger.get::,_>("sql") + })).collect::>() + }); + let reference = ResourceRef { namespace: None, name: name.clone(), kind }; + if kind == ResourceKind::View { + findings.push(SecurityFinding { + code: "sqlite_view_requires_dependency_review".into(), + resource: Some(reference.clone()), + detail: "SQLite views do not provide tenant isolation; review their complete dependency graph and application access paths.".into(), + }); + } + resources.push(DiscoveredResource { + namespace: None, + name: name.clone(), + kind, + owner: None, + attributes: attributes.clone(), + }); + state.push(json!({ "name": name, "kind": object_type, "attributes": attributes })); + } + if truncated { + findings.push(SecurityFinding { + code: "sqlite_inventory_truncated".into(), + resource: None, + detail: "The SQLite schema exceeded 10,000 tables/views; the inventory is incomplete.".into(), + }); + } + let database_list = sqlx::query("PRAGMA database_list").fetch_all(&mut connection).await.map_err(db_error)?; + let file_row = database_list.iter().find(|row| row.get::("name") == "main") + .ok_or_else(|| error("sqlite_main_database_missing", "SQLite did not report its main database file."))?; + let file: String = file_row.try_get("file").map_err(db_error)?; + let file_metadata = std::fs::metadata(&self.database_path) + .map_err(|_| error("sqlite_file_metadata_unavailable", "The SQLite database file metadata could not be read."))?; + let parent_metadata = self.database_path.parent().and_then(|path| std::fs::metadata(path).ok()); + let wal_path = PathBuf::from(format!("{}-wal", self.database_path.display())); + let shm_path = PathBuf::from(format!("{}-shm", self.database_path.display())); + let wal_metadata = std::fs::metadata(wal_path).ok(); + let shm_metadata = std::fs::metadata(shm_path).ok(); + let filesystem = filesystem_permissions( + &file_metadata, + parent_metadata.as_ref(), + wal_metadata.as_ref(), + shm_metadata.as_ref(), + ); + if filesystem.unsafe_permissions { + findings.push(SecurityFinding { + code: "sqlite_filesystem_permissions_too_broad".into(), + resource: None, + detail: "The database file or containing directory grants group/other access. SQLite tenant isolation depends on OS-level file and directory permissions.".into(), + }); + } + if !filesystem.assessed { + findings.push(SecurityFinding { + code: "sqlite_filesystem_acl_not_assessed".into(), + resource: None, + detail: "This platform does not expose the filesystem ACL detail required to assess tenant-exclusive file access.".into(), + }); + } + let pragma_rows = sqlx::query("PRAGMA foreign_keys").fetch_all(&mut connection).await.map_err(db_error)?; + let foreign_keys_enabled = pragma_rows.first().and_then(|row| row.try_get::(0).ok()).unwrap_or(0) != 0; + let journal_mode: String = sqlx::query_scalar("PRAGMA journal_mode").fetch_one(&mut connection).await.map_err(db_error)?; + let user_version: i64 = sqlx::query_scalar("PRAGMA user_version").fetch_one(&mut connection).await.map_err(db_error)?; + let application_id: i64 = sqlx::query_scalar("PRAGMA application_id").fetch_one(&mut connection).await.map_err(db_error)?; + let target_attributes = json!({ + "database_file": file, + "filesystem_permissions": filesystem, + "inspection_connection_foreign_keys_enabled": foreign_keys_enabled, + "journal_mode": journal_mode, + "user_version": user_version, + "application_id": application_id, + "read_only_connection": true, + "query_only": true, + "inspection_connection_trusted_schema_disabled": true + }); + let fingerprint = digest(&serde_json::to_vec(&json!({ "target_id": self.target_id, "database_path": self.database_path.display().to_string(), "target": target_attributes, "resources": state })) + .map_err(|_| error("sqlite_fingerprint_failed", "Could not serialize SQLite catalog state."))?); + Ok(DiscoverySnapshot { + database_kind: DatabaseKind::Sqlite, + target: request.target.clone(), + completeness: if truncated || !filesystem.assessed { InspectionCompleteness::Incomplete } else { InspectionCompleteness::Complete }, + target_attributes, + resources, + findings, + fingerprint: Some(fingerprint), + observed_at: chrono::Utc::now().to_rfc3339(), + }) + } + + async fn discover_bounded(&self, request: &DiscoveryRequest) -> Result { + tokio::time::timeout(Duration::from_secs(60), self.discover_inner(request)) + .await + .map_err(|_| AdapterError { + code: "sqlite_catalog_timeout".into(), + detail: "SQLite schema and filesystem discovery exceeded the sixty-second operation deadline.".into(), + retryable: true, + })? + } +} + +impl DatabaseAdapter for SqliteCatalogAdapter { + fn descriptor(&self) -> AdapterDescriptor { + AdapterDescriptor { + kind: DatabaseKind::Sqlite, + name: "SQLite file-isolation discovery adapter", + maturity: AdapterMaturity::InDevelopment, + capabilities: AdapterCapabilities { schema_inspection: true, drift_detection: true, ..AdapterCapabilities::default() }, + status_note: "Read-only SQLite schema discovery fingerprints tables, views, columns, indexes, foreign keys, triggers and filesystem permission metadata. SQLite has no native users or RLS; tenant isolation requires a file-per-tenant design, OS ACL enforcement, trusted file selection and independent access probes. No runtime admission or policy deployment is implemented.", + } + } + + fn discover<'a>(&'a self, request: &'a DiscoveryRequest) -> AdapterFuture<'a, Result> { + Box::pin(async move { self.discover_bounded(request).await }) + } + + fn inspect<'a>(&'a self, request: &'a InspectionRequest) -> AdapterFuture<'a, Result> { + Box::pin(async move { + request.policy.validate().map_err(|_| error("invalid_policy", "The canonical tenant policy failed validation."))?; + let discovery = self.discover_bounded(&DiscoveryRequest { target: request.target.clone(), namespace: None }).await?; + let mut findings = discovery.findings.clone(); + let mut inspected = Vec::new(); + for required in &request.policy.resources { + let resource = discovery.resources.iter().find(|resource| { + resource.namespace == required.resource.namespace + && resource.name == required.resource.name + && resource.kind == required.resource.kind + }); + let Some(resource) = resource else { + findings.push(finding("sqlite_required_resource_missing", &required.resource, "The policy resource is not present in the SQLite schema inventory.")); + continue; + }; + let columns = resource.attributes.get("columns").and_then(|value| value.as_array()).cloned().unwrap_or_default(); + let tenant_column = columns.iter().find(|column| column.get("name").and_then(|value| value.as_str()) == Some(required.tenant_key.as_str())); + let mut resource_findings = Vec::new(); + match tenant_column { + None => resource_findings.push(finding("sqlite_tenant_key_missing", &required.resource, "The declared tenant ownership column does not exist.")), + Some(column) if column.get("not_null").and_then(|value| value.as_bool()) != Some(true) => + resource_findings.push(finding("sqlite_tenant_key_nullable", &required.resource, "The tenant ownership column must be explicitly NOT NULL.")), + _ => {} + } + findings.extend(resource_findings.iter().cloned()); + inspected.push(ResourceInspection { + resource: required.clone(), + completeness: discovery.completeness, + posture: SecurityPosture::NeedsAttention, + verified_operations: Vec::new(), + findings: resource_findings, + fingerprint: discovery.fingerprint.clone(), + }); + } + findings.push(SecurityFinding { + code: "sqlite_native_tenant_authorization_unavailable".into(), + resource: None, + detail: "SQLite has no native row-level security or per-tenant database users. A trusted file-per-tenant selector and operating-system file/directory isolation must be implemented and independently tested.".into(), + }); + Ok(InspectionSnapshot { + database_kind: DatabaseKind::Sqlite, + target: discovery.target, + completeness: discovery.completeness, + posture: SecurityPosture::NeedsAttention, + resources: inspected, + findings, + fingerprint: discovery.fingerprint, + observed_at: discovery.observed_at, + }) + }) + } + + fn compile_policy(&self, _policy: &TenantSecurityPolicy) -> Result { + Err(error("sqlite_policy_compilation_unavailable", "SQLite has no native tenant policy mechanism. Use a reviewed file-per-tenant deployment design with OS-level isolation; the adapter will not generate misleading row-policy SQL.")) + } + + fn verify<'a>(&'a self, _policy: &'a TenantSecurityPolicy, snapshot: &'a InspectionSnapshot) -> AdapterFuture<'a, Result> { + Box::pin(async move { + if snapshot.database_kind != DatabaseKind::Sqlite { + return Err(error("sqlite_snapshot_target_mismatch", "The inspection snapshot belongs to a different database kind.")); + } + self.validate_target(&snapshot.target)?; + let mut findings = snapshot.findings.clone(); + findings.push(SecurityFinding { + code: "sqlite_semantic_verification_unavailable".into(), + resource: None, + detail: "SQLite file isolation has not been proven through independent tenant identities, OS-level permission checks and cross-tenant file-access probes.".into(), + }); + Ok(VerificationReport { + model_version: SECURITY_MODEL_VERSION.into(), + posture: SecurityPosture::Blocked, + inspection: snapshot.completeness, + findings, + }) + }) + } + + fn detect_drift<'a>(&'a self, target: &'a AdapterTarget, previous_fingerprint: Option<&'a str>) -> AdapterFuture<'a, Result> { + Box::pin(async move { + self.validate_target(target)?; + if previous_fingerprint.is_some_and(|value| value.len() != 64 || hex::decode(value).map_or(true, |bytes| bytes.len() != 32)) { + return Err(error("invalid_previous_fingerprint", "The previous fingerprint must be a 32-byte hexadecimal SHA-256 digest.")); + } + let snapshot = self.discover_bounded(&DiscoveryRequest { target: target.clone(), namespace: None }).await?; + let detected = previous_fingerprint.is_some_and(|previous| Some(previous) != snapshot.fingerprint.as_deref()); + Ok(DriftReport { + database_kind: DatabaseKind::Sqlite, + target: target.clone(), + detected, + completeness: snapshot.completeness, + previous_fingerprint: previous_fingerprint.map(str::to_owned), + observed_fingerprint: snapshot.fingerprint, + findings: if detected { vec![SecurityFinding { + code: "sqlite_catalog_fingerprint_changed".into(), + resource: None, + detail: "SQLite schema or filesystem permission metadata differs from the previously accepted fingerprint.".into(), + }] } else { snapshot.findings }, + observed_at: snapshot.observed_at, + }) + }) + } +} + +#[derive(Clone, Copy, Debug, serde::Serialize)] +struct FilesystemPermissions { + assessed: bool, + unsafe_permissions: bool, + file_mode: Option, + parent_mode: Option, + wal_mode: Option, + shm_mode: Option, +} + +fn filesystem_permissions( + file: &std::fs::Metadata, + parent: Option<&std::fs::Metadata>, + wal: Option<&std::fs::Metadata>, + shm: Option<&std::fs::Metadata>, +) -> FilesystemPermissions { + #[cfg(unix)] + { + use std::os::unix::fs::PermissionsExt; + let file_mode = file.permissions().mode() & 0o777; + let parent_mode = parent.map(|metadata| metadata.permissions().mode() & 0o777); + let wal_mode = wal.map(|metadata| metadata.permissions().mode() & 0o777); + let shm_mode = shm.map(|metadata| metadata.permissions().mode() & 0o777); + let sidecar_is_unsafe = wal_mode.into_iter().chain(shm_mode).any(|mode| (mode & 0o077) != 0); + FilesystemPermissions { + assessed: true, + unsafe_permissions: (file_mode & 0o077) != 0 + || parent_mode.map_or(true, |mode| (mode & 0o077) != 0) + || sidecar_is_unsafe, + file_mode: Some(file_mode), + parent_mode, + wal_mode, + shm_mode, + } + } + #[cfg(not(unix))] + { + let _ = (file, parent, wal, shm); + FilesystemPermissions { + assessed: false, + unsafe_permissions: true, + file_mode: None, + parent_mode: None, + wal_mode: None, + shm_mode: None, + } + } +} + +fn digest(bytes: &[u8]) -> String { hex::encode(Sha256::digest(bytes)) } +fn finding(code: &str, resource: &ResourceRef, detail: &str) -> SecurityFinding { + SecurityFinding { code: code.into(), resource: Some(resource.clone()), detail: detail.into() } +} +fn error(code: &str, detail: &str) -> AdapterError { AdapterError { code: code.into(), detail: detail.into(), retryable: false } } +fn db_error(error: sqlx::Error) -> AdapterError { + AdapterError { + code: "sqlite_catalog_query_failed".into(), + detail: "The read-only SQLite catalog operation failed.".into(), + retryable: matches!(error, sqlx::Error::PoolTimedOut | sqlx::Error::Io(_)), + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn rejects_memory_databases_and_relative_paths() { + assert!(SqliteCatalogAdapter::new("target", "/tmp/app.db", "sqlite::memory:").is_err()); + assert!(SqliteCatalogAdapter::new("target", "app.db", "sqlite://app.db").is_err()); + } + + #[test] + fn descriptor_claims_discovery_only() { + let file = tempfile::NamedTempFile::new().unwrap(); + let path = file.path().to_path_buf(); + let uri = format!("sqlite://{}", path.display()); + let adapter = SqliteCatalogAdapter::new("target", path, uri).unwrap(); + let descriptor = adapter.descriptor(); + assert_eq!(descriptor.maturity, AdapterMaturity::InDevelopment); + assert!(descriptor.capabilities.schema_inspection); + assert!(descriptor.capabilities.drift_detection); + assert!(!descriptor.capabilities.tenant_identity_enforcement); + assert!(!descriptor.capabilities.policy_semantic_verification); + assert!(!descriptor.capabilities.policy_generation); + assert!(!descriptor.capabilities.controlled_policy_deployment); + assert!(!descriptor.capabilities.runtime_fail_closed_admission); + assert!(!descriptor.capabilities.signed_security_evidence); + } +} diff --git a/crates/proxima-engine/src/tenant_identity.rs b/crates/proxima-engine/src/tenant_identity.rs new file mode 100644 index 00000000..2600e87f --- /dev/null +++ b/crates/proxima-engine/src/tenant_identity.rs @@ -0,0 +1,274 @@ +//! Cross-database trusted tenant identity claims. +//! +//! Tokens are bound to one authenticated principal, tenant, database target, +//! database family, policy revision, and short validity window. A verified +//! identity is a distinct type so callers cannot treat decoded, unsigned claims +//! as trusted context. + +use crate::{policy_evidence::AdmissionExpectation, security_core::DatabaseKind}; +use hmac::{Hmac, Mac}; +use serde::{Deserialize, Serialize}; +use sha2::Sha256; +use std::fmt; + +type HmacSha256 = Hmac; +const TOKEN_VERSION: &str = "pti1"; +const CLAIMS_VERSION: &str = "proxima.tenant-identity.v1"; +const SIGNING_DOMAIN: &[u8] = b"proxima-tenant-identity-v1\0"; +const MAX_TOKEN_BYTES: usize = 16 * 1024; +const MAX_IDENTITY_LIFETIME_SECONDS: i64 = 60; + +#[derive(Clone, Debug, Eq, PartialEq)] +pub struct TenantIdentityError { + pub code: &'static str, + pub detail: &'static str, +} + +impl fmt::Display for TenantIdentityError { + fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(formatter, "{}: {}", self.code, self.detail) + } +} + +impl std::error::Error for TenantIdentityError {} + +fn error(code: &'static str, detail: &'static str) -> TenantIdentityError { + TenantIdentityError { code, detail } +} + +/// Claims produced by a trusted identity issuer. The principal and tenant +/// relationship must come from authenticated control-plane identity. +#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +pub struct TenantIdentityClaims { + pub schema_version: String, + pub tenant_id: String, + pub principal_id: String, + pub target_id: String, + pub database_kind: DatabaseKind, + pub policy_id: String, + pub policy_revision: u64, + pub request_id: String, + pub issued_at_unix: i64, + pub expires_at_unix: i64, +} + +/// Scope expected by the receiving database runtime. +#[derive(Clone, Copy, Debug, Eq, PartialEq)] +pub struct TenantIdentityExpectation<'a> { + pub tenant_id: &'a str, + pub principal_id: &'a str, + pub target_id: &'a str, + pub database_kind: DatabaseKind, + pub policy_id: &'a str, + pub policy_revision: u64, +} + +/// A verified identity has private claims and can only be constructed by +/// TenantIdentityAuthority after signature, lifetime, and scope checks pass. +#[derive(Clone, Debug, Eq, PartialEq)] +pub struct VerifiedTenantIdentity { + claims: TenantIdentityClaims, +} + +impl VerifiedTenantIdentity { + pub fn tenant_id(&self) -> &str { &self.claims.tenant_id } + pub fn principal_id(&self) -> &str { &self.claims.principal_id } + pub fn target_id(&self) -> &str { &self.claims.target_id } + pub fn database_kind(&self) -> DatabaseKind { self.claims.database_kind } + pub fn policy_id(&self) -> &str { &self.claims.policy_id } + pub fn policy_revision(&self) -> u64 { self.claims.policy_revision } + pub fn request_id(&self) -> &str { &self.claims.request_id } + pub fn issued_at_unix(&self) -> i64 { self.claims.issued_at_unix } + pub fn expires_at_unix(&self) -> i64 { self.claims.expires_at_unix } + + /// Derive admission expectations from verified claims instead of accepting + /// separate caller-supplied tenant, target, or policy values. + pub fn admission_expectation(&self) -> AdmissionExpectation<'_> { + AdmissionExpectation { + database_kind: self.claims.database_kind, + policy_id: &self.claims.policy_id, + policy_revision: self.claims.policy_revision, + target_id: &self.claims.target_id, + tenant_id: &self.claims.tenant_id, + } + } +} + +#[derive(Clone)] +pub struct TenantIdentityAuthority { + key: Vec, +} + +impl TenantIdentityAuthority { + pub fn new(key: impl AsRef<[u8]>) -> Result { + let key = key.as_ref(); + if key.len() < 32 { + return Err(error("identity_key_too_short", "Tenant identity signing keys must contain at least 32 bytes.")); + } + Ok(Self { key: key.to_vec() }) + } + + /// Sign one exact, short-lived tenant/database/policy scope. + pub fn sign(&self, claims: &TenantIdentityClaims, now_unix: i64) -> Result { + validate_claims(claims)?; + validate_time(claims, now_unix)?; + let payload = serde_json::to_vec(claims) + .map_err(|_| error("identity_serialization_failed", "Tenant identity claims could not be serialized."))?; + let mut mac = HmacSha256::new_from_slice(&self.key) + .map_err(|_| error("identity_key_invalid", "Tenant identity signing key could not be initialized."))?; + mac.update(SIGNING_DOMAIN); + mac.update(&payload); + Ok(format!("{TOKEN_VERSION}.{}.{}", hex::encode(payload), hex::encode(mac.finalize().into_bytes()))) + } + + /// Verify signature, short lifetime, and every expected scope field. + pub fn verify( + &self, + token: &str, + expected: TenantIdentityExpectation<'_>, + now_unix: i64, + ) -> Result { + if token.len() > MAX_TOKEN_BYTES { + return Err(error("identity_token_too_large", "Tenant identity token exceeds the configured size bound.")); + } + let mut parts = token.split('.'); + if parts.next() != Some(TOKEN_VERSION) { + return Err(error("identity_token_version_invalid", "Tenant identity token has an unsupported version.")); + } + let encoded_payload = parts.next().ok_or_else(|| error("identity_token_malformed", "Tenant identity token is incomplete."))?; + let encoded_signature = parts.next().ok_or_else(|| error("identity_token_malformed", "Tenant identity token is incomplete."))?; + if parts.next().is_some() { + return Err(error("identity_token_malformed", "Tenant identity token contains extra fields.")); + } + let payload = hex::decode(encoded_payload) + .map_err(|_| error("identity_token_malformed", "Tenant identity payload is not valid hexadecimal."))?; + let signature = hex::decode(encoded_signature) + .map_err(|_| error("identity_token_malformed", "Tenant identity signature is not valid hexadecimal."))?; + let mut mac = HmacSha256::new_from_slice(&self.key) + .map_err(|_| error("identity_key_invalid", "Tenant identity verification key could not be initialized."))?; + mac.update(SIGNING_DOMAIN); + mac.update(&payload); + mac.verify_slice(&signature) + .map_err(|_| error("identity_signature_invalid", "Tenant identity signature verification failed."))?; + let claims: TenantIdentityClaims = serde_json::from_slice(&payload) + .map_err(|_| error("identity_claims_invalid", "Signed tenant identity claims are malformed or contain unknown fields."))?; + validate_claims(&claims)?; + validate_time(&claims, now_unix)?; + if claims.tenant_id != expected.tenant_id + || claims.principal_id != expected.principal_id + || claims.target_id != expected.target_id + || claims.database_kind != expected.database_kind + || claims.policy_id != expected.policy_id + || claims.policy_revision != expected.policy_revision + { + return Err(error("identity_scope_mismatch", "Tenant identity is not bound to the authenticated principal, database target, engine, tenant, and exact policy revision.")); + } + Ok(VerifiedTenantIdentity { claims }) + } +} + +fn valid_text(value: &str, max_bytes: usize) -> bool { + !value.trim().is_empty() && value.len() <= max_bytes && !value.contains('\0') +} + +fn validate_claims(claims: &TenantIdentityClaims) -> Result<(), TenantIdentityError> { + let lifetime = claims.expires_at_unix.checked_sub(claims.issued_at_unix); + if claims.schema_version != CLAIMS_VERSION + || !valid_text(&claims.tenant_id, 128) + || !valid_text(&claims.principal_id, 256) + || !valid_text(&claims.target_id, 256) + || !valid_text(&claims.policy_id, 128) + || !valid_text(&claims.request_id, 128) + || uuid::Uuid::parse_str(&claims.request_id) + .map_or(true, |request_id| request_id.to_string() != claims.request_id) + || claims.policy_revision == 0 + || claims.issued_at_unix < 0 + || claims.expires_at_unix <= claims.issued_at_unix + || lifetime.map_or(true, |seconds| seconds > MAX_IDENTITY_LIFETIME_SECONDS) + { + return Err(error("identity_claims_invalid", "Tenant identity claims are incomplete, malformed, or exceed the 60-second lifetime bound.")); + } + Ok(()) +} + +fn validate_time(claims: &TenantIdentityClaims, now_unix: i64) -> Result<(), TenantIdentityError> { + if now_unix < claims.issued_at_unix { + return Err(error("identity_not_yet_valid", "Tenant identity is not valid yet.")); + } + if now_unix >= claims.expires_at_unix { + return Err(error("identity_expired", "Tenant identity has expired.")); + } + Ok(()) +} + +#[cfg(test)] +mod tests { + use super::*; + + fn authority() -> TenantIdentityAuthority { + TenantIdentityAuthority::new([7; 32]).unwrap() + } + + fn claims() -> TenantIdentityClaims { + TenantIdentityClaims { + schema_version: CLAIMS_VERSION.into(), + tenant_id: "tenant-a".into(), + principal_id: "app-service-7".into(), + target_id: "db-target-1".into(), + database_kind: DatabaseKind::PostgreSql, + policy_id: "tenant-boundary".into(), + policy_revision: 9, + request_id: "550e8400-e29b-41d4-a716-446655440000".into(), + issued_at_unix: 1_900_000_000, + expires_at_unix: 1_900_000_030, + } + } + + fn expected() -> TenantIdentityExpectation<'static> { + TenantIdentityExpectation { + tenant_id: "tenant-a", + principal_id: "app-service-7", + target_id: "db-target-1", + database_kind: DatabaseKind::PostgreSql, + policy_id: "tenant-boundary", + policy_revision: 9, + } + } + + #[test] + fn identity_is_bound_to_principal_database_and_policy_revision() { + let authority = authority(); + let token = authority.sign(&claims(), 1_900_000_001).unwrap(); + let verified = authority.verify(&token, expected(), 1_900_000_002).unwrap(); + assert_eq!(verified.tenant_id(), "tenant-a"); + assert_eq!(verified.target_id(), "db-target-1"); + assert_eq!(verified.admission_expectation().policy_revision, 9); + + let wrong_target = TenantIdentityExpectation { target_id: "other-db", ..expected() }; + assert_eq!(authority.verify(&token, wrong_target, 1_900_000_002).unwrap_err().code, "identity_scope_mismatch"); + let wrong_kind = TenantIdentityExpectation { database_kind: DatabaseKind::MySql, ..expected() }; + assert_eq!(authority.verify(&token, wrong_kind, 1_900_000_002).unwrap_err().code, "identity_scope_mismatch"); + let wrong_policy = TenantIdentityExpectation { policy_revision: 10, ..expected() }; + assert_eq!(authority.verify(&token, wrong_policy, 1_900_000_002).unwrap_err().code, "identity_scope_mismatch"); + let wrong_principal = TenantIdentityExpectation { principal_id: "other-app", ..expected() }; + assert_eq!(authority.verify(&token, wrong_principal, 1_900_000_002).unwrap_err().code, "identity_scope_mismatch"); + } + + #[test] + fn tampering_and_expiry_are_rejected() { + let authority = authority(); + let token = authority.sign(&claims(), 1_900_000_001).unwrap(); + let mut parts = token.split('.').map(str::to_owned).collect::>(); + parts[1].push_str("00"); + assert_eq!( + authority.verify(&parts.join("."), expected(), 1_900_000_002).unwrap_err().code, + "identity_signature_invalid" + ); + assert_eq!(authority.verify(&token, expected(), 1_900_000_030).unwrap_err().code, "identity_expired"); + + let mut long_lived = claims(); + long_lived.expires_at_unix = long_lived.issued_at_unix + 61; + assert_eq!(authority.sign(&long_lived, 1_900_000_001).unwrap_err().code, "identity_claims_invalid"); + } +} diff --git a/docs/ARCHITECTURE.md b/docs/ARCHITECTURE.md index 8013430f..87e37d9a 100644 --- a/docs/ARCHITECTURE.md +++ b/docs/ARCHITECTURE.md @@ -1,8 +1,8 @@ # Proxima Engine architecture -Agata Proxima provides security infrastructure for multi-tenant PostgreSQL applications. Proxima Engine is its public Rust data plane: a PostgreSQL wire-protocol gateway that verifies signed tenant context and routes each accepted connection to a tenant-specific PostgreSQL role. +Agata Proxima is a database-independent tenant-security platform. Its Proxima Security Core defines the common policy and verification contract; database adapters implement native controls. Proxima Engine is the public Rust enforcement runtime. Its current runtime adapter speaks the PostgreSQL wire protocol, verifies signed tenant context and routes each accepted connection to a tenant-specific PostgreSQL role. Separate read-only native discovery adapters now inspect MySQL/MariaDB, SQL Server, MongoDB, Redis, CockroachDB, SQLite and Elasticsearch/OpenSearch catalogs and security metadata. These discovery adapters are in development and do not yet provide tenant-principal binding, controlled policy deployment, independent semantic verification or runtime admission. -Applications retain their existing PostgreSQL drivers. PostgreSQL remains the database and applies the grants and Row-Level Security (RLS) policies assigned to each tenant role. +Applications retain their existing PostgreSQL drivers for the current adapter. PostgreSQL applies the grants and Row-Level Security (RLS) policies assigned to each tenant role. This PostgreSQL-specific request path is an adapter implementation, not the definition of the entire Agata Proxima security model. ## Request path diff --git a/docs/CLI.md b/docs/CLI.md index b1432c60..325780fc 100644 --- a/docs/CLI.md +++ b/docs/CLI.md @@ -16,6 +16,47 @@ On Windows PowerShell, use the same commands with `python`. On Unix-like systems ## Commands +The Rust Policy Guard binary also exposes the adapter maturity catalog: + +```bash +cargo run -p proxima-engine --bin proxima-policy-guard -- adapters +``` + +The `adapters` command prints the versioned Proxima Security Core catalog. PostgreSQL, MySQL/MariaDB, Microsoft SQL Server, MongoDB, Redis, CockroachDB, SQLite and Elasticsearch/OpenSearch are marked `in_development` with only their implemented discovery/compiler capabilities. Oracle, DynamoDB, Cassandra and VAULTDB remain `planned`. An in-development entry is not a supported database integration. + +The PostgreSQL `discover-postgres` command enumerates non-system tables, partitioned tables, foreign tables, views, materialized views, sequences, functions and procedures. It captures ownership, columns/defaults, RLS flags, native policies, constraints, indexes, triggers, view definitions/options and routine security/execute ACL metadata. It requires the registered target ID/database name and a TLS-verified, read-only inspection role through `PROXIMA_POSTGRES_ADAPTER_DATABASE_URL`, `PROXIMA_POSTGRES_ADAPTER_TARGET_ID`, `PROXIMA_POSTGRES_ADAPTER_DATABASE_NAME` and `PROXIMA_TENANT_ROLE_PREFIX`. + +Run a full database discovery or scope it to one schema: + +```bash +cargo run -p proxima-engine --bin proxima-policy-guard -- discover-postgres +cargo run -p proxima-engine --bin proxima-policy-guard -- discover-postgres public +``` + +Discovery returns an inventory and fingerprint; it does not infer tenant keys, verify tenant isolation, or authorize traffic. + +The PostgreSQL `audit` command is a catalog posture inspection, not a semantic policy verifier. Its JSON deliberately reports `security_posture: unknown` and `access_decision: deny`, even when it finds no catalog findings. A zero exit code means the inspection completed without catalog findings; it does not certify tenant isolation. + + +Validate a database-neutral policy document against the shared contract without connecting to a database: + +```bash +cargo run -p proxima-engine --bin proxima-policy-guard -- validate-policy ./policy.json +``` + +The command checks the versioned envelope, explicit resources, tenant ownership keys and unique operations. It does not prove that any database adapter has enforced the policy. + +Generate reviewable PostgreSQL policy SQL from an explicit JSON specification: + +```bash +cargo run -p proxima-engine --bin proxima-policy-guard -- generate ./policy.json > policy.sql +``` + +Each tenant role must match one shared Engine prefix plus the normalized tenant ID. For example, `tenant-a` maps to `proxima_tenant_tenant_a` when `PROXIMA_TENANT_ROLE_PREFIX=proxima_tenant_`. The generated SQL prints the required prefix and performs transactional preflight checks; the CLI never connects to a database or executes the generated DDL. Review and apply it through a controlled migration workflow. + +Generation refuses partitioned relations, unsafe dependent views, materialized views without separate protection, tenant roles with database/schema `CREATE` privileges, and unsafe role defaults. These restrictions are deliberate until the PostgreSQL adapter implements and verifies those paths. + + | Command | Purpose | |---|---| | `init` | Generate local node identity and tenant-signing credentials in `.proxima-dev/` | @@ -49,3 +90,165 @@ python -m unittest discover -s tests_cli -v ``` For the full Rust and PostgreSQL verification path, see [Verification](VERIFICATION.md). + +## Review-only multi-database policy plans + +The `compile-plan` command generates a JSON policy plan for the current early non-PostgreSQL compilers. It does not connect to a database or apply changes. + +```bash +proxima-policy-guard compile-plan sql_server policy.json +proxima-policy-guard compile-plan mysql policy.json +proxima-policy-guard compile-plan mariadb policy.json +proxima-policy-guard compile-plan mongodb policy.json +proxima-policy-guard compile-plan redis policy.json +``` + +Redirect output to a file for review, for example `proxima-policy-guard compile-plan sql_server policy.json > sql-server-plan.json`. SQL Server plans contain a `` placeholder that must be resolved by a future live catalog inspector; do not execute the plan as-is. MySQL/MariaDB and MongoDB templates require one database per tenant. Redis requires a keyspace resource whose `tenant_key` uses a strict tenant-specific pattern such as `tenant:${tenant_id}:*`. These policy-generation templates are review-only. MySQL/MariaDB, MongoDB and Redis also have live native discovery/inspection paths, but none of these adapters currently deploy policies, execute independent semantic probes or provide production runtime admission. + + +## Native MySQL/MariaDB adapter + +The Rust adapter exposes read-only MySQL-protocol discovery and catalog inspection for a registered database target. It requires a `mysql://` connection URL whose server certificate and hostname can be verified; TLS identity verification is mandatory. The adapter reads `information_schema` tables, columns, routines, table privileges and schema privileges, and computes a catalog fingerprint for drift comparison. It deliberately reports catalog visibility as incomplete because MySQL/MariaDB metadata visibility is privilege-filtered. + +The adapter can be constructed by an Engine integration with `MySqlCatalogAdapter::new(target_id, database_name, connection_url, DatabaseKind::MySql)` or `DatabaseKind::MariaDb`. It captures table/view columns, constraints, indexes, triggers, view definitions/security mode, routine metadata and routine privileges, as well as authenticated-account grants. It does not apply DDL, create users, switch roles, or authorize traffic. Its existing database-per-tenant plan compiler remains review-only until a trusted protocol gateway binds tenant identity to isolated database principals and independent positive/negative probes prove the boundary. + +Use the native discovery commands with the same registered-target variables for either database family: + +```bash +PROXIMA_MYSQL_ADAPTER_DATABASE_URL='mysql://...' \ +PROXIMA_MYSQL_ADAPTER_TARGET_ID='registered-target-id' \ +PROXIMA_MYSQL_ADAPTER_DATABASE_NAME='application_db' \ +cargo run -p proxima-engine --bin proxima-policy-guard -- discover-mysql + +PROXIMA_MYSQL_ADAPTER_DATABASE_URL='mysql://...' \ +PROXIMA_MYSQL_ADAPTER_TARGET_ID='registered-target-id' \ +PROXIMA_MYSQL_ADAPTER_DATABASE_NAME='application_db' \ +cargo run -p proxima-engine --bin proxima-policy-guard -- discover-mariadb +``` + +For policy inspection, use `inspect-mysql-policy policy.json` or `inspect-mariadb-policy policy.json`. These commands always retain a deny decision because the adapter has no trusted tenant-to-database runtime principal binding and cannot prove document/row isolation from metadata alone. Keep the connection URL in a protected environment variable; do not place credentials in source control or command history. + + +## Native MongoDB adapter + +The Engine crate exposes `MongoCatalogAdapter` for a registered MongoDB database. Its URI must explicitly enable TLS or use `mongodb+srv://`; insecure certificate/hostname options and explicit TLS disablement are rejected. Discovery records visible collections/views, collection validators/options, view definitions and the authenticated account's effective privileges from `connectionStatus`. The inventory is marked incomplete because MongoDB metadata visibility is privilege-scoped. + +The adapter checks whether a collection validator declares and requires the configured tenant ownership field, but this is not a substitute for enforcing document-level authorization. MongoDB database roles do not automatically filter documents by tenant. Independent authenticated tenant probes and a trusted runtime enforcement boundary remain mandatory before admission. + +Use the Policy Guard commands to inventory a registered database or inspect a policy: + +```bash +PROXIMA_MONGODB_ADAPTER_URI='mongodb+srv://...' \ +PROXIMA_MONGODB_ADAPTER_TARGET_ID='registered-target-id' \ +PROXIMA_MONGODB_ADAPTER_DATABASE_NAME='application_db' \ +cargo run -p proxima-engine --bin proxima-policy-guard -- discover-mongodb + +PROXIMA_MONGODB_ADAPTER_URI='mongodb+srv://...' \ +PROXIMA_MONGODB_ADAPTER_TARGET_ID='registered-target-id' \ +PROXIMA_MONGODB_ADAPTER_DATABASE_NAME='application_db' \ +cargo run -p proxima-engine --bin proxima-policy-guard -- inspect-mongodb-policy policy.json +``` + +Both commands return a deny decision until a native document-level enforcement boundary and independent positive/negative tenant probes exist. The URI must not disable TLS or certificate/hostname verification; keep credentials in a protected environment variable. + + +## Native Redis ACL adapter + +The Rust adapter requires a rediss:// URI and a registered logical database index. It rejects URL fragments, including redis-rs's #insecure fragment that disables TLS certificate verification. It connects with TLS, confirms the selected database using CLIENT INFO, reads the authenticated ACL user, ACL user rules, read-only/write-only/read-write key patterns, command rules, ACL categories, server version and keyspace statistics, and fingerprints the observed ACL state. Policy inspection checks required explicit commands and key-pattern modes, flags broad categories and wildcard access, and still requires independent data-plane probes. Credential hashes and plaintext-style ACL password tokens are redacted from the returned inventory; the raw ACL rules are hashed for drift detection. + +```bash +PROXIMA_REDIS_ADAPTER_URI='rediss://...' \\ +PROXIMA_REDIS_ADAPTER_TARGET_ID='registered-target-id' \\ +PROXIMA_REDIS_ADAPTER_DATABASE_INDEX='0' \\ +cargo run -p proxima-engine --bin proxima-policy-guard -- discover-redis + +PROXIMA_REDIS_ADAPTER_URI='rediss://...' \\ +PROXIMA_REDIS_ADAPTER_TARGET_ID='registered-target-id' \\ +PROXIMA_REDIS_ADAPTER_DATABASE_INDEX='0' \\ +cargo run -p proxima-engine --bin proxima-policy-guard -- inspect-redis-policy policy.json +``` + +The inspection principal needs permission to run CLIENT INFO, PING, ACL WHOAMI, ACL LIST, ACL CAT, and INFO. The result remains incomplete and denied: ACL key patterns do not prove that application code consistently uses tenant keys, and keyless commands, scripts, functions and modules need a trusted enforcement layer and adversarial probes. Keep the Redis URI and credentials in a protected environment variable. + + +## Native Microsoft SQL Server adapter + +The SQL Server adapter uses encrypted TDS with certificate verification and SQL username/password authentication. Supply a direct hostname and TCP port; SQL Browser/named-instance discovery and integrated Windows/Kerberos authentication are not enabled. This build rejects integrated Windows/Kerberos authentication, TrustServerCertificate=true and Encrypt=false. It confirms the connected database, and inventories tables/columns, object and column permissions, schema/database permissions, principals, role memberships, RLS security policies/predicates, triggers, views and stored routines. It marks catalog visibility incomplete unless the inspection identity has database VIEW DEFINITION or sysadmin visibility; sysadmin inspection is explicitly flagged. + +```powershell +$env:PROXIMA_SQL_SERVER_ADAPTER_CONNECTION_STRING = 'Server=db.example,1433;Database=app;User Id=...;Password=...;Encrypt=True;TrustServerCertificate=False' +$env:PROXIMA_SQL_SERVER_ADAPTER_TARGET_ID = 'registered-target-id' +$env:PROXIMA_SQL_SERVER_ADAPTER_DATABASE_NAME = 'app' +cargo run -p proxima-engine --bin proxima-policy-guard -- discover-sql-server +cargo run -p proxima-engine --bin proxima-policy-guard -- inspect-sql-server-policy policy.json +``` + +Inspection checks tenant columns and nullability, enabled FILTER/BLOCK predicates for the declared operations, and the referenced predicate-function definition for SESSION_CONTEXT and schema binding. It still denies admission: a database client can set SESSION_CONTEXT unless a trusted application/gateway boundary prevents it, and independent positive/negative tenant probes are required. Keep the connection string in a protected environment variable. + +## Native CockroachDB catalog discovery + +CockroachDB discovery uses the PostgreSQL wire protocol with TLS certificate verification, but a separate CockroachDB adapter and explicit server-identity check. It inventories non-system tables and views, columns, and table grants from the target database. The inventory is bounded to 10,000 relations and is always marked incomplete because database/schema ACLs, role memberships, ownership and effective inherited privileges are not yet inventoried. It fingerprints the visible catalog for drift comparison. + +The adapter does not assume PostgreSQL row-level security semantics and does not generate or deploy policies. Its descriptor exposes schema inspection and drift detection only; verification always denies until CockroachDB-specific tenant authorization, trusted identity binding and independent cross-tenant probes exist. + +```bash +PROXIMA_COCKROACH_ADAPTER_DATABASE_URL='postgresql://...' \ +PROXIMA_COCKROACH_ADAPTER_TARGET_ID='registered-target-id' \ +PROXIMA_COCKROACH_ADAPTER_DATABASE_NAME='application_db' \ +cargo run -p proxima-engine --bin proxima-policy-guard -- discover-cockroachdb + +# Optional schema-scoped inventory +cargo run -p proxima-engine --bin proxima-policy-guard -- discover-cockroachdb public + +# Inspect a canonical policy; verification remains blocked until native enforcement exists +PROXIMA_COCKROACH_ADAPTER_DATABASE_URL='postgresql://...' \ +PROXIMA_COCKROACH_ADAPTER_TARGET_ID='registered-target-id' \ +PROXIMA_COCKROACH_ADAPTER_DATABASE_NAME='application_db' \ +cargo run -p proxima-engine --bin proxima-policy-guard -- inspect-cockroach-policy policy.json +``` + +The connector uses the same verified root-store configuration as PostgreSQL discovery. Credentials must remain in a protected environment variable; discovery is read-only and does not authorize application traffic. + + +## Native SQLite file-isolation discovery + +The SQLite adapter opens a persistent database file read-only, disables trusted schema execution for the inspection connection, rejects attached databases and verifies that the connected main database resolves to the registered absolute file path. It inventories tables/views, columns, indexes and indexed columns, foreign keys, triggers, schema definitions, journal mode and filesystem permissions for the database file, containing directory and any WAL/SHM sidecars. + +SQLite has no native database users or row-level security. The adapter therefore does not generate SQL tenant policies or claim that a tenant key column provides isolation. A real tenant boundary requires a trusted file-per-tenant selector, exclusive OS-level file and directory permissions, and independent cross-tenant file-access probes. Windows ACL inspection is not yet implemented, so Windows discovery remains denied. + +```bash +PROXIMA_SQLITE_ADAPTER_DATABASE_PATH='/absolute/path/to/tenant.db' \ +PROXIMA_SQLITE_ADAPTER_DATABASE_URI='sqlite:///absolute/path/to/tenant.db' \ +PROXIMA_SQLITE_ADAPTER_TARGET_ID='registered-target-id' \ +cargo run -p proxima-engine --bin proxima-policy-guard -- discover-sqlite + +PROXIMA_SQLITE_ADAPTER_DATABASE_PATH='/absolute/path/to/tenant.db' \ +PROXIMA_SQLITE_ADAPTER_DATABASE_URI='sqlite:///absolute/path/to/tenant.db' \ +PROXIMA_SQLITE_ADAPTER_TARGET_ID='registered-target-id' \ +cargo run -p proxima-engine --bin proxima-policy-guard -- inspect-sqlite-policy policy.json +``` + +The inspection URI must point to the same file as the absolute registered path. Both commands are read-only; policy inspection returns deny because native tenant authorization and file-selection enforcement are not implemented. + + +## Native Elasticsearch / OpenSearch discovery + +The search-cluster adapter requires HTTPS and an explicit Authorization value supplied separately from the endpoint URL. It disables redirects, applies connection/request deadlines, confirms the root cluster identity, inventories indices matching the registered pattern, and retrieves mappings, settings and aliases. It also reads the authenticated identity and Elasticsearch security roles/users or OpenSearch Security plugin roles, role mappings and internal users when the inspection principal has permission. Policy inspection checks DLS coverage only against roles assigned to the authenticated principal; it does not infer safety from an unrelated tenant role. Discovery remains incomplete because cluster-wide index and security-catalog visibility cannot yet be independently attested. User password/hash/token fields are stripped before evidence serialization. + +The adapter is discovery-only. A tenant field in an index mapping does not isolate documents. Native DLS/FLS role definitions, authenticated tenant-principal binding, policy deployment and independent positive/negative document probes are still required. + +```bash +PROXIMA_ELASTICSEARCH_ADAPTER_ENDPOINT='https://search.example.com:9200' \ +PROXIMA_ELASTICSEARCH_ADAPTER_INDEX_PATTERN='tenant-*' \ +PROXIMA_ELASTICSEARCH_ADAPTER_TARGET_ID='registered-target-id' \ +PROXIMA_ELASTICSEARCH_ADAPTER_AUTHORIZATION='ApiKey ...' \ +cargo run -p proxima-engine --bin proxima-policy-guard -- discover-elasticsearch + +PROXIMA_ELASTICSEARCH_ADAPTER_ENDPOINT='https://search.example.com:9200' \ +PROXIMA_ELASTICSEARCH_ADAPTER_INDEX_PATTERN='tenant-*' \ +PROXIMA_ELASTICSEARCH_ADAPTER_TARGET_ID='registered-target-id' \ +PROXIMA_ELASTICSEARCH_ADAPTER_AUTHORIZATION='ApiKey ...' \ +cargo run -p proxima-engine --bin proxima-policy-guard -- inspect-elasticsearch-policy policy.json +``` + +Do not put API keys, bearer tokens or Basic credentials in the endpoint URL, source control or command history. Use a protected environment/secret manager. If the security catalog endpoints return 401/403/404, discovery reports the security inventory as incomplete and policy inspection remains denied. diff --git a/docs/IMPLEMENTATION_AUDIT_2026-11-17.md b/docs/IMPLEMENTATION_AUDIT_2026-11-17.md new file mode 100644 index 00000000..c0477b5d --- /dev/null +++ b/docs/IMPLEMENTATION_AUDIT_2026-11-17.md @@ -0,0 +1,173 @@ +# Proxima Security Core implementation audit — 17 November 2026 + +This is an implementation-state audit, not a security certification. It records what is present in the current development branches and what is still required before production support or merge. + +## 1. Multi-database coverage + +| Database | Current implementation | Runtime support | +|---|---|---| +| PostgreSQL | Existing signed tenant-token verification, PostgreSQL role binding, Policy Guard CLI, Cloud inventory/registration/reviewed RLS deployment and drift workflow | Existing PostgreSQL path only; full semantic verification and admission gating remain incomplete | +| SQL Server | Review-only native RLS filter/block predicate plan compiler; exact tenant-column type remains a live-catalog placeholder | Not implemented | +| MySQL | Review-only database-per-tenant user/grant SQL template | Not implemented; no native row-level security; shared-table tenant isolation is not provided | +| MariaDB | Review-only database-per-tenant user/grant SQL template | Not implemented; no native row-level security; shared-table tenant isolation is not provided | +| MongoDB | Review-only database-per-tenant custom collection-role template | Not implemented; shared-collection document-level isolation is not provided | +| Redis | Review-only tenant key-pattern ACL template with baseline core-command allowlist | Not implemented; trusted ACL principal selection, live ACL inspection and runtime enforcement are absent | +| CockroachDB, SQLite, Oracle, DynamoDB, Cassandra, Elasticsearch/OpenSearch, VAULTDB | Cataloged as planned | Not implemented | + +The CLI command `proxima-policy-guard compile-plan` emits reviewable JSON policy plans for SQL Server, MySQL, MariaDB, MongoDB and Redis. It does not connect to customer databases or execute changes. The catalog exposes only `policy_generation` for those five in-development compilers; no inspection, enforcement, deployment, verification, drift, runtime admission or signed-evidence capability is enabled for them. + +## 2. Runtime admission + +The common `VerificationReport` decision rule fails closed unless the model version is known, inspection is complete, posture is verified and findings are empty. The new `PolicyEvidenceAuthority` can issue and verify a short-lived admission envelope bound to the policy revision, database target, tenant, signed evidence digest and a maximum 60-second lifetime. + +The admission envelope is not yet called by the PostgreSQL connection-startup path. It does not yet have per-connection challenge/replay protection. Other database protocol listeners do not exist. Therefore runtime admission tied to a verified policy posture is not complete. + +## 3. Signed evidence + +The Engine library can HMAC-sign policy evidence containing model version, policy revision, database kind, target, tenant, posture, inspection completeness, findings, verified operations, fingerprint, timestamp and positive/negative checks. The admission envelope references the exact signed evidence digest. + +This is not yet integrated into the existing node-attestation ledger, the hosted Cloud evidence-ingestion API, or persistent evidence storage. Signing keys are library inputs; production secret loading, rotation, key identifiers and operational recovery are still required. + +## 4. Verification and adversarial acceptance + +Regression tests have been added for policy-plan generation, SQL Server predicate generation, database-per-tenant limitations, Redis key-pattern constraints, evidence tampering, policy/target/tenant binding, stale evidence, expiry and incomplete verification. + +No Rust build, Rust test suite, frontend build, live database integration test, protocol test, supply-chain verification or GitHub Actions run was performed in this authoring session. CI was intentionally not triggered. New adapters have not passed independent adversarial acceptance. + +## Merge gate + +Do not mark the five new database families as supported, do not advertise runtime multi-database enforcement, and do not merge these drafts into `main` until: +- adapter-specific database drivers/listeners and secure TLS connections exist; +- native catalog and privilege inspection is complete; +- exact policy deployment, rollback and drift response are implemented; +- semantic positive and negative isolation tests pass on supported versions/topologies; +- policy evidence is ingested and persisted by Cloud; +- the connection runtime verifies fresh admission envelopes with replay/connection binding; +- owner-run local acceptance and independent adversarial review pass. + +The current result is a wider Agata-owned security architecture and five policy-plan compilers—not a completed all-database production security platform. +## 5. Production maturity gate added after this audit + +The adapter registry now refuses registration unless an adapter explicitly declares supported maturity and all eight end-to-end capability flags are true: schema inspection, tenant identity enforcement, semantic verification, policy generation, controlled deployment, drift detection, fail-closed runtime admission and signed evidence. The shared capability model exposes the same completeness predicate. Regression tests cover rejection of review-only/partial adapters and acceptance of a complete descriptor. + +This is a guard against accidentally advertising or loading an incomplete adapter. It does not implement the missing database drivers, native inspection, deployment, protocol listeners or acceptance tests, and it does not change the maturity of any database in the catalog. + +## Follow-on Security Core coordinator work + +The Engine branch now includes `security_core_coordinator.rs`, which centralizes adapter-backed policy compilation, native inspection/semantic verification, and drift validation. Compilation rejects unapproved plans, mismatched policy identity/revision/database kind, missing or duplicate protected-resource coverage, altered tenant ownership keys, and incomplete operation coverage. Inspection rejects target/database identity mismatches, missing or malformed SHA-256 fingerprints, incomplete native posture, missing protected resources, ownership-key mismatches, and unverified operations. Drift reports must match the requested target and prior baseline, contain a complete inspection and valid observed fingerprint, and report a drift state consistent with the fingerprint comparison. A first baseline cannot claim drift without a prior trusted fingerprint. + +These coordinator paths are orchestration contracts and test-fixture coverage, not a live database adapter. The registry remains empty in production; no database is promoted to `supported`. PostgreSQL native inspection, deployment integration, semantic adversarial verification, durable Cloud evidence ingestion, and protocol-startup admission wiring remain outstanding. No build, unit test, integration test, or CI run has been performed for these follow-on changes. + + +## 6. Current cross-component boundary — 17 November 2026 + +The PostgreSQL listener's active admission path consumes the Cloud node-key-signed policy-status response and its per-registration evidence object. The generic Engine `PolicyEvidenceAuthority` format remains a separate library primitive; it is not silently treated as the hosted wire protocol. The PostgreSQL catalog adapter intentionally returns a deny posture until authenticated positive and cross-tenant negative probes exist. The Cloud policy lifecycle currently verifies catalog/revision/role-binding posture, not those independent data-plane probes. + +The Cloud registration validator additionally rejects distinct tenant IDs that normalize to one PostgreSQL role and rejects derived role names exceeding PostgreSQL's 63-byte identifier limit. Regression tests were added. The Cloud tenant-role migration was repaired to remove malformed duplicated legacy-collision SQL and now quarantines ambiguous mappings, records drift, and preserves fail-closed behavior. + +No Rust/frontend builds, tests, migration execution, live PostgreSQL acceptance, or GitHub Actions were run. These changes are committed to the development branches but remain uncompiled and unvalidated. PostgreSQL remains in development; the five compiler-only databases and all other planned targets remain unsupported. + + +## 7. PostgreSQL drift fingerprint expansion — 17 November 2026 + +The concrete Engine PostgreSQL catalog adapter now includes additional native security and schema metadata in its drift fingerprint: database-wide role attributes and validity, database-scoped persistent role settings, role memberships and admin-option state, database and schema ACLs/ownership, default privileges, relation ownership/ACL/RLS/policy definitions, columns and defaults, constraints and validation state, indexes and validity/readiness, non-internal triggers and enabled state, view/materialized-view definitions/options/ACLs, and application routine ownership, SECURITY DEFINER state, settings, arguments, definitions and execute ACLs. Sequence ownership and ACLs are also included. + +This closes a material blind spot in the earlier relation-only fingerprint: role grants, inherited membership, persistent settings, routine changes, and schema-object changes can alter effective authorization without changing a table's own RLS policy or ACL. The fingerprint is still a drift signal, not semantic proof. It does not promote PostgreSQL to supported, and independent authenticated positive/negative tenant probes, controlled deployment and full local acceptance remain required. + +The SQL changes have been committed but were not compiled or executed against PostgreSQL in this session. Validate catalog-query permissions and compatibility against the supported PostgreSQL major versions before accepting the adapter. + + +## 8. Policy-plan hardening — 17 November 2026 + +The MySQL/MariaDB database-per-tenant grant template now requires a trusted application-host placeholder for both account creation and grants instead of creating a principal reachable from the unrestricted wildcard host. Deployment must bind that placeholder to a narrowly scoped trusted egress identity. + +The Redis ACL compiler now derives a narrower command allowlist from the requested read/create/update/delete operations rather than granting the same broad mutating command set for every write operation. Regression tests cover delete-only and create-only plans. The generated plan also explicitly states that Redis ACL command permissions cannot distinguish create-only from update-only behavior for upsert commands; that semantic distinction requires an enforcing gateway or application contract and is not claimed as a Redis-native capability. + +These are policy-plan safety improvements only. They do not add native MySQL/MariaDB/Redis connections, catalog inspection, deployment, semantic verification, runtime enforcement or drift monitoring. The tests were authored but not executed in this session. + + +## 9. Signed evidence admission coverage hardening — 17 November 2026 + +The generic Engine evidence authority now refuses admission unless every declared operation has both a passing own_tenant_allow: check and a passing cross_tenant_deny: check. Duplicate check identifiers and duplicate verified operations are rejected, and check identifiers/details are bounded. This prevents a signed payload with one arbitrary passing check from being treated as complete tenant-isolation proof. + +The evidence fixture tests now model positive and negative coverage for read, create, update and delete. Regression tests cover missing per-operation negative probes, duplicate check identifiers and duplicate operation declarations. These checks validate the evidence contract; they do not themselves execute database probes. A trusted native verifier must still perform the operations and sign the resulting evidence. Tests were authored but not executed. + +The signed evidence payload validator also bounds policy/target/tenant identifiers, finding/check counts, finding and check text, resource identifiers and operation counts, and rejects NUL-bearing values. Regression coverage includes oversized tenant identifiers and finding details. + +The read-only PostgreSQL inspection path also checks that each policy-declared tenant ownership column exists on the registered relation and is NOT NULL; missing or nullable tenant keys become explicit findings rather than being inferred from RLS policy presence. + +PostgreSQL resource inspection also checks dependent view chains for non-security-invoker views and materialized views, and flags application SECURITY DEFINER routines for explicit review. These are conservative findings; their presence does not automatically prove exploitability, but they prevent a clean isolation posture from being inferred without reviewing those alternate access paths. + + +## 10. Native PostgreSQL resource discovery — 17 November 2026 + +The database-neutral adapter contract now exposes `discover` independently of policy inspection, with typed resource inventory, adapter target, completeness, findings, fingerprint and observation time. The PostgreSQL adapter implements read-only discovery of tables, partitioned/foreign tables, views, materialized views, sequences, functions and procedures. It records owners, relation ACL/RLS state, columns/defaults, native policy expressions/roles, constraints, indexes, non-internal triggers, view definitions/options, and routine SECURITY DEFINER/execute ACL metadata. The Policy Guard CLI exposes `discover-postgres [schema]` and always labels the result as inventory only with an explicit deny decision. + +Discovery tests cover invalid namespace and target mismatch without opening a database connection. Live catalog discovery and supported-version compatibility remain unexecuted in this session. + + +## 11. Native MySQL/MariaDB catalog adapter — 17 November 2026 + +Added a TLS identity-verifying MySQL protocol adapter shared by MySQL and MariaDB. It discovers tables/views and routines, column definitions/defaults/nullability, table/schema grants, constraints and foreign-key references, indexes, triggers and definers, view definitions/check options/security mode, and routine grants; authenticated-account grants are included in target metadata. The Policy Guard exposes `discover-mysql`, `discover-mariadb`, `inspect-mysql-policy` and `inspect-mariadb-policy` commands. Policy inspection checks registered resource presence and tenant-key existence/nullability, while explicitly flagging that native row-level security is unavailable and database-per-tenant grants require independent principal probes. Drift comparison uses discovery fingerprints. The adapter remains in development and does not claim runtime tenant enforcement, semantic verification, controlled deployment or signed admission. Metadata visibility is marked incomplete because information_schema results are privilege-filtered. + +Regression tests cover database-kind validation, target bounds and capability maturity. Tests and live TLS/catalog compatibility checks were authored but not executed in this session. + + +## 12. Native MongoDB discovery and posture adapter — 17 November 2026 + +Added a MongoDB Rust-driver adapter requiring verified TLS and rejecting insecure TLS URI options. It connects to the registered database, obtains authenticated effective privilege information, enumerates visible collections and views, captures collection options/validators and view metadata, and fingerprints the inventory. Policy inspection checks tenant ownership validator declarations and required fields, but explicitly records that MongoDB database-level roles do not provide document-level tenant filtering. Discovery is marked incomplete where authenticated visibility is privilege-scoped; verification always denies pending independent positive/negative document probes and runtime principal binding. The adapter remains in development. + +The adapter now applies bounded server-selection and connect deadlines, and policy inspection checks that tenant ownership has an explicit BSON type, is required, and is protected by strict validation with error action. The Policy Guard exposes `discover-mongodb` and `inspect-mongodb-policy` using explicit target/URI environment variables; both retain deny semantics. Regression tests cover TLS URI enforcement and capability maturity. Driver API compatibility, live MongoDB catalog permissions and tests were not executed in this session. + + +## 13. Native Redis ACL discovery adapter — 17 November 2026 + +Added a TLS-only Redis adapter that confirms the selected logical database, reads the authenticated ACL user, ACL user definitions, key patterns, command rules, channels, ACL categories, server version and keyspace statistics, and fingerprints raw ACL state while redacting credential hashes/password tokens from the returned inventory. Discovery flags unrestricted key patterns and remains incomplete because ACL inventory does not enumerate all keys or prove application-level tenant binding. The Policy Guard exposes `discover-redis` and `inspect-redis-policy`; both retain deny semantics. Tests cover TLS URI requirements, ACL credential redaction and target/database mismatch. Runtime protocol mediation, controlled ACL deployment, independent semantic probes, module/script/function coverage and signed admission remain unimplemented. No build, test, or live Redis validation was performed. + +Redis inspection now distinguishes read-only, write-only and read/write ACL key patterns, checks that one tenant ACL principal covers the required key scopes, compares explicit command allowlists against the canonical operation set, and flags broad command categories or unrestricted key patterns. Redis `execute` operations are rejected by the compiler and inspector rather than silently omitted. + + +## 14. Native SQL Server catalog and RLS inspection adapter — 17 November 2026 + +Added a Tiberius encrypted-TDS adapter that rejects disabled encryption and TrustServerCertificate bypass, confirms the registered database, and discovers tables/columns, indexes, partition schemes/functions/range boundaries, foreign/check/default constraints, object and column grants, schema/database permissions, principals, role membership, database TRUSTWORTHY/cross-database chaining options, RLS policies/predicates, triggers, views and routines. Discovery fingerprints the visible catalog and marks completeness according to database VIEW DEFINITION/sysadmin visibility, flagging sysadmin inspection identities. Policy inspection checks tenant-column existence/nullability, enabled FILTER predicates, AFTER INSERT, BEFORE/AFTER UPDATE and BEFORE DELETE block predicates, and follows the predicate function definition to check SESSION_CONTEXT use and schema binding. The Policy Guard exposes `discover-sql-server` and `inspect-sql-server-policy`; inventory output is bounded to 10,000 tables, views and routines, with truncation explicitly marked incomplete. Runtime SESSION_CONTEXT trust, controlled policy deployment/rollback, independent semantic probes and signed admission remain outstanding. Tiberius API compatibility, TLS chain behavior, SQL Server version compatibility and live catalog tests were not executed. + +The PostgreSQL discovery snapshot now also includes database/schema ACLs and ownership, default privileges, role attributes and role memberships, and full application routine definitions alongside relation metadata. The adapter descriptor now advertises its implemented fingerprint drift comparison. + +MongoDB discovery now includes collection index definitions in addition to validators, view pipelines, collection options and effective connection privileges; inventory is bounded to 10,000 collections, 10,000 indexes per collection and 100,000 indexes total, with cursor pagination and explicit truncation findings. It flags broad inspection roles/any-resource privileges and uses bounded connect and server-selection timeouts. + +PostgreSQL discovery and policy inspection now include declarative partition parent/child relationships, partition keys and bounds, and each child partition's RLS state, FORCE RLS state and local policy expressions. Inspection flags directly addressable partitions without RLS, without local policies, with RLS not forced, or whose local policy expressions do not visibly reference the registered tenant key. + +SQL Server discovery also fingerprints partition schemes/functions/range boundaries, and inspection flags RLS predicate functions or table triggers that execute under an explicit EXECUTE AS principal. + +MongoDB tenant-field validation now also rejects validators whose BSON type constraint explicitly permits null, rather than treating a merely present bsonType declaration as sufficient. + +## CockroachDB discovery adapter added after the initial audit + +- Added a separate CockroachDB adapter over the PostgreSQL wire protocol with an injected connector, read-only session settings, server identity validation, database-target binding, bounded discovery, native `information_schema` table/view/column/table-grant inventory, deterministic catalog fingerprinting and drift comparison. +- The adapter is deliberately marked `in_development` and exposes only schema inspection and drift detection. It does not reuse PostgreSQL RLS assumptions, compile or deploy policy, claim tenant enforcement, or return a verified posture. +- CockroachDB native authorization, authenticated tenant binding, independent positive/negative probes, controlled policy deployment, signed evidence and runtime admission remain unimplemented. The module has authored unit tests only; no Rust build, tests or live CockroachDB validation were run. + +## Native adapter inspection-session hardening + +- PostgreSQL inspection now evaluates the connected role and its reachable role memberships for SUPERUSER, BYPASSRLS, CREATEROLE, CREATEDB and REPLICATION attributes before catalog access. +- MySQL/MariaDB inspection now sets subsequent transactions read-only and requires the vendor-specific SELECT statement deadline to be accepted; it no longer silently ignores unsupported timeout settings. +- SQL Server inspection now rejects sysadmin, database owner/DDL/security/access administration, db_datawriter, and effective database/object mutation privileges before inventory queries. +- MongoDB catalog discovery now has bounded server-selection, connection and whole-operation deadlines; the driver does not expose a configurable per-socket timeout in this version. +- MySQL/MariaDB, MongoDB, Redis, SQL Server and CockroachDB discovery/inspection/drift inventory operations have a bounded sixty-second operation deadline. PostgreSQL retains server-side statement and lock deadlines. +- These are code changes and regression coverage where present, not executed validation. No Rust build, unit test suite, live database test or migration execution has been run. + + +## SQLite file-isolation discovery adapter added after the initial audit + +- Added a SQLx SQLite read-only adapter that refuses in-memory databases and attached databases, validates the connected main file against a registered absolute path, disables trusted schema execution, and applies bounded busy/operation deadlines. +- Discovery inventories tables/views, columns, indexes and index columns, foreign keys, triggers, schema definitions, journal mode, file/directory permissions and WAL/SHM sidecar permission bits where visible. +- The adapter is marked `in_development` with schema-inspection and drift-detection capabilities only. SQLite has no native per-tenant users or RLS; policy compilation and semantic verification are explicitly denied. +- File-per-tenant selection, complete cross-platform OS ACL verification (including Windows), independent cross-tenant file-access probes, runtime admission and signed evidence remain unimplemented. No Rust build, tests or live SQLite acceptance were run. + + +## Elasticsearch / OpenSearch discovery adapter added after the initial audit + +- Added a verified-HTTPS adapter with redirect suppression, bounded requests, registered index-pattern scoping, cluster identity inspection, index mapping/settings/alias inventory, and Elasticsearch or OpenSearch native security-role/user catalog retrieval where authorized. +- User catalog password/hash/token fields are removed before serialization. Missing security API visibility is represented as incomplete discovery rather than a clean security state. +- The adapter is marked `in_development` and exposes schema inspection and drift detection only. DLS/FLS enforcement, tenant-principal binding, policy compilation/deployment, independent document probes, runtime admission and signed evidence remain unimplemented. +- Authored tests cover endpoint TLS requirements, glob matching, nested field mapping lookup and credential redaction. No build, tests or live cluster acceptance were run. diff --git a/docs/IMPLEMENTATION_STATUS_2026-11-17.md b/docs/IMPLEMENTATION_STATUS_2026-11-17.md new file mode 100644 index 00000000..53f1191f --- /dev/null +++ b/docs/IMPLEMENTATION_STATUS_2026-11-17.md @@ -0,0 +1,25 @@ +# Implementation status — 17 November 2026 + +## Changes made + +These changes are on the existing draft PR branches; no PR was merged. + +- In `crates/proxima-engine/src/main.rs`, tenant policy admission now defaults to required when `PROXIMA_POLICY_ADMISSION_REQUIRED` is unset. Invalid values fail startup. Explicit opt-out is accepted only in debug builds; release builds reject it. +- The same runtime admission default and release-build requirement were applied to the embedded Engine in the Agata Proxima control-plane branch. +- In `crates/proxima-engine/src/connection_admission.rs`, the test evidence fixture now supplies `mutation_rollback:create`, `mutation_rollback:update`, and `mutation_rollback:delete` checks. The evidence authority already requires these checks for mutating operations. + +## Validation and review state + +- The source files were fetched from the current branch heads before each update, and GitHub accepted the updates. +- Rust tests/builds, database integration tests, and GitHub Actions were not run in this session. The evidence-fixture change addresses a mismatch identified by source inspection; it is not represented as a passing test run. +- Engine PR #30 remains open and draft. Control-plane PR #219 remains open and draft. Neither was merged. + +## Remaining work + +This is a bounded enforcement improvement, not completion of the multi-database platform. + +- PostgreSQL still lacks independent positive and cross-tenant negative data-plane probes that produce trusted per-operation evidence. +- MySQL/MariaDB, SQL Server, MongoDB, Redis, CockroachDB, SQLite, Elasticsearch/OpenSearch, and Oracle do not have complete production adapters. Existing discovery paths and review-only policy compilers do not provide controlled deployment/rollback, trusted tenant identity binding, semantic authorization probes, runtime admission, and signed data-plane evidence as one verified lifecycle. +- Policy deployment approval/rollback orchestration, adapter-specific live drift response, multi-protocol runtime enforcement, and adversarial acceptance remain outstanding. + +The adapter registry continues to keep incomplete adapters out of production registration. Keep both PRs in draft until local builds, tests, and database-specific adversarial acceptance pass. diff --git a/docs/INTEGRATIONS.md b/docs/INTEGRATIONS.md index 35fdede9..43294f84 100644 --- a/docs/INTEGRATIONS.md +++ b/docs/INTEGRATIONS.md @@ -26,7 +26,7 @@ psql "host=127.0.0.1 port=6432 dbname=appdb user=proxima sslmode=disable" \ -c "SELECT current_user, current_database();" ``` -The client username is the proxy login name. The Engine derives the upstream PostgreSQL username from the signed tenant ID. The supplied password must authenticate as that tenant's upstream database role. +The client username is the proxy login name. The Engine derives the upstream PostgreSQL username from the signed tenant ID using one global `PROXIMA_TENANT_ROLE_PREFIX` (default `proxima_tenant_`) plus the tenant ID with hyphens normalized to underscores. The supplied password must authenticate as that tenant's upstream database role. Cloud policy registration enforces the same prefix and returns the required value; configure the Control Plane and Engine identically. ## Node.js — node-postgres (`pg`) diff --git a/docs/LAUNCH.md b/docs/LAUNCH.md index 7a01880e..e7bc1c2d 100644 --- a/docs/LAUNCH.md +++ b/docs/LAUNCH.md @@ -27,10 +27,10 @@ Review the exact commands and observed results in [Tenant isolation](TENANT_ISOL ## Participate -[Star or follow the Engine](https://github.com/Agata-Proxima/proxima-engine) to track changes. Use [GitHub Issues](https://github.com/Agata-Proxima/proxima-engine/issues) for reproducible bugs, driver compatibility reports, and improvement requests. Read [Contributing](../CONTRIBUTING.md) before submitting a pull request. Report vulnerabilities privately through the repository [Security Policy](../SECURITY.md). +[Star or follow the Engine](https://github.com/Proxima-Engine/proxima-engine) to track changes. Use [GitHub Issues](https://github.com/Proxima-Engine/proxima-engine/issues) for reproducible bugs, driver compatibility reports, and improvement requests. Read [Contributing](../CONTRIBUTING.md) before submitting a pull request. Report vulnerabilities privately through the repository [Security Policy](../SECURITY.md). ## Project resources - Website: https://agataproxima.com -- Engine: https://github.com/Agata-Proxima/proxima-engine +- Engine: https://github.com/Proxima-Engine/proxima-engine - [Discord community](https://discord.gg/xsYSuDMzg) diff --git a/docs/LOCAL_DEVELOPMENT.md b/docs/LOCAL_DEVELOPMENT.md index b306cbbd..21966ee4 100644 --- a/docs/LOCAL_DEVELOPMENT.md +++ b/docs/LOCAL_DEVELOPMENT.md @@ -25,7 +25,7 @@ The local identity is self-issued and only meaningful to your local environment. Requirements: Git, Python 3.10+ (for the standard-library bootstrap script), and Docker Compose. ```bash -git clone https://github.com/Agata-Proxima/proxima-engine.git +git clone https://github.com/Proxima-Engine/proxima-engine.git cd proxima-engine docker compose -f compose.dev.yaml up --build -d ``` diff --git a/docs/MULTI_DATABASE_POLICY_PLANS.md b/docs/MULTI_DATABASE_POLICY_PLANS.md new file mode 100644 index 00000000..33fe266e --- /dev/null +++ b/docs/MULTI_DATABASE_POLICY_PLANS.md @@ -0,0 +1,50 @@ +# Multi-database policy-plan compilers + +This release adds reviewable native policy-plan generation for SQL Server, MySQL, MariaDB, MongoDB and Redis. These are early adapter-development capabilities, not production database integrations. + +The compilers live in `crates/proxima-engine/src/native_policy_plans.rs` and are exposed through `proxima-policy-guard compile-plan `. They accept the shared `proxima.security.v1` policy model and return `CompiledPolicy` values with native, reviewable changes. They do not open database connections, execute DDL, provision credentials, inspect live catalogs, verify effective permissions, detect drift, or admit runtime traffic. + +## Current compiler behavior + +| Database | Generated native plan | Required security model | Not provided | +|---|---|---|---| +| SQL Server | RLS inline predicate-function template plus filter and block predicate security-policy template | Trusted, authenticated `SESSION_CONTEXT` tenant claim | Session-context bootstrap, catalog inspection, ownership/bypass analysis, deployment, semantic verification, drift and runtime admission | +| MySQL | User and table-grant SQL template | One database and principal per tenant | Native row-level security; shared-table isolation; live privilege inspection | +| MariaDB | User and table-grant SQL template | One database and principal per tenant | Native row-level security; shared-table isolation; live privilege inspection | +| MongoDB | Custom collection-role template | One database per tenant | Document-level filtering inside a shared collection; live role inspection | +| Redis | ACL user/key-pattern template | One ACL user and strict key namespace per tenant | Trusted principal selection, command allowlist, ACL inspection and runtime enforcement | + +### SQL Server + +The generated RLS predicate compares the configured tenant ownership column with the configured claim in SQL Server `SESSION_CONTEXT`. Read operations generate a filter predicate. Insert, update and delete operations generate corresponding block predicates, including before/after update checks. The function parameter includes a `` placeholder because the exact native type must come from a live catalog inspection; the output is not executable until that substitution is performed. Function and policy DDL are separate batches, and an existing policy requires an explicit reviewed `ALTER SECURITY POLICY` revision. + +This is only safe when the tenant context is set by a trusted authenticated gateway and cannot be set or overwritten by an untrusted client. The compiler cannot prove that condition. The generated function and security policy must be inspected after deployment, and elevated principals, ownership chaining, module signing and bypass paths must be audited. + +### MySQL and MariaDB + +These systems do not expose native row-level security predicates equivalent to PostgreSQL RLS or SQL Server RLS. The compiler therefore generates a database-per-tenant grant template. It explicitly marks shared-table row-level isolation as false. The generated user and grant statements require a `${trusted_application_host}` placeholder; deployment must replace it with the exact trusted application egress host or a narrowly scoped network identity, never an unrestricted wildcard. A deployment must provision a separate database, principal and secret for each tenant, and route only after authenticating the tenant. A shared table with a `tenant_id` column is not secured by this template. + +### MongoDB + +MongoDB RBAC controls database and collection privileges; it does not automatically enforce arbitrary tenant predicates on each document. The generated custom-role template is limited to a database-per-tenant design. Shared collections need a separately enforced document-level authorization mechanism and must not be represented as isolated by this role plan. + +### Redis + +The ACL template binds a tenant-specific principal to a key pattern containing the literal `${tenant_id}` placeholder, for example `tenant:${tenant_id}:*`. The trusted gateway must select the corresponding ACL principal after authenticating the tenant. The template derives a narrower core-command allowlist from the requested operations instead of granting every mutating command. Redis ACLs cannot distinguish create-only from update-only semantics for upsert commands such as `SET`, `HSET`, `SADD` and `ZADD`; a trusted enforcing gateway or application contract must enforce that distinction. Production support still requires inspection of command key specifications, multi-key behavior, keyless commands, scripts, functions, channels, modules and administrative privileges. + +## Why these are not yet called supported + +A generated policy is not an enforced policy. Before an adapter can be marked supported, it must have all of the following: + +1. Authenticated TLS connection handling and least-privilege inspection. +2. Complete resource and native-authorization discovery. +3. Trusted tenant identity to native principal/context binding. +4. Native policy deployment behind exact-revision approval and safe rollback. +5. Semantic positive and negative tests proving cross-tenant reads and writes are denied. +6. Inspection of superuser/admin, owner, inherited-role, global privilege, view, trigger, procedure, script and bypass paths relevant to that database. +7. Drift detection that denies affected access when required controls change. +8. Runtime fail-closed admission tied to the exact verified policy revision. +9. Signed evidence with target identity, policy revision, coverage, test results, timestamp and limitations. +10. Independent adversarial acceptance against supported database versions and topologies. + +The Engine catalog therefore marks these five compilers `in_development` and enables only the `policy_generation` capability. All other capabilities remain false. CockroachDB and SQLite have separate read-only discovery adapters with drift fingerprints; Elasticsearch/OpenSearch has HTTPS index and security-role discovery. All three remain `in_development` and expose no policy-generation, semantic-verification, deployment or runtime-admission capability. Oracle, DynamoDB, Cassandra and VAULTDB remain planned. No database is promoted to production support by the existence of a compiler or catalog entry. diff --git a/docs/OPEN_SOURCE_SCOPE.md b/docs/OPEN_SOURCE_SCOPE.md index bbc1e166..80c0fbb5 100644 --- a/docs/OPEN_SOURCE_SCOPE.md +++ b/docs/OPEN_SOURCE_SCOPE.md @@ -16,7 +16,7 @@ Agata Proxima is not responsible for operating, monitoring, securing, or maintai ## Support and security reports -Community questions, reproducible bugs, and feature requests may be submitted through [GitHub Issues](https://github.com/Agata-Proxima/proxima-engine/issues). Please do not post passwords, private keys, access tokens, customer data, or exploitable vulnerability details in public issues. Follow the [Security Policy](../SECURITY.md) to report potential vulnerabilities privately. +Community questions, reproducible bugs, and feature requests may be submitted through [GitHub Issues](https://github.com/Proxima-Engine/proxima-engine/issues). Please do not post passwords, private keys, access tokens, customer data, or exploitable vulnerability details in public issues. Follow the [Security Policy](../SECURITY.md) to report potential vulnerabilities privately. Support for the hosted Agata Proxima service is separate from community support for this open-source repository. See the hosted service's published terms and support channels for any service-specific commitments. diff --git a/docs/QUICKSTART.md b/docs/QUICKSTART.md index 33eceefc..0d3a7419 100644 --- a/docs/QUICKSTART.md +++ b/docs/QUICKSTART.md @@ -12,7 +12,7 @@ Start a local PostgreSQL database, PgBouncer transaction pool, and Proxima Engin ## 1. Clone and start the stack ```bash -git clone https://github.com/Agata-Proxima/proxima-engine.git +git clone https://github.com/Proxima-Engine/proxima-engine.git cd proxima-engine docker compose -f compose.dev.yaml up --build -d ``` diff --git a/docs/README.md b/docs/README.md index 8dd6c55e..64933833 100644 --- a/docs/README.md +++ b/docs/README.md @@ -6,6 +6,9 @@ This is the complete technical guide to the public Rust data plane. Choose a tas - **[Quickstart](QUICKSTART.md)** — launch PostgreSQL and Proxima Engine, run a real SQL query, and inspect health and metrics. - **[Architecture](ARCHITECTURE.md)** — understand the request lifecycle, tenant identity, role routing, and system boundaries. +- **[Proxima Security Core](SECURITY_CORE.md)** — database-neutral policy contract, adapter maturity and fail-closed acceptance requirements. +- **[Multi-database policy plans](MULTI_DATABASE_POLICY_PLANS.md)** — SQL Server, MySQL, MariaDB, MongoDB and Redis native policy templates, plus the discovery-only scope and remaining enforcement gaps for CockroachDB, SQLite and Elasticsearch/OpenSearch. +- **[Implementation audit](IMPLEMENTATION_AUDIT_2026-11-17.md)** — current implementation status, test limitations and remaining production/merge gates. - **[Tenant isolation](TENANT_ISOLATION.md)** — configure tenant roles and RLS, issue signed context, and run positive and negative access tests. - **[Engineering case study](ENGINEERING_CASE_STUDY.md)** — review executed PgBouncer, RLS, 1,000-identity, signed-token, and recovery validation. - **[Developer security walkthrough](DEVELOPER_SECURITY_DEMO.md)** — reproduce the tenant-access scenarios and review the recorded PgBouncer evidence. @@ -42,11 +45,11 @@ This is the complete technical guide to the public Rust data plane. Choose a tas ## External project resources - [Agata Proxima website](https://agataproxima.com) -- [GitHub repository](https://github.com/Agata-Proxima/proxima-engine) -- [GitHub Actions](https://github.com/Agata-Proxima/proxima-engine/actions) -- [GitHub issues](https://github.com/Agata-Proxima/proxima-engine/issues) -- [GitHub pull requests](https://github.com/Agata-Proxima/proxima-engine/pulls) -- [GitHub releases](https://github.com/Agata-Proxima/proxima-engine/releases) +- [GitHub repository](https://github.com/Proxima-Engine/proxima-engine) +- [GitHub Actions](https://github.com/Proxima-Engine/proxima-engine/actions) +- [GitHub issues](https://github.com/Proxima-Engine/proxima-engine/issues) +- [GitHub pull requests](https://github.com/Proxima-Engine/proxima-engine/pulls) +- [GitHub releases](https://github.com/Proxima-Engine/proxima-engine/releases) - [Discord community](https://discord.gg/xsYSuDMzg) ## Product boundary diff --git a/docs/SECURITY_CORE.md b/docs/SECURITY_CORE.md new file mode 100644 index 00000000..1ca857d2 --- /dev/null +++ b/docs/SECURITY_CORE.md @@ -0,0 +1,68 @@ +# Proxima Security Core and database adapters + +## Product boundary + +Agata Proxima is a database-independent tenant-security platform. The Security Core defines a common policy and verification contract. Proxima Engine is the enforcement runtime; each database adapter implements the native protocol, identity mapping, authorization inspection and enforcement behavior required by that database. + +The current Engine implementation is PostgreSQL-specific. The common contract is an architectural foundation, not a claim that other databases are already supported. + +## Shared contract + +The canonical JSON Schema is published at [`schemas/proxima.security.v1.schema.json`](../schemas/proxima.security.v1.schema.json). The Engine Rust model validates the same envelope before an adapter compiles it. + +The Rust library module `security_core` defines: + +- Versioned policy envelopes (`proxima.security.v1`). +- Protected resource references and native tenant ownership keys. +- A common operation vocabulary: read, create, update, delete and execute. +- Explicit adapter maturity and capability descriptors. +- Security posture states and inspection-completeness states. +- A fail-closed decision rule. + +A report permits access only when posture is `verified`, inspection is `complete`, and the finding list is empty. Unknown, incomplete, unavailable, degraded, or failing inspection produces a deny decision. + +The Rust module `database_adapter` defines the adapter boundary through `DatabaseAdapter`: native inspection, policy compilation, verification, and drift detection. Its registry rejects duplicate implementations for the same database kind. The interface is an implementation contract, not proof that a database adapter exists; the current Engine branch does not register a production-ready PostgreSQL adapter through this trait yet. + +The CLI's `adapters` command reports `scope: engine_runtime`. The Cloud API reports platform-level management capabilities separately. Their scopes differ deliberately: a Cloud deployment workflow does not imply that the Engine itself performs database DDL deployment or runtime posture admission. + +## Adapter maturity + +The Engine catalog intentionally reports PostgreSQL as `in_development`. Existing work includes signed tenant-context verification, PostgreSQL role binding, the PostgreSQL Policy Guard CLI, Cloud-managed reviewed policy deployment and verification, a 30-second Cloud drift monitor, and protocol-level fail-closed admission against signed Control Plane posture. The Engine admission request uses a fresh request ID; the Control Plane persists the node-key-signed decision and per-registration evidence. The catalog still does not mark independent semantic positive/negative verification, Engine-native controlled deployment, or the generic `PolicyEvidenceAuthority` envelope pipeline as complete Engine capabilities. + +The Engine now includes review-only native policy-plan compilers for Microsoft SQL Server RLS, MySQL/MariaDB database-per-tenant grants, MongoDB database-per-tenant collection roles, and Redis tenant-key ACL templates. Read-only native discovery adapters also inspect MySQL/MariaDB, SQL Server, MongoDB, Redis, CockroachDB, SQLite and Elasticsearch/OpenSearch. These non-PostgreSQL adapters remain `in_development`; their enabled capabilities are limited to schema/security-catalog inspection, drift fingerprinting and, for the four compiler families, review-only `policy_generation`. They are not runtime enforcement adapters. Trusted tenant-principal binding, controlled policy deployment, independently executed semantic probes, drift remediation, runtime fail-closed admission and signed per-operation data-plane evidence are not implemented. MySQL/MariaDB do not have native row-level security; their grant templates require a separate database per tenant and do not secure shared tenant tables. MongoDB collection roles likewise do not provide document-level tenant filtering. Redis templates require strict key-prefix discipline, a verified command allowlist and trusted ACL-user selection. Oracle, DynamoDB, Cassandra and VAULTDB remain planned with no enabled capabilities. VAULTDB is an Agata-native research target, not a production-supported adapter. + +## Adapter responsibilities + +Every adapter must implement and validate: + +1. Secure connection establishment and least-privilege catalog inspection. +2. Native resource discovery and explicit tenant-resource classification. +3. Tenant identity to native principal/context binding. +4. Policy compilation using the target database's own semantics. +5. Effective grants, ownership, role inheritance and bypass-path inspection. +6. Semantic verification of read and write authorization. +7. Fail-closed behavior when inspection is incomplete or the required posture is not verified. +8. Drift detection and re-verification before reopening affected access. +9. Signed evidence with target, policy revision, coverage, timestamp and limitations. + +A database driver or successful connection is not an adapter. A catalog listing is not semantic authorization verification. A generated policy is not evidence that it was safely deployed. + +## Signed policy evidence and admission primitives + +The Engine library now exposes `policy_evidence::PolicyEvidenceAuthority`. It signs policy-evidence payloads with HMAC-SHA256, binding the model version, policy revision, database kind, target, tenant, posture, inspection completeness, findings, verified operations, catalog fingerprint, timestamp and individual checks. Admission envelopes bind to the exact signed-evidence digest and expire within 60 seconds. Issuance rejects stale evidence, incomplete inspection, unresolved findings, empty operation coverage or failed checks; verification rejects altered signatures and mismatched policy, target or tenant. + +The generic `PolicyEvidenceAuthority` types remain library primitives and are not yet the wire format used by the PostgreSQL listener. Separately, the PostgreSQL listener can be configured to require the hosted `/api/v1/nodes/policy-status` decision before it releases the startup `ReadyForQuery` frame; active tenant sessions are rechecked every five seconds. The Control Plane signs each response with the enrolled node key, binds it to a fresh request ID and target/tenant identity, persists the exact payload and signature, and exposes the latest 100 records in the dashboard. The response proves the Control Plane's recorded posture decision, not an independent Engine-side adversarial data probe. Do not conflate this integration with the generic `PolicyEvidenceAuthority` evidence-digest admission format. + +## PostgreSQL-specific implementation + +The PostgreSQL adapter currently uses the PostgreSQL wire protocol and native role/RLS mechanisms. It must preserve the existing signed tenant identity and tenant-to-role binding while Policy Guard matures. + +The Policy Guard CLI is an inspection and SQL-generation tool. Its current posture report explicitly states that catalog inspection cannot prove an arbitrary policy implements the intended tenant boundary. It must not be presented as a complete semantic verifier or as a runtime admission gate until those capabilities are implemented and tested. + +The SQL guard is an additional session-protection layer. It is not a complete SQL semantic firewall or general SQL rewrite engine. Its tokenizer/parser behavior, protocol coverage and fail-closed edge cases require adversarial validation. + +## Acceptance gate + +An adapter may be promoted from planned to in-development only when implementation work begins. It may be called supported only after its native inspection, policy semantics, runtime enforcement, drift response, evidence and compatibility tests are complete and independently reviewed. + +Do not enable planned adapter capabilities in the catalog merely to make the product appear broader. diff --git a/docs/SUPPORT.md b/docs/SUPPORT.md index 5636eaa2..4460c039 100644 --- a/docs/SUPPORT.md +++ b/docs/SUPPORT.md @@ -11,7 +11,7 @@ Use the route that matches the request. ## Public Engine issues -Use [GitHub Issues](https://github.com/Agata-Proxima/proxima-engine/issues) for reproducible Engine bugs, driver integration problems, documentation corrections, and feature requests. +Use [GitHub Issues](https://github.com/Proxima-Engine/proxima-engine/issues) for reproducible Engine bugs, driver integration problems, documentation corrections, and feature requests. Include: diff --git a/docs/VERIFICATION.md b/docs/VERIFICATION.md index f6034037..6bb7a19a 100644 --- a/docs/VERIFICATION.md +++ b/docs/VERIFICATION.md @@ -146,7 +146,7 @@ The maximum lifetime is 900 seconds (15 minutes). The Engine records used nonces ## 8. CI workflow -The [Rust CI workflow](https://github.com/Agata-Proxima/proxima-engine/actions/workflows/ci.yml) runs on pushes to `main` and pull requests targeting `main`. It provisions PostgreSQL 17, runs the Python CLI tests, executes `cargo test -p proxima-engine`, builds the release binary, runs the two-tenant acceptance script, builds the Docker image, and runs the PgBouncer tenant-pool integration test. +The [Rust CI workflow](https://github.com/Proxima-Engine/proxima-engine/actions/workflows/ci.yml) runs on pushes to `main` and pull requests targeting `main`. It provisions PostgreSQL 17, runs the Python CLI tests, executes `cargo test -p proxima-engine`, builds the release binary, runs the two-tenant acceptance script, builds the Docker image, and runs the PgBouncer tenant-pool integration test. A green workflow run is direct evidence that those configured checks passed for its commit. For deployment acceptance, also verify the target environment's TLS, database roles/RLS, network policy, persistence, and recovery procedures. diff --git a/docs/postgres-security-core-adapter.md b/docs/postgres-security-core-adapter.md new file mode 100644 index 00000000..de80a79d --- /dev/null +++ b/docs/postgres-security-core-adapter.md @@ -0,0 +1,133 @@ +# PostgreSQL Security Core adapter + +The Engine now contains a concrete PostgreSQL catalog adapter at +`crates/proxima-engine/src/postgres_adapter.rs`. It implements the shared +`DatabaseAdapter` contract for read-only inspection, deterministic catalog +fingerprints, review-only RLS plan generation, and fail-closed verification +reports. + +## Compile a policy plan + +```sh +cargo run -p proxima-engine --bin proxima-policy-guard -- compile-plan postgresql policy.json +``` + +Set `PROXIMA_TENANT_ROLE_PREFIX` to the same prefix configured on the Engine, +then run the command. It emits JSON containing SQL statements and explicit +preconditions. It does not connect to PostgreSQL and does not execute DDL. The +generated plan enables and forces RLS, then creates restrictive per-operation +policies that derive the tenant ID from the authenticated PostgreSQL login +role: the role must equal the configured prefix followed by the normalized +tenant ID. This uses the Engine's existing per-tenant role routing and does not +depend on session-level GUC state, which is important when a transaction-pooling +proxy is present. + +Before applying a plan, an operator must review the resource mapping, confirm +the tenant column type and semantics, verify that each requested command has a +reviewed permissive baseline policy, reconcile existing policies and grants, +and ensure the Engine's tenant role prefix and tenant-role provisioning contract +match the database's tenant IDs. The plan is not an authorization approval and is not safe to apply +without those preconditions. + +## Inspect a live target + +Configure: + +- `PROXIMA_POSTGRES_ADAPTER_DATABASE_URL`: PostgreSQL connection URL. The + adapter requires TLS and uses the Engine's trusted root set. Set + `PROXIMA_POLICY_AUDIT_TLS_CA_FILE` when a private CA is required. +- `PROXIMA_POSTGRES_ADAPTER_TARGET_ID`: stable, non-secret registered target ID. +- `PROXIMA_POSTGRES_ADAPTER_DATABASE_NAME`: expected database name. +- `PROXIMA_TENANT_ROLE_PREFIX`: exact role prefix used by Engine startup + authentication and tenant role routing. + +Then run: + +```sh +cargo run -p proxima-engine --bin proxima-policy-guard -- inspect-policy policy.json +``` + +The adapter configures a read-only session with bounded statement and lock +timeouts. It rejects inspection credentials with elevated role attributes or +database/schema/table write privileges. It checks target identity, relation +existence, RLS enabled/forced state, inherited owner SUPERUSER/BYPASSRLS paths, +policy definitions, policy roles, and relation ACLs. The catalog fingerprint +includes policy expressions and ACL state so policy edits, grant changes, and +RLS toggles change the digest. + +The command currently exits with a deny result. This is intentional: catalog +inspection and policy presence cannot prove tenant isolation. The adapter +does not claim semantic verification, approved policy deployment, rollback, +or runtime admission. It does not register as production-supported. Production +admission must remain denied until independent authenticated positive and +cross-tenant negative probes, controlled deployment/rollback, drift response, +and the protocol connection admission path are implemented and accepted. + +## Runtime admission against Control Plane posture + +For a node to enforce the hosted PostgreSQL policy state before accepting a +tenant connection, configure: + +- `PROXIMA_NODE_POLICY_STATUS_URL`: the Control Plane endpoint + `/api/v1/nodes/policy-status` (HTTPS in production). +- `PROXIMA_DATABASE_TARGET_ID`: the UUID of the registered PostgreSQL + connection in the Control Plane. +- `PROXIMA_POLICY_ADMISSION_REQUIRED=true`: fail Engine startup if the + admission endpoint or its required node identity is not configured. + +When the endpoint is configured, every tenant-bound PostgreSQL startup performs +a signed request bound to the node, registered target, requested database, +verified tenant ID, Engine role prefix, and a fresh random request ID. The +Control Plane returns a node-key-signed decision with a 15-second expiry and +per-registration evidence covering catalog fingerprint freshness, persisted +tenant-role binding, revision verification, and latest drift observations. +The exact signed payload is persisted in the Control Plane with a SHA-256 +digest and a unique `(node_id, request_id)` constraint. The Engine verifies +the signature and every binding, including the one-time request ID, before +relaying the established session. Replayed request IDs are rejected. An +unreachable service, invalid signature, expired response, unknown policy, +unapplied revision, stale schema fingerprint, drift flag, or non-protected +verification denies the connection. + +The Control Plane runs its PostgreSQL catalog and revision verification monitor every 30 seconds. +The admission endpoint denies when the last fingerprint check is older than +90 seconds. Every registration on the target that maps to the requested tenant +must be enabled and have its latest revision applied and verified as protected; +a disabled, unknown, stale or drifted registration denies admission. The +Control Plane also checks that tenant roles have no access to unregistered +application tables. A tenant with no registered protected resources is denied +when admission is enabled. + +The Engine rechecks active tenant sessions every five seconds. Each recheck +uses a new request ID and obtains a new signed decision; no allow decision is +reused across connections or rechecks. If posture becomes unknown, unsafe, +stale, or unreachable, the Engine closes affected sessions instead of allowing +them to continue. The PostgreSQL startup +`ReadyForQuery` message is withheld until the first signed admission succeeds, +so a denied connection is never reported as ready to the client. + +## Signed evidence boundary + +Every request ID is reserved in a short-lived nonce table for 15 minutes to +reject replay. To avoid writing one audit row for every five-second active- +session recheck, the Control Plane stores at most one signed posture snapshot +per node/target/tenant/posture per minute. Each snapshot contains the request +ID, per-registration verification checks, SHA-256 payload digest and HMAC +signature, and is retained for 90 days. The dashboard exposes the latest 100 +snapshots per target. This proves which Control Plane posture decision was +issued to a node and what checks informed it; it is not a substitute for +independent positive and cross-tenant negative data-plane probes. + +The generic `PolicyEvidenceAuthority` in `policy_evidence.rs` remains a separate +cryptographic library primitive. Its policy-evidence/admission-envelope format +is not yet the payload used by this PostgreSQL Control Plane admission route. + +The Engine Prometheus endpoint also exposes `proxima_engine_policy_admission_checks_total`, `proxima_engine_policy_admission_allowed_total`, `proxima_engine_policy_admission_denied_total`, and `proxima_engine_policy_admission_session_revocations_total` so operators can monitor gate activity and automatic session closure. + +## Scope boundary + +This first concrete adapter supports PostgreSQL table and partitioned-table +catalog inspection and table RLS plan generation. Partitioned relations produce +an explicit finding because directly addressable child partitions require +their own inspection. Views, routines, SECURITY DEFINER behavior, external +authorization, and application-level access paths require separate checks. diff --git a/schemas/proxima.security.v1.schema.json b/schemas/proxima.security.v1.schema.json new file mode 100644 index 00000000..3acf391f --- /dev/null +++ b/schemas/proxima.security.v1.schema.json @@ -0,0 +1,99 @@ +{ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "$id": "https://agataproxima.com/schemas/proxima.security.v1.schema.json", + "title": "Proxima Security Policy v1", + "description": "Database-neutral tenant-security policy contract. Database adapters compile these requirements into native controls.", + "type": "object", + "additionalProperties": false, + "required": [ + "schema_version", + "policy_id", + "revision", + "tenant_identity_claim", + "resources" + ], + "properties": { + "schema_version": { + "const": "proxima.security.v1" + }, + "policy_id": { + "type": "string", + "minLength": 1, + "maxLength": 128 + }, + "revision": { + "type": "integer", + "minimum": 1 + }, + "tenant_identity_claim": { + "type": "string", + "minLength": 1, + "maxLength": 128 + }, + "resources": { + "type": "array", + "minItems": 1, + "maxItems": 1000, + "items": { + "type": "object", + "additionalProperties": false, + "required": [ + "resource", + "tenant_key", + "operations" + ], + "properties": { + "resource": { + "type": "object", + "additionalProperties": false, + "required": [ + "name", + "kind" + ], + "properties": { + "namespace": { + "type": "string", + "minLength": 1, + "maxLength": 256 + }, + "name": { + "type": "string", + "minLength": 1, + "maxLength": 256 + }, + "kind": { + "enum": [ + "table", + "view", + "collection", + "procedure", + "function", + "keyspace" + ] + } + } + }, + "tenant_key": { + "type": "string", + "minLength": 1, + "maxLength": 256 + }, + "operations": { + "type": "array", + "minItems": 1, + "uniqueItems": true, + "items": { + "enum": [ + "read", + "create", + "update", + "delete", + "execute" + ] + } + } + } + } + } + } +}