llamaCVEVulnerability Intelligence
/
Advisory · GitHub · Maven · com.arcadedb:arcadedb-server

GHSA-6PGQ-XPQQ-RMJX

A user with only updateSchema escapes a per-type ACL by renaming the type, gaining read, DELETE and TRUNCATE on a denied TIMESERIES type

Parche disponible
Descargar PNG JSON
CVSS
—
high
Fuente: —
ExplotaciónSin evidenciaNo figura en CISA KEV
Exploits públicos0Ninguno conocido
Parche1 versiónPrimer parche el mismo día de la divulgación
Exposición16 dDesde la divulgación, 4 nov 2026, 4:25 p. m.
Detección13 dDesde la divulgación hasta su ingreso al índice
Timeline

Ciclo de vida de la vulnerabilidad

Hoy
Divulgación
Publicada
Explotación
Remediación
Parche 26.11.1
Monitoreo
Detectada +1
4 nov 26
18 nov 26
21 nov 26
4 nov 26
8 nov 26
12 nov 26
17 nov 26
21 nov 26
FechaFaseEventoDetalle
Divulgación Publicada GHSA-6PGQ-XPQQ-RMJX divulgada
Remediación Parche 26.11.1 com.arcadedb:arcadedb-server · 0 d desde divulgación
Monitoreo Detectada Ingresó al índice
Monitoreo Verificada Última verificación contra las fuentes
Resumen
Descripción del advisory
Texto original · GitHub · en inglés

Summary

A user holding only `updateSchema` on a database can read, delete and truncate a type they are explicitly denied, by renaming it. Per-type ACLs are keyed by type NAME on both sides and nothing carries a rename into the permission configuration.

Affected component

`engine` and `server` security, at main. Not introduced by a recent change; the destructive half became reachable when TIMESERIES DELETE and TRUNCATE were re-enabled.

Impact

`ALTER TYPE <t> NAME <new>` requires only `DATABASE_ACCESS.UPDATE_SCHEMA`. After it, the per-type entry that denied the user no longer matches, and `requestAccessOnType` default-allows an unknown name. A refresh does not repair it: resolving the new name falls through to the group's `"*"` default.

On a TIMESERIES type the per-type map is, in the code's own words, the only way to gate the type. Measured against the real `ServerSecurityDatabaseUser`:

  • before the rename, the denied user gets a `SecurityException` on SELECT, DELETE and TRUNCATE
  • after `ALTER TYPE SecretMetrics NAME PublicMetrics`, the same user reads every sample, `DELETE ... WHERE ts < 1500` answers `{"count":1}`, and `TRUNCATE TYPE` empties it

On a record-backed type the per-file map (keyed by file id, not by name) still denies immediately after the rename, but the next `updateSecurity()` rebuilds it under the new name and the type is open. Any CREATE TYPE, DROP TYPE or index creation triggers that.

Root cause

Two sides, both keyed by name:

  • the group document's `types` object
  • `AccessSnapshot.typeAccess`, rebuilt from `type.getName()`

`LocalDocumentType.rename` does not call `updateSecurity()` at all, and nothing else carries the rename to the configuration.

The project already has the right abstraction for this. The schema now enumerates everything that stores a type name behind `TypeNameDependant`, gathered by `LocalSchema.getTypeNameDependants()` and walked by `checkTypeHasNoDependants`, `checkTypeRenameKeepsDependants` and `carryTypeRenameToDependants`. The interface's own framing is that there is no second place to remember a type name. The permission map is exactly such a second place and is not in that list.

Suggested fix

Make the permission configuration a `TypeNameDependant` so a rename either carries to it or is refused, the same way a materialized view, a continuous aggregate, a trigger and a graph analytical view already behave.

The guarantee that closes the class rather than this instance: a test that, for every registered `TypeNameDependant` implementation plus the permission map, renames a type and asserts the dependant still resolves. Adding the permission map to the existing list makes that test cover it for free.

Separately, `requestAccessOnType` defaulting to allow for an unknown name is what turns a stale key into access rather than into a refusal. Defaulting to deny for a name the snapshot does not know would make this fail closed even if a future dependant is forgotten.

Credit

Reported by @ruispereira.

---

Update 2026-10-22: still unfixed, and one correction to our own report

Nothing moved. The `TypeNameDependant` implementors are still materialized views, continuous
aggregates, triggers and graph analytical views, and `LocalSchema.getTypeNameDependants()` builds
from exactly those four, so none of the three schema guards sees the permission map. `rename` still
gates on `UPDATE_SCHEMA` alone, and `requestAccessOnType` still default-allows an unknown name.

The correction

Our report said the rename "does not call `updateSecurity()`". That is true of the method, and
misleading: the rename runs inside a `recordFileChanges` session that reaches `saveConfiguration()`,
which ends in `updateSecurity()`.

It does not close the hole, and it is worth stating why so the report is not dismissed on that
sentence. The rebuild resolves the NEW name against a groups document that still names the OLD one,
so `resolveTypeAccess` falls through to the group default. And the no-rebuild path exists as well:
`saveConfiguration` returns before `updateSecurity()` when a transaction is active or
`multipleUpdate` is set. Both ways end in access being granted.

---

Validation update 2026-10-23

Both reported vulnerabilities are fixed. Two small residuals follow.

I re-validated all four reports against the hardening work, each against its own report rather than
the commit message. All four come back COMPLETE, every fix has a test, and I made each test inert
and re-ran it: none was inert, and in each case the failure on the inert tree reproduces the
original report verbatim, including the admin group coming back widened for the groups-file case.

Worth saying explicitly: the rename fix also closes an escape I did not report, detaching a
non-empty bucket from a restricted type. And `stop()` no longer takes the policy lock before
cancelling, so the shutdown stall is gone.

Two residuals remain. Neither is the reported vulnerability and neither needs an embargo in my view,
but both belong in this thread rather than a public issue.

1. A type alias still leaks the sample count of a denied TIMESERIES type

`LocalDatabase.countType` gates on the name the caller passed rather than on `type.getName()`, and
an alias is not a key of the access snapshot, so the default-allow arm fires:

public long countType(final String typeName, final boolean polymorphic) {
  ...
  final DocumentType type = schema.getType(typeName);
  ...
  checkPermissionsOnType(typeName, SecurityDatabaseUser.ACCESS.READ_RECORD);

`SELECT count(*)` through the alias answers, while reads and writes through the same alias are
still refused. Record-backed types are unaffected. Gating on `type.getName()` is a one line change.

This is the same shape as the rename escape: a permission keyed by a name, consulted with a name
the caller chose. The narrower patch closes the rename route; the alias route is the other way to
present a second name for the same type.

2. "A reload never writes the live file" is still conditional

With a root password configured, a reload that needs it is applied rather than refused, and
`server-users.jsonl` is rewritten from memory. No loop, no stall, no widening, so this is a much
smaller thing than what was reported. I mention it only because the guarantee as stated in the class
is unconditional and this is the one case where it does not hold.

One observation, not a finding

On the MongoDB side an empty or `$`-prefixed database name still takes the admin branch, so a
command there is authenticated but not checked against `canAccessToDatabase` and runs with no
principal bound. That is unchanged from before the fix and I could not reach it by any supported
route that creates such a database, so I am noting it rather than reporting it.

---

Update, 2026-10-25, re-validated at main d9faba8ca3

The rename route is closed and holds. The alias route I mentioned above as "the other way to
present a second name" turns out not to need any pre-existing alias: a user holding only
`updateSchema` can install it, and that operation is not checked.

`ALTER TYPE ... ALIASES` is the unguarded twin of `ALTER TYPE ... NAME`

`LocalDocumentType.setAliases:1019` gates only on `checkForSchemaMutation()`, that is
`checkPermissionsOnDatabase(UPDATE_SCHEMA)` at `LocalDocumentType:442`. It never calls
`schema.checkTypeRenameKeepsAccess`, which has exactly two call sites in the whole tree: the rename
and the bucket detach.

So the operation you just refused, and the operation that gives the same records the same second
name at the same privilege, differ only in which one is checked.

Measured with a `SecurityManager` that refuses every `checkTypeRename` and records each call it is
given:

ALTER TYPE SecretMetrics NAME Leaked     -> REFUSED SecurityException: 'SecretMetrics' and 'Leaked' do not resolve to the same access
ALTER TYPE SecretMetrics ALIASES Leaked  -> {"aliases":["Leaked"],"operation":"ALTER TYPE","typeName":"SecretMetrics","result":"OK"}
security manager calls: [checkTypeRename(SecretMetrics -> Leaked)]
the type now also answers to 'Leaked': SecretMetrics

One call recorded, for the rename. None for the alias.

The count residual is confirmed still live

`LocalDatabase.countType:915` is byte for byte unchanged. It gates on the caller's `typeName` and
then calls `tsType.requireEngine()`, the unchecked accessor whose own javadoc at
`LocalTimeSeriesType:121-128` says every user-facing path must use `requireEngine(ACCESS)` instead.

schema.getType("PublicMetrics") resolves to: SecretMetrics
requestAccessOnType(SecretMetrics, READ_RECORD) = false
countType("SecretMetrics")         -> REFUSED SecurityException: not allowed to read records on type 'SecretMetrics'
countType("PublicMetrics") [alias] -> 7
SELECT count(*) FROM PublicMetrics -> 7
SELECT * FROM PublicMetrics        -> REFUSED
DELETE FROM PublicMetrics          -> REFUSED
TRUNCATE TYPE PublicMetrics        -> REFUSED

Blast radius is exactly the count, in both the API and the SQL form, polymorphic or not. Nothing
escalates beyond it. We censused every caller-name-keyed authorization in the tree: `countType` is
the only one that leaks. `PostPrometheusWriteHandler:200` also keys on the caller's name, but its
write is then gated by `requireEngine(CREATE_RECORD)`, so an alias buys nothing there.

The guarantee we are asking for

Invariant: a per-type grant resolved for a type is the grant configured for that type, whichever of
its names the caller used, and no schema operation may give a type a name the configuration
resolves differently.

Four levels, cheapest first:

  1. `countType` stops deciding for itself: use `tsType.requireEngine(ACCESS.READ_RECORD)`, the
  2. `setAliases` calls `schema.checkTypeRenameKeepsAccess(name, alias)` for each added alias, so the
  3. The one that closes the class rather than these two instances: make the permission configuration
  4. A test in the shape of the Mongo census you shipped for the OP_QUERY fix: for every registered
Note on where this fix sits

We asked for the permission map to become a `TypeNameDependant` and for `requestAccessOnType` to
fail closed. What landed is a bespoke refusal inside `rename`, called from two sites. The alias
route is what the difference between those two answers costs. We are not asking you to redo the
rename fix, only to note that it is a guard at a call site rather than at the authority, and that
the authority is where level 3 above would put it.

Versiones

Rangos afectados

Afectada Corregida Última
com.arcadedb:arcadedb-server≤ 26.10.2
26.10.2
26.11.1
Remediación

Estado del parche por paquete

Paquete / productoEstadoCorregida enDesde divulgaciónÚltima versión
mavencom.arcadedb:arcadedb-server
Corregida 26.11.1 0 d 26.11.1 no afectada
Versiones corregidas26.11.1
Explotación

Arsenal público

Sin exploits, módulos ni PoC públicos conocidos a la fecha de verificación.

Referencias
Advisoryhttps://github.com/ArcadeData/arcadedb/security/advisories/GHSA-6pgq-xpqq-rmjx

Las referencias externas se muestran para copiar: cve.llama.ec no lo redirige a otros sitios.