Skip to main content

Apache Camel CVE-2026-93572

| EUVDEUVD-2026-82870 HIGH
Allocation of Resources Without Limits or Throttling (CWE-770)
2026-09-18 redhat GHSA-jmx3-m859-mrgc
7.5
CVSS 3.1 · Vendor: redhat
View

Attack ChainAIDerived

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

  1. Access
    Reach Netty RESP decoder over network
  2. Delivery
    Send ~12KB of nested array headers (length 1,000,000)
  3. Exploit
    Each header eagerly allocates ArrayList capacity
  4. Execution
    Reserve ~1 billion slots to depth 1024
  5. Impact
    Exhaust JVM heap, denial of service

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A06:2025 - Insecure Design
ASVS 5.0
V2 - Validation and Business Logic Resource allocation limits
MITRE ATT&CK

1 technique across 1 tactic: Impact

The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up.

Exploitation Conditions

Requires the target application to use Netty's Redis codec (RedisArrayAggregator) constructed with the default constructor - i.e., the default nesting limit of 1024 and no tightened maxElements - and to feed attacker-reachable, untrusted RESP input into that decoder. Exploitation is unauthenticated and needs no user interaction (PR:N/UI:N), but is LIMITED to deployments that actually expose a Netty-based RESP/Redis-protocol parsing endpoint to untrusted clients; applications that override the limits with a stricter custom constructor, or never parse untrusted RESP, are not exposed. Impact is availability-only (heap exhaustion); no data is read or modified.

Impact

This is a genuine but bounded availability risk. The CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H, base 7.5) is internally consistent with the description: an unauthenticated remote attacker sends ~12 KB of crafted nested RESP array headers and forces up to ~1,024,000,000 ArrayList slots to be pre-allocated, an amplification attack causing memory-exhaustion DoS with no confidentiality or integrity impact. I agree with the 7.5 and the CWE-770 (allocation of resources without limits) classification. However, the real-world priority is lower than the raw score suggests: no EPSS score, no CISA KEV listing, and no public exploit are present in the input (no public exploit identified at time of analysis), and exploitation is gated on the host application actually using Netty's Redis codec with the default (untightened) maxElements/maxNestedArrayDepth and exposing the RESP decoder to untrusted input. Note the data covers only Red Hat's downstream products; the vulnerable class RedisArrayAggregator is a Netty component, so the true affected population is 'applications embedding the Netty Redis codec,' not Red Hat products alone - verify Netty upstream advisory for the fixed version, which is not provided here.

Exploit ScenarioDerived

An attacker with network reach to a service that decodes untrusted RESP (Redis protocol) input via Netty's RedisArrayAggregator sends a small (~12 KB) stream of deeply nested array headers each declaring length 1,000,000, up to the default depth of 1024. The eager allocator reserves over a billion child slots before any element arrives, exhausting heap and causing an out-of-memory denial of service. No public exploit is identified in the provided data, but the technique is simple and fully described in the advisory.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
No patch listed yet 0.3% exploitation probability (EPSS)

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

Alert me

AnalysisAIv1 – Sep 18, 2026

Heap exhaustion in Netty's Redis array aggregator, as shipped inside Red Hat products such as JBoss Enterprise Application Platform 7, Red Hat Fuse 7, Red Hat Build of Apache Camel for Spring Boot 4, and Red Hat Single Sign-On 7, lets a remote unauthenticated attacker crash the JVM by sending a tiny stream of nested RESP array headers. Because the decoder eagerly allocates an ArrayList sized to the declared array length before any child element arrives, roughly 12 KB of crafted input can reserve about 1.02 billion child slots when the default 1024-level nesting limit and default element limit are in effect; the impact is availability-only, with no data read or modified. Exploitation is limited to deployments that feed attacker-reachable, untrusted RESP/Redis-protocol traffic into the Netty codec with the default constructor; no public exploit code and no confirmed active exploitation were identified at time of analysis.

RemediationAI

No exact vendor-released fix version is provided in the available intelligence; the Red Hat CVE page (https://access.redhat.com/security/cve/CVE-2026-93572) and Bugzilla 2536963 are the authoritative tracking sources and should be monitored for the patched Netty/Camel build to be applied once published. Until then, the most effective control is to stop using the default codec configuration: construct the Redis decoder/aggregator with an explicit maxElements tightly bounded to the largest legitimate array the application must handle and a reduced maxNestedArrayDepth well below 1024, which destroys the depth-times-length amplification - the trade-off is that legitimate large multi-bulk replies (for example LRANGE or SMEMBERS results with many members) may be rejected, so limits must be validated against real workloads before rollout. If untrusted clients cannot be prevented from reaching the RESP parser, isolate and restrict that endpoint: segment the Redis-protocol listener so it is reachable only from trusted proxies or internal networks, and enforce connection-count/concurrency caps and request rate limits at the edge so an attacker cannot repeat the allocation many times in parallel; the trade-off is added operational complexity and potential throttling of legitimate clients. Finally, cap the JVM heap (-Xmx) and enable heap-dump/OOM alerting so large allocations fail fast and are detected, accepting that this converts silent heap growth into a process crash rather than preventing it.

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 issue sits in Netty's Redis protocol (RESP) decoding path, specifically RedisArrayAggregator/RedisDecoder and its AggregateState, which were recently hardened with two independent guards: maxElements (per-array length) and maxNestedArrayDepth (stack depth). Both checks pass independently, but allocation remains eager - AggregateState calls new ArrayList<RedisMessage>(length), and the ArrayList(int) constructor reserves backing capacity immediately while the list is still logically empty. An attacker therefore only needs to emit positive array headers of length 1,000,000 repeated up to the default nesting depth of 1024 to force allocation of roughly 1,024,000,000 reference slots from about 12 KB of wire input, an amplification far beyond normal parsing cost. CWE-770 (Allocation of Resources Without Limits or Throttling) is the root-cause class: the limits bound each dimension separately but not their product, and they do not delay or lazily grow capacity. The vulnerable component is the RES P codec embedded in the Camel/Netty stack that Red Hat redistributes in EAP 7, Fuse 7, Red Hat Build of Apache Camel for Spring Boot 4, and Single Sign-On 7, as reflected by the CPE entries and the availability-only vector CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H.

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

Vendor (redhat) PRIMARY 7.5 HIGH
AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H
vuln.today AI 7.5 HIGH

Unauthenticated remote attacker sends a small crafted RESP stream (AV:N/AC:L/PR:N/UI:N) causing memory-exhaustion DoS with no confidentiality/integrity impact, so C:N/I:N/A:H, S:U.

3.1 AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H
4.0 AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:N/VA:H/SC:N/SI:N/SA:N
SUSE HIGH
Red Hat 7.5 HIGH

Primary rating from Vendor (redhat).

CVSS VectorVendor: redhat

Attack Vector
Network
Attack Complexity
Low
Privileges Required
None
User Interaction
None
Scope
Unchanged
Confidentiality
None
Integrity
None
Availability
High

Lifecycle Timeline

3
CVSS changed
Sep 18, 2026 - 13:22 NVD
7.5 (HIGH)
CVE Published
Sep 18, 2026 - 10:53 cve.org
UNKNOWN (no severity yet)
CVE Published
Sep 18, 2026 - 10:53 nvd
HIGH 7.5

DescriptionCVE.org

Summary

RedisArrayAggregator recently added maxElements and maxNestedArrayDepth limits to fix public Redis resource-exhaustion advisories. The limits are independent, but the allocator remains eager: every positive nested RESP array header creates new ArrayList<RedisMessage>(length) before any child element exists.

With the default constructor, an attacker can send nested array headers with length 1,000,000 until the default nesting limit of 1024 is reached. This can reserve up to 1,024,000,000 child slots from roughly 12 KB of RESP input. This is backing capacity, not logical list size: ArrayList(int) constructs an empty list with the specified initial capacity.

Technical Details

Current decodeRedisArrayHeader(...) checks the two limits independently:

java
if (header.length() > maxElements) {
    throw new CodecException("this codec doesn't support longer length than " + maxElements);
}

if (depths.size() >= maxNestedArrayDepth) {
    releaseAndClearDepths();
    throw new CodecException("max nested array depth exceeded: "  + maxNestedArrayDepth);
}
depths.push(new AggregateState((int) header.length()));

AggregateState i

Executive ViewAI

Why It Matters

Netty's Redis array aggregator, bundled in Red Hat products such as JBoss Enterprise Application Platform 7, Red Hat Fuse 7, Red Hat Build of Apache Camel for Spring Boot 4, and Red Hat Single Sign-On 7, can let a remote attacker exhaust JVM heap and crash the application by sending crafted RESP array headers. The impact is availability-only, with no data read or modified, but successful exploitation could cause production outages for any service that accepts untrusted Redis-protocol traffic through the affected codec. No public exploit identified at time of analysis, but leadership should prioritize exposure discovery and interim mitigations because no vendor-released patch identified at time of analysis.

Business Impact: High
Compensating Controls

No vendor-released patch identified at time of analysis. Interim mitigations: restrict untrusted RESP/Redis-protocol traffic to the Netty codec; configure non-default decoder limits for maximum array length and nesting depth; reject oversized RESP array headers at network edge/WAF; segment or disable Redis protocol listeners; monitor JVM heap and enable alerts for rapid memory exhaustion; prepare to apply vendor patch once available.

Threat Intelligence Overview

EPSS Score
0.3%
Top 73% exploitable
Prevalence
High
affects widely-deployed Red Hat Java middleware (JBoss EAP, Keycloak/SSO, Fuse) bundling Netty
Social Media
2
Sightings
Data Quality
6 sources
Confidence: High

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 HIGH
CISA KEV No
Public POC No
EPSS 0.3%
Patch available No
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.9)
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.

SSVC AssessmentENISA

SSVC Decision
Scheduled
Exploitation
None
System Exposure· derived
Open
Automatable
Yes
Human Impact
High
Technical Impact
Partial

Priority Score

38
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +38
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.

Affected Products (CPE)CVE.org

cpe:2.3:a:red_hat:red_hat_build_of_apache_camel_for_spring_boot_4:*:*:*:*:*:*:*:*
cpe:2.3:a:red_hat:red_hat_fuse_7:*:*:*:*:*:*:*:*
cpe:2.3:a:red_hat:red_hat_jboss_enterprise_application_platform_7:*:*:*:*:*:*:*:*
cpe:2.3:a:red_hat:red_hat_jboss_enterprise_application_platform_7:*:*:*:*:*:*:*:*
cpe:2.3:a:red_hat:red_hat_jboss_enterprise_application_platform_7:*:*:*:*:*:*:*:*
cpe:2.3:a:red_hat:red_hat_jboss_enterprise_application_platform_7:*:*:*:*:*:*:*:*
cpe:2.3:a:red_hat:red_hat_single_sign-on_7:*:*:*:*:*:*:*:*

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.

Vendor StatusVendor

SUSE

Severity: Important
Product Status
SUSE Linux Enterprise Desktop 15 SP7 Not-Affected
SUSE Linux Enterprise Desktop 15 SP7 Affected
SUSE Linux Enterprise Module for Development Tools 15 SP7 Not-Affected
SUSE Linux Enterprise Module for Development Tools 15 SP7 Affected
SUSE Linux Enterprise Module for Package Hub 15 SP7 Affected

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