Skip to main content
Menu
Advisories

Found during a routine audit of main at 0d9d8ce189

GHSA-VPXW-WQC5-HVVJPublished Updated GitHub

Description

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, information_schema.tables / columns / views, pg_matviews),
  • GraphQL introspection (both __schema { types } and __type(name: ...)),
  • SchemaInfo, which renders the MCP get_schema tool and the arcadedb://{database}/schema MCP resource, and whose own javadoc says "Performs no permission or authorization check; the caller is responsible for both" while both callers check only database-level access.

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 every type of the schema with no principal consulted; it is the source of the TABLES, COLUMNS and the relkind listings
  • postgresw/src/main/java/com/arcadedb/postgres/PostgresCatalog.java:496, resolve() takes a userName string and never resolves a SecurityDatabaseUser from it
  • postgresw/src/main/java/com/arcadedb/postgres/PostgresNetworkExecutor.java:1606, the catalog is answered before the statement can reach the SQL engine, so no engine-level gate runs
  • postgresw/src/main/java/com/arcadedb/postgres/PostgresNetworkExecutor.java:3995 and 4017, where the principal IS bound on the connection, which is what makes this a renderer gap
  • graphql/src/main/java/com/arcadedb/graphql/schema/GraphQLSchema.java:619, buildTypeList() walks database.getSchema().getTypes() unfiltered
  • graphql/src/main/java/com/arcadedb/graphql/schema/GraphQLSchema.java:649, buildTypeResult() answers any existsType(name) by name
  • server/src/main/java/com/arcadedb/server/info/SchemaInfo.java:53, toJSON() walks schema.getTypes() unfiltered, with the javadoc that puts the duty on its callers
  • mcp/src/main/java/com/arcadedb/mcp/tools/GetSchemaTool.java:47, the caller, which checks the MCP allow-list and database-level read only
  • 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, engine/src/main/java/com/arcadedb/query/sql/executor/FetchFromSchemaTypesStep.java:66 and 130, engine/src/main/java/com/arcadedb/query/opencypher/procedures/db/DbLabels.java:75, server/src/main/java/com/arcadedb/server/ai/AiSchemaDigest.java:303

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 handler shape? No. PostgresNetworkExecutor binds it at openDatabase and rebinds it at revalidateUser; MCPToolUtils.bindCurrentUser binds it before the tool runs; the HTTP query handler binds it for GraphQL. The gate that is missing is in the renderer, not in the transport.
  • Does a second layer catch it? No. The PostgreSQL catalog is answered from the schema before the statement could reach the SQL engine, and it reads no record, so neither checkPermissionsOnFile nor checkPermissionsOnType is ever reached. GraphQL introspection and SchemaInfo likewise read only schema objects.
  • Is it deliberate, with something saying so? The opposite is said twice, in SecurityHelper.canAccessType and in FetchFromSchemaTypesStep, and acted on in four other listings. SchemaInfo's javadoc delegates the check to its callers and neither caller performs it, which is a broken promise rather than a decision.
  • Is it only reachable by an administrator? No. Any authenticated user with access to the database reaches all three; the PostgreSQL route does not even need a non-default client, psql \dt is enough.
  • Does it leak record data? Not directly. Only a materialized view's stored query text can carry literal values from the schema, which is why this is rated MEDIUM and not higher.
  • Does the denied type have to pre-exist the user's permission snapshot? Yes, and it does in the probe: the types are created before the principal is bound, which is the normal deployment order and the order UngatedHandlerPerTypeAclIT uses for the same reason.

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: 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: 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: Full-text BM25 statistics ignore bucket access control: hidden subtype documents are countable through EXPLAIN/PROFILE, and restricted users fail their first search

Affected versions

References

GitHub · ArcadeData/arcadedb