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.
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