GHSA-VPXW-WQC5-HVVJ
Three schema listings ignore the per-type ACL and hand a denied user the full definition of a type it cannot read, including a materialized view's defining SQL
Ciclo de vida de la vulnerabilidad
| Fecha | Fase | Evento | Detalle |
|---|---|---|---|
| Divulgación | Publicada | GHSA-VPXW-WQC5-HVVJ divulgada | |
| Remediación | Parche 26.11.1 | com.arcadedb:arcadedb-grpcw · 2 d desde divulgación | |
| Monitoreo | Detectada | Ingresó al índice | |
| Monitoreo | Verificada | Última verificación contra las fuentes |
Found during a routine audit of main at 0d9d8ce189. Reported privately per SECURITY.md. Reproduced with controls in the same process; recorded output below is verbatim.
## The "hide a type the caller cannot read" rule of the schema listings is applied at the call sites that were patched for it and not at the authority, so the PostgreSQL wire catalog, GraphQL introspection and the MCP schema renderer hand a per-type-denied user the full schema: type names, every property and its type, index definitions and the supertype graph
SEVERITY: MEDIUM
Summary
The codebase has an explicit rule for catalog listings, written down twice: a type the current
user may not read is left out of the listing rather than failing it. It is stated in
SecurityHelper.canAccessType ("For listings that must silently hide what the caller cannot see
rather than fail the whole request") and in FetchFromSchemaTypesStep ("Issue #4238: hide types the
current user cannot read at all instead of throwing"), and that step goes as far as hiding an
unreadable type from the parentTypes of a readable child.
The rule lives in each listing, not in the thing that renders a schema. Four listings keep it: the
SQL pseudo-types (schema:types, schema:indexes, schema:triggers), the Cypher db.labels /
db.propertyKeys / db.relationshipTypes / schema visualization procedures, the PromQL and Grafana
metadata handlers, and the AI schema digest. Three other routes to the same state do not consult
the bound principal at all:
- the PostgreSQL wire catalog emulation (pg_class, pg_attribute, pg_index, pg_inherits,
- GraphQL introspection (both __schema { types } and __type(name: ...)),
- SchemaInfo, which renders the MCP get_schema tool and the arcadedb://{database}/schema MCP
A user holding database access with per-type permissions that deny a type reads that type's whole
definition through any of the three. The record data stays protected (the engine's per-bucket gate
still fires), so this is disclosure of schema metadata, not of rows. What it discloses is the
column names and declared types of the denied type, its UNIQUE and other index definitions, its
inheritance, and, for a materialized view or continuous aggregate, the full SQL text of the view's
defining query, which can carry literal predicate values.
The principal is bound on all three transports before these routes run, so this is not a missing
binding: it is a renderer that never asks.
Where (HEAD 0d9d8ce189)
- postgresw/src/main/java/com/arcadedb/postgres/PostgresCatalog.java:2240, sortedTypes() takes
- postgresw/src/main/java/com/arcadedb/postgres/PostgresCatalog.java:496, resolve() takes a
- postgresw/src/main/java/com/arcadedb/postgres/PostgresNetworkExecutor.java:1606, the catalog is
- postgresw/src/main/java/com/arcadedb/postgres/PostgresNetworkExecutor.java:3995 and 4017, where
- graphql/src/main/java/com/arcadedb/graphql/schema/GraphQLSchema.java:619, buildTypeList() walks
- graphql/src/main/java/com/arcadedb/graphql/schema/GraphQLSchema.java:649, buildTypeResult()
- server/src/main/java/com/arcadedb/server/info/SchemaInfo.java:53, toJSON() walks
- mcp/src/main/java/com/arcadedb/mcp/tools/GetSchemaTool.java:47, the caller, which checks the MCP
- mcp/src/main/java/com/arcadedb/mcp/MCPResources.java:84, the second caller, same gap
- the rule the three break: engine/src/main/java/com/arcadedb/security/SecurityHelper.java:111,
Repro
Three standalone probes against the built module classes, each on an embedded database with a
SecurityDatabaseUser bound into DatabaseContext that denies SecretDoc by bucket id and by name, the
same shape the engine ACL tests use (Issue7477LightweightEdgeScanAclTest.bindUser). Built with
mvn -pl postgresw -am and mvn -pl graphql -am, skipping tests.
Probe 1, the PostgreSQL catalog resolver, run verbatim:
=== CONTROL 1: SELECT FROM SecretDoc as the scoped user ===
refused: SecurityException: User 'scoped' is not allowed to read records on type 'SecretDoc'
=== CONTROL 2: SELECT name FROM schema:types as the scoped user ===
PublicDoc
=== PROBE A: pg_class table list ===
{relname=PublicDoc}
{relname=SecretDoc}
=== PROBE B: information_schema.tables ===
{table_name=PublicDoc}
{table_name=SecretDoc}
=== PROBE C: information_schema.columns of SecretDoc ===
{table_name=SecretDoc, column_name=cardNumber, data_type=character varying}
{table_name=SecretDoc, column_name=ssn, data_type=character varying}
The two controls are the point: the same bound principal is refused the records, and the SQL
catalog listing already hides the type from the same user in the same process.
Probe 2, GraphQL introspection through the database query engine, run verbatim:
=== PROBE: graphql __schema introspection as the scoped user ===
{"types":[{"name":"PublicDoc","fields":[{"name":"title"}]},{"name":"SecretDoc","fields":[{"name":"cardNumber"},{"name":"ssn"}]},{"name":"String","fields":null},{"name":"Int","fields":null},{"name":"Float","fields":null},{"name":"Boolean","fields":null},{"name":"ID","fields":null},{"name":"Long","fields":null},{"name":"JSON","fields":null},{"name":"BigDecimal","fields":null}]}
=== PROBE: graphql __type(name: "SecretDoc") as the scoped user ===
{"name":"SecretDoc","fields":[{"name":"cardNumber"},{"name":"ssn"}]}
Probe 3, the MCP schema renderer, run verbatim (the type also carries a UNIQUE index here):
=== PROBE: SchemaInfo.toJSON (MCP get_schema / arcadedb://{db}/schema) as the scoped user ===
{"database":"probe","types":[{"name":"PublicDoc","category":"document","properties":[{"name":"title","type":"STRING"}]},{"name":"SecretDoc","category":"document","properties":[{"name":"cardNumber","type":"STRING"}],"indexes":[{"name":"SecretDoc[cardNumber]","type":"LSM_TREE","properties":["cardNumber"],"unique":true}]}]}
Refutation attempted
- Is the principal simply not bound on those transports, making this the already-reported ungated
- Does a second layer catch it? No. The PostgreSQL catalog is answered from the schema before the
- Is it deliberate, with something saying so? The opposite is said twice, in
- Is it only reachable by an administrator? No. Any authenticated user with access to the database
- Does it leak record data? Not directly. Only a materialized view's stored query text can carry
- Does the denied type have to pre-exist the user's permission snapshot? Yes, and it does in the
Suggested fix (and then the guarantee)
The correction is three filters: sortedTypes() in PostgresCatalog, buildTypeList() and
buildTypeResult() in GraphQLSchema, and toJSON() in SchemaInfo, each dropping a type for which
SecurityHelper.canAccessType(user, type, READ_RECORD) is false, resolving the user from the
database context as FetchFromSchemaTypesStep does. The PostgreSQL catalog should filter its derived
relations off the same set, so pg_attribute, pg_index and pg_inherits do not reintroduce by RID
what pg_class hides, and __type should answer "not found" rather than a refusal so it does not
become an existence oracle, matching the MCP decision already taken on that distinction.
The guarantee is what matters more. The invariant that must hold is: no route may render a schema
object the bound principal cannot read, and a new route must not be able to acquire the leak by
being written. Today the invariant lives in each listing, so every new catalog is a new chance to
forget it, and three already did. Make the schema walk the only way to enumerate types for
presentation: one method, for instance SecurityHelper.readableTypes(DatabaseInternal), that
resolves the bound principal itself and returns the visible types, with Schema.getTypes() kept for
engine-internal callers the way LocalTimeSeriesType.getEngine() is kept beside
getEngine(ACCESS) and documented the same way ("unchecked accessor, engine-internal callers only").
Then convert the four listings that already filter onto it, so the rule has one implementation, and
make a new renderer that reaches for getTypes() visible as what it is. A test that enumerates every
main-source caller of getSchema().getTypes() outside the engine and asserts each is either on the
readable walk or named in an explicit allow-list would turn the next omission into a red build
instead of the next advisory.
Scope / confidence
Executed: all three probes above, against engine, postgresw, graphql and server target/classes
built from this worktree, with the recorded output reproduced verbatim. The two controls in probe 1
were executed in the same process as the leak.
Read, not executed: that the HTTP, MCP and PostgreSQL transports bind the principal before these
routes run (read in PostgresNetworkExecutor, MCPToolUtils, DatabaseAbstractHandler); that
MCPToolUtils.resolveDatabase checks only the MCP allow-list and database-level access; that the
pg_matviews definition column carries the view's query text (PostgresCatalog around line 1950). The
probes drive the renderers directly rather than through a live socket, which is why the transport
binding is stated as read rather than run; the leak itself does not depend on it, since the
renderers ignore any principal.
Dedup
Checked the last 1000 titles. The nearest neighbours are catalog correctness, not authorization:
#10829, #10799, #10711, #10695, #10594, #10593, #10591, #10495, #10473, #10371, #10370, #10228 and
#10691 are all about what the PostgreSQL catalog answers, none about who may see it. #10764 is the
GraphQL introspection concurrency bug, a different defect in the same code. #9780 and #9637 are
per-file permission-map gaps on buckets, the mirror image of this one (they were about data, this
is about the catalog). #10739 is the build-lane question for SchemaChangePerTypeAclIT and
UngatedHandlerPerTypeAclIT, which is where a regression test for this would go. No title covers a
schema listing that ignores the per-type ACL.
Related advisories
This advisory and its CVE also cover the following advisories, fixed in the same release (26.11.1):
- GHSA-4mmv-84cq-wpc5
https://github.com/ArcadeData/arcadedb/security/advisories/GHSA-4mmv-84cq-wpc5: ArcadeDbGrpcAdminService.getDatabaseInfo reads schema and per-type record counts without binding the authenticated principal, the shape the sibling handler's own comment forbids - GHSA-48q6-q453-cm77
https://github.com/ArcadeData/arcadedb/security/advisories/GHSA-48q6-q453-cm77: GET /api/v1/cluster names every single-bucket type of every database the caller may open, with no per-type readability filter, and the new census sanctions the walk as internal - GHSA-875c-3v5j-4wh2
https://github.com/ArcadeData/arcadedb/security/advisories/GHSA-875c-3v5j-4wh2: Full-text BM25 statistics ignore bucket access control: hidden subtype documents are countable through EXPLAIN/PROFILE, and restricted users fail their first search
Rangos afectados
Estado del parche por paquete
| Paquete / producto | Estado | Corregida en | Desde divulgación | Última versión |
|---|---|---|---|---|
mavencom.arcadedb:arcadedb-grpcw |
Corregida | 26.11.1 | 2 d | 26.11.1 no afectada |
mavencom.arcadedb:arcadedb-engine |
Corregida | 26.11.1 | 0 d | 26.11.1 no afectada |
26.11.1Arsenal público
Sin exploits, módulos ni PoC públicos conocidos a la fecha de verificación.
https://github.com/ArcadeData/arcadedb/security/advisories/GHSA-vpxw-wqc5-hvvjLas referencias externas se muestran para copiar: cve.llama.ec no lo redirige a otros sitios.
