Skip to main content

Apache Camel EUVDEUVD-2026-25790

| CVE-2026-40048 HIGH
Deserialization of Untrusted Data (CWE-502)
2026-04-27 security@apache.org GHSA-v3vg-332r-mw99
7.8
CVSS 3.1 · Vendor: apache
View

Attack ChainAIDerived

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

  1. Access
    Obtain write access to key directory
  2. Delivery
    Plant crafted serialized `.key` file
  3. Exploit
    Key lifecycle op calls readObject()
  4. Execution
    Gadget chain executes on deserialization
  5. Persist
    Arbitrary code runs as application
  6. Impact
    Full host/application compromise

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A08:2025 - Software or Data Integrity Failures
ASVS 5.0
V1 - Encoding and Sanitization Safe deserialization, type allowlists
MITRE ATT&CK

2 techniques across 2 tactics: Execution, Initial Access

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

Exploitation Conditions

Exploitation requires the application to be using the camel-pqc FileBasedKeyLifecycleManager with a file-backed key store, and the attacker must be able to write or replace a <keyId>.key file in the configured key directory. The description names the concrete avenues: a path traversal that reaches the key directory, misconfigured filesystem permissions on the key volume, a compromised key provisioning pipeline, or a symlink attack. A key lifecycle operation must then deserialize the planted file for the payload to fire. Limiting factors: the vector is local (AV:L) and requires low privileges (PR:L) - there is no purely remote, unauthenticated path; only vulnerable 4.18.0-4.18.1 and 4.19.0 deployments actually running the PQC key management feature are exposed, and a properly locked-down key directory neutralizes the practical attack surface.

Impact

Signals are consistent and point to a genuine-but-conditional risk rather than a mass-exploitation emergency. The CVSS vector (AV:L/AC:L/PR:L/UI:N, C:H/I:H/A:H) and SSVC 'Technical Impact: total' both reflect that successful exploitation gives full compromise of the application, but AV:L plus the description confirm the attacker must already be able to write into the key directory. SSVC 'Exploitation: none' and 'Automatable: no' align with the very low EPSS (0.07%, 22nd percentile) and the absence of KEV listing or public PoC - this is not opportunistically wormable. The practical priority is therefore driven by whether the affected 4.18.x/4.19.x PQC feature is actually in use and how well the key directory is isolated; where it is used, the total-impact outcome justifies prompt patching, but for most estates this is a moderate, patch-in-normal-cycle item. No major conflicts exist between sources; the only caveat is that the local write precondition means raw CVSS 7.8 overstates remote risk against a hardened deployment.

Exploit ScenarioDerived

An attacker gains write access to the Camel key directory - for example by exploiting a path-traversal upload, abusing loose permissions on the mounted key volume, or compromising the key-provisioning pipeline - and drops a malicious <keyId>.key file containing a serialized gadget-chain object. During the next routine key lifecycle operation the application calls readObject() on that file, executing the gadget's side effects and running attacker code in the application's context before the failed KeyPair cast is ever reached. No public exploit is identified at time of analysis, though the deserialization pattern is well understood and gadget chains are widely available.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
Patch available 0.1% exploitation probability (EPSS)

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

Alert me

AnalysisAIv1 – Jul 24, 2026

Arbitrary code execution in Apache Camel's PQC component (camel-pqc) arises because FileBasedKeyLifecycleManager deserializes <keyId>.key files with java.io.ObjectInputStream and no ObjectInputFilter or class allow-listing. Because the KeyPair cast happens only after readObject() returns, malicious gadget-chain side effects execute before any type check, letting an attacker who can plant a crafted serialized object in the key directory run code as the application. It affects Camel 4.19.0 before 4.20.0 and 4.18.0 before 4.18.2, carries CVSS 7.8, and has no public exploit identified at time of analysis; EPSS is very low at 0.07%.

RemediationAI

Vendor-released patch: upgrade to Apache Camel 4.20.0, or 4.18.2 on the 4.18.x LTS stream; these replace ObjectInputStream-based key/metadata storage with PKCS#8 and X.509 SubjectPublicKeyInfo Base64 JSON encoding, eliminating the deserialization path (see https://camel.apache.org/security/CVE-2026-40048.html). Note that after upgrading, existing serialized .key files are in the old format, so plan for key re-provisioning/migration to the new encoding. Where immediate patching is not possible, reduce exposure by restricting filesystem permissions on the configured key directory so only the Camel process account can write to it, mounting that volume without attacker-writable paths, and disabling symlink following to blunt the symlink and path-traversal vectors; audit any key-provisioning pipeline that feeds the directory. As a hardening measure, deploy a JVM-wide serialization filter (jdk.serialFilter / ObjectInputFilter) to reject unexpected classes - the trade-off is potential breakage if other components rely on Java serialization, so test before rolling out. Red Hat customers should track https://access.redhat.com/security/cve/CVE-2026-40048 for downstream fixed builds.

Affected VersionsENISA

Apache Camel PQC 4.19.0 <4.20.0
Apache Camel PQC 4.18.0 <4.18.2

Affected Packages

maven org.apache.camel:camel-pqc fix: 4.18.2
euvd apache_camel_pqc fix: 4.18.2, 4.20.0

Source: OSV (Open Source Vulnerabilities)

Affects your stack

Affects 2 packages in maven, euvd

Checking this CVE against your own stacks and servers is part of the Basic plan and up.

Technical ContextAI · show details

The flaw is a classic Java deserialization weakness (CWE-502) in the camel-pqc integration component, which manages post-quantum/asymmetric key material on disk. FileBasedKeyLifecycleManager reads each <keyId>.key file straight into an ObjectInputStream and calls readObject() expecting a java.security.KeyPair, but ObjectInputStream reconstructs whatever class the byte stream names, invoking that class's readObject()/readResolve() and finalizer logic during reconstruction - well before the (KeyPair) cast can reject it. With a suitable gadget chain on the classpath (e.g. Commons-Collections, Spring, or other libraries common in Camel deployments), this reconstruction yields code execution. CPE data scopes the issue to cpe:2.3:a:apache:camel across the listed 4.18.x/4.19.x ranges. Version 4.20.0 removes ObjectInputStream entirely, storing keys as PKCS#8 (private) and X.509 SubjectPublicKeyInfo (public) in Base64 JSON, which is not code-bearing.

Know when Camel 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 (apache) PRIMARY 7.8 HIGH
AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H
vuln.today AI 7.8 HIGH

Attacker needs local write access to the key directory (AV:L, PR:L); once a malicious file is placed, deserialization reliably yields full code execution (C/I/A:H).

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

Primary rating from Vendor (apache).

CVSS VectorVendor: apache

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

Lifecycle Timeline

4
Patch released
Apr 28, 2026 - 19:43 nvd
Patch available
CVSS changed
Apr 27, 2026 - 16:22 NVD
7.8 (None) 7.8 (HIGH)
Patch available
Apr 27, 2026 - 10:01 EUVD
CVE Published
Apr 27, 2026 - 09:16 nvd
HIGH 7.8

DescriptionCVE.org

The Camel-PQC FileBasedKeyLifecycleManager class deserializes the contents of <keyId>.key files in the configured key directory using java.io.ObjectInputStream without applying any ObjectInputFilter or class-loading restrictions. The cast to java.security.KeyPair is evaluated only after readObject() has already returned, so any readObject() side effects in the deserialized object run before the type check. An attacker who can write to the key directory used by a Camel application - for example through a path traversal into the directory, misconfigured filesystem permissions on the volume where keys are stored, a compromised key provisioning pipeline, or a symlink attack - can place a crafted serialized Java object that, when deserialized during normal key lifecycle operations, results in arbitrary code execution in the context of the application.

This issue affects Apache Camel: from 4.19.0 before 4.20.0, from 4.18.0 before 4.18.2.

Users are recommended to upgrade to version 4.20.0, which fixes the issue by replacing java.io.ObjectInputStream-based key and metadata storage with standard PKCS#8 (private key) / X.509 SubjectPublicKeyInfo (public key) Base64 JSON encoding. For users on the 4.18.x LTS releases stream, upgrade to 4.18.2.

Blast Radius

ecosystem impact
† from your stack dependencies † transitive graph · vuln.today resolves 4-path depth
  • 4 maven packages depend on org.apache.camel:camel-pqc (3 direct, 1 indirect)

Ecosystem-wide dependent count for version 4.18.2.

Executive ViewAI

Why It Matters

Apache Camel versions 4.18.0-4.18.1 and 4.19.0-4.19.x contain a deserialization vulnerability in the PQC component allowing arbitrary code execution if an attacker can write malicious objects to the application's key storage directory; no public exploit identified at time of analysis. Successful exploitation would grant application-level code execution and potential access to encryption keys. Organizations must upgrade to patched versions 4.18.2 or 4.20.0 immediately.

Business Impact: High
Compensating Controls

Apply vendor patch. Interim: restrict file-system write permissions on key storage directories to the Camel application service account only, and deploy file integrity monitoring to detect unauthorized file modifications in those directories.

Threat Intelligence Overview

EPSS Score
0.1%
Top 78% exploitable
Prevalence
Medium
Apache Camel widely deployed, but the affected PQC key component is niche/new
Threat Intel
1
1 source
Social Media
1
Sightings
Data Quality
7 sources
Confidence: High
EUVD NVD CVE.org EPSS Vulnrichment GHSA Vendor CIRCL VulDB

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.1%
Patch available Yes
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
Small
Automatable
No
Human Impact
High
Technical Impact
Total

Priority Score

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

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.

Path traversal exploits occur when applications use user-controlled input to construct file system paths 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 Camel

View all
CVE-2025-27636 MEDIUM POC
5.6 Mar 09

Bypass/Injection vulnerability in Apache Camel components under particular conditions.10.0 through <= 4.10.1, from 4.8.0

CVE-2014-0002 HIGH POC
7.5 Mar 21

The XSLT component in Apache Camel before 2.11.4 and 2.12.x before 2.12.3 allows remote attackers to read arbitrary file

CVE-2016-8749 CRITICAL POC
9.8 Mar 28

Apache Camel's Jackson and JacksonXML unmarshalling operation are vulnerable to Remote Code Execution attacks. Rated cri

CVE-2014-0003 HIGH POC
7.5 Mar 21

The XSLT component in Apache Camel 2.11.x before 2.11.4, 2.12.x before 2.12.3, and possibly earlier versions allows remo

CVE-2026-23552 CRITICAL POC
9.1 Feb 23

Cross-realm token acceptance bypass in Apache Camel Keycloak security policy. The KeycloakSecurityPolicy fails to proper

CVE-2026-25747 HIGH POC
8.8 Feb 23

Deserialization of Untrusted Data vulnerability in Apache Camel LevelDB component. The Camel-LevelDB DefaultLevelDBSeria

CVE-2026-40473 HIGH POC
8.8 Apr 27

Unsafe Java deserialization in the Apache Camel camel-mina component (versions 3.0.0 through 4.14.5, 4.15.0 through 4.18

CVE-2019-0194 HIGH POC
7.5 Apr 30

Apache Camel's File is vulnerable to directory traversal. Rated high severity (CVSS 7.5), this vulnerability is remotely

CVE-2017-12634 CRITICAL
9.8 Nov 15

The camel-castor component in Apache Camel 2.x before 2.19.4 and 2.20.x before 2.20.1 is vulnerable to Java object de-se

CVE-2015-5344 CRITICAL
9.8 Feb 03

The camel-xstream component in Apache Camel before 2.15.5 and 2.16.x before 2.16.1 allow remote attackers to execute arb

CVE-2017-12633 CRITICAL
9.8 Nov 15

The camel-hessian component in Apache Camel 2.x before 2.19.4 and 2.20.x before 2.20.1 is vulnerable to Java object de-s

CVE-2013-4330 MEDIUM
6.8 Oct 04

Apache Camel before 2.9.7, 2.10.0 before 2.10.7, 2.11.0 before 2.11.2, and 2.12.0 allows remote attackers to execute arb

Vendor StatusVendor

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