Skip to main content

Apache Storm CVE-2026-82436

CRITICAL
2026-11-09
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Obtain write access to Redis state store
  2. Delivery
    Plant malicious serialized object graph in topology keyspace
  3. Exploit
    Worker restores stateful bolt checkpoint
  4. Execution
    Kryo deserializes without class registration
  5. Impact
    Execute 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.

Act Now Prioritize within 24-48h. Why: CRITICAL severity.
No patch listed yet

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – 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

vuln.today AI 7.5 HIGH

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).

3.1 AV:N/AC:H/PR:L/UI:N/S:U/C:H/I:H/A:H
4.0 AV:N/AC:L/AT:P/PR:L/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N

Description PRE-NVD

Disclosed via oss-security. NVD scoring and full description are pending.

Executive ViewAI

Why It Matters

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.

Business Impact: High
Compensating Controls

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

Prevalence
Low
niche distributed real-time compute framework; Redis state provider is non-default
Social Media
2
Sightings
Data Quality
1 sources
Confidence: Low

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.

SignalValue
Severity CRITICAL
CISA KEV No
Public POC No
EPSS N/A
Patch available No
Active threat No
Deciding rule
CRITICAL severity
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

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.

More in Redis

View all
CVE-2026-48172 CRITICAL POC
10.0 May 21

Privilege escalation to root in the LiteSpeed User-End cPanel Plugin (versions 2.3 through before 2.4.5) lets attackers

CVE-2024-31449 HIGH
8.8

Alpine Linux: valkey fixed in 7.2.7-r0

CVE-2025-49844 CRITICAL POC
9.9 Oct 03

UAF in Redis 8.2.1 via crafted Lua scripts by authenticated users. EPSS 12.4%. Patch available.

CVE-2025-46817 HIGH POC
8.8 Oct 03

Authenticated Redis users with permission to run server-side Lua can trigger an integer overflow (CWE-190) in the bundle

CVE-2022-0543 CRITICAL POC
10.0 Feb 18

It was discovered, that redis, a persistent key-value database, due to a packaging issue, is prone to a (Debian-specific

CVE-2018-11218 CRITICAL POC
9.8 Jun 17

Memory Corruption was discovered in the cmsgpack library in the Lua subsystem in Redis before 3.2.12, 4.x before 4.0.10,

CVE-2015-4335 CRITICAL POC
10.0 Jun 09

Redis before 2.8.21 and 3.x before 3.0.2 allows remote attackers to execute arbitrary Lua bytecode via the eval command.

CVE-2016-8339 CRITICAL POC
9.8 Oct 28

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

CVE-2025-46819 HIGH POC
7.1 Oct 03

Authenticated Lua script execution in Redis 8.2.1 and earlier can be abused with a crafted long-string delimiter to trig

CVE-2026-77602 CRITICAL POC
9.9 Sep 23

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 HIGH POC
7.3 Oct 03

CVE-2025-46818 is a sandbox-escape flaw in Redis's embedded Lua scripting engine (all versions up to and including 8.2.1

CVE-2026-27574 CRITICAL POC
9.9 Feb 21

Code injection in OneUptime monitoring via custom JS monitor using vm module. PoC and patch available.

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy