Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessObtain write access to Redis state store
-
DeliveryPlant malicious serialized object graph in topology keyspace
-
ExploitWorker restores stateful bolt checkpoint
-
ExecutionKryo deserializes without class registration
-
ImpactExecute arbitrary code in worker JVM
Vulnerability Assessment
| Exploitation Conditions | Exploitation requires the Redis-backed state provider (explicitly NOT the default state-store configuration) AND the attacker having write access to the topology's keyspace in that state store - e.g. a co-tenant of a shared Redis instance or anyone with network/credential access to it. It is further gated on the use of stateful bolts whose checkpoints are serialized by DefaultStateSerializer. Limiting factors: default Storm deployments are not affected; the attacker must already hold a data-plane write privilege to the state store; and exploitation only triggers when state is restored. Per the advisory, the only complete fix is upgrading to 3.1.0 (with a possible checkpoint-migration step); operators who cannot upgrade immediately should restrict network and credential access to the state store to the cluster itself. |
| Impact | This is an important-severity deserialization-to-RCE flaw (CWE-502) in Apache Storm Client's DefaultStateSerializer, which configured Kryo with class registration disabled and a constructor-skipping instantiation strategy, then deserialized whatever the state store returned. No CVSS vector was supplied by NVD, no EPSS score is available, and vuln.today's decision label is 'awaiting_data' - so the quantitative signals are effectively absent and cannot be weighed. It is NOT in CISA KEV and no public exploit is identified, so this is not a confirmed widespread-exploitation emergency; it reads as a conditional, high-impact issue rather than a high-CVSS-but-trivial one. The critical mitigating factor is that exploitation requires the Redis-backed state provider (explicitly NOT the default) plus write access to the topology's keyspace in the state store - a data-plane privilege the advisory is careful to distinguish from the code execution it yields. Realistic priority is therefore elevated specifically for multi-tenant/shared-Redis Storm deployments using stateful bolts with the Redis state provider, and low for everyone on default configurations. Key missing data to note explicitly: no NVD CVSS vector, no EPSS, and no KEV/POC signals to corroborate exploitability - priority rests on the vendor advisory alone. |
| Exploit ScenarioDerived | A co-tenant of a shared Redis instance, or anyone with network/credential access to the state store, writes a crafted Kryo-serialized object graph into the topology's keyspace. When a stateful bolt later restores its checkpoint, DefaultStateSerializer deserializes the attacker-supplied bytes without class registration and instantiates objects without calling constructors, executing attacker-controlled code inside the worker JVM. No public PoC or exploit code is identified at time of analysis. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Nov 09, 2026
Deserialization of untrusted data in Apache Storm Client (org.apache.storm:storm-client) 3.0.0 before 3.1.0 lets an attacker who can write to a topology's keyspace in the state store plant a crafted serialized object graph that executes code inside the worker JVM when stateful bolt checkpoints are restored. The flaw sits in DefaultStateSerializer, which configured Kryo with class registration disabled and used a constructor-skipping instantiation strategy before deserializing whatever bytes the state store returned, so a low-privileged party (CVSS PR:L) with data-plane write access - a co-tenant of a shared Redis instance or anyone with network or credential access to it - gains code execution, a privilege escalation out of the data plane. Exposure is limited to deployments using the Redis-backed state provider, which is explicitly not the default, and the advisory states the only complete fix is upgrading to 3.1.0; no public exploit code and no confirmed active exploitation were identified at time of analysis, and no EPSS or KEV data is available (priority status: awaiting_data).
RemediationAI
Vendor-released patch: Apache Storm 3.1.0, in which the state serializer requires registered classes and no longer deserializes arbitrary class graphs. Upgrade org.apache.storm:storm-client to 3.1.0 across the cluster. Because the fix is a behaviour change, checkpoints written by an affected 3.0.x version may fail to restore after the upgrade and the advisory notes a migration step may be required - plan for that during a maintenance window rather than treating the upgrade as drop-in, and validate restoration of stateful-topology state before promoting to production. The advisory states that upgrading is the only complete fix; operators who cannot upgrade immediately should restrict network and credential access to the state store to the cluster itself, which shrinks the set of parties able to write to a topology's keyspace but does not remove the weakness for any insider or co-tenant that retains that write access. Advisory: https://seclists.org/oss-sec/2026/q4/581 (project: https://storm.apache.org/).
Affected ProductsAI
Apache Storm Client, Maven coordinate org.apache.storm:storm-client, versions 3.0.0 before 3.1.0. Within that range only deployments whose topologies use the Redis-backed state provider (explicitly not Storm's default state-store configuration) and contain stateful bolts whose checkpoints are handled by DefaultStateSerializer are exploitable; stock or default-configured clusters are stated not to be affected. Applicability should be confirmed per cluster by checking the configured state provider and whether any topology relies on stateful bolts. Vendor and disclosure references are the oss-security advisory at https://seclists.org/oss-sec/2026/q4/581 and the project site https://storm.apache.org/, with the CVE record at https://www.cve.org/CVERecord?id=CVE-2026-82436.
Affects your stack
Find out whether the stacks and servers you run are on an affected version.
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
The component is Apache Storm's DefaultStateSerializer, the serializer used to persist and restore checkpoints of stateful bolts. It configured Kryo - the Java serialization framework Storm uses for object graphs - with two unsafe settings combined: class registration disabled, which means deserialization is not restricted to an allow-list of expected classes, and an instantiation strategy that constructs objects without invoking their constructors, so constructor-side validation or invariants never run. The serializer then deserialized whatever bytes the state store returned, which is the classic CWE-502 (deserialization of untrusted data) pattern that allows gadget-chain style code execution inside the worker JVM. Two preconditions bound the attack surface: the topology must use the Redis-backed state provider rather than the default state-store configuration, and the topology must use stateful bolts whose checkpoints flow through this serializer. The affected package is org.apache.storm:storm-client from 3.0.0 up to, but not including, 3.1.0; 3.1.0 changes the serializer to require registered classes, which is a behavioural change for pre-existing checkpoint data. The advisory frames write access to a state-store key as a data-plane privilege and code execution in the worker JVM as something beyond it, so the flaw is an elevation from storage-write to execution rather than a remotely reachable unauthenticated bug; the assessed vector (AV:N/AC:H/PR:L/UI:N/S:U/C:H/I:H/A:H) reflects that a high-impact but precondition-heavy path. The trigger mechanics beyond the serializer configuration - such as which specific gadget classes would be usable - are not described in the available sources.
Know when Redis gets its next vulnerability
- Watch products and get an email when something new is published
- Check this CVE against your own stack and servers
- Exploit and PoC references, threat intelligence from 22 sources
No credit card · 7-day full trial
Severity by source
Attacker needs write access to the state store (PR:L) and the non-default Redis state provider (AC:H); successful deserialization yields full code execution in the worker JVM (C/I/A:H).
Description PRE-NVD
Executive ViewAI
CVE-2026-82436 is a critical deserialization vulnerability in Apache Storm's client library that allows a low-privileged attacker with write access to a topology's state store to execute arbitrary code inside worker processes. Only deployments using the non-default Redis-backed state provider are vulnerable, but those are exposed to potential privilege escalation from the data plane. Leadership should prioritize remediation because a single compromised Redis instance could lead to full worker compromise and lateral movement.
No vendor-released patch identified at time of analysis. Interim mitigations: restrict network access to the Redis state store to only necessary hosts and users; enforce strong authentication and authorization on Redis; monitor for anomalous write operations to topology keyspaces; consider migrating to a non-Redis state provider until upgrade is possible.
Threat Intelligence Overview
How this decision was reached
The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.
What every action level means
Attack Technique
Insecure deserialization occurs when an application converts serialized data (a stream of bytes representing an object's state) back into a living object without proper validation.
Remote Code Execution represents the critical moment when an attacker successfully runs arbitrary code on a target system without physical access.
Privilege escalation to root in the LiteSpeed User-End cPanel Plugin (versions 2.3 through before 2.4.5) lets attackers
Alpine Linux: valkey fixed in 7.2.7-r0
UAF in Redis 8.2.1 via crafted Lua scripts by authenticated users. EPSS 12.4%. Patch available.
Authenticated Redis users with permission to run server-side Lua can trigger an integer overflow (CWE-190) in the bundle
It was discovered, that redis, a persistent key-value database, due to a packaging issue, is prone to a (Debian-specific
Memory Corruption was discovered in the cmsgpack library in the Lua subsystem in Redis before 3.2.12, 4.x before 4.0.10,
Redis before 2.8.21 and 3.x before 3.0.2 allows remote attackers to execute arbitrary Lua bytecode via the eval command.
A buffer overflow in Redis 3.2.x prior to 3.2.4 causes arbitrary code execution when a crafted command is sent. Rated cr
Authenticated Lua script execution in Redis 8.2.1 and earlier can be abused with a crafted long-string delimiter to trig
Authenticated remote code execution in OpenC3 COSMOS (Ruby gem 'openc3' versions 5.1.0 through 7.2.1) lets any logged-in
CVE-2025-46818 is a sandbox-escape flaw in Redis's embedded Lua scripting engine (all versions up to and including 8.2.1
Code injection in OneUptime monitoring via custom JS monitor using vm module. PoC and patch available.
CVE.org
GitHub PoC
Exploit-DB