Skip to main content

Apache Camel CVE-2026-85243

| EUVDEUVD-2026-104185 MEDIUM
Improper Validation of Integrity Check Value (CWE-354)
2026-10-19 apache GHSA-rgg6-2q97-gxhm
5.9
CVSS 3.1 · Vendor: apache
View

Attack ChainAIDerived

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

  1. Access
    Produce message or gain MITM position
  2. Delivery
    Encode with legacy symmetrically-encrypted packet (no MDC)
  3. Exploit
    unmarshal() skips integrity check
  4. Execution
    Tamper ciphertext via CFB malleability
  5. Impact
    Route accepts forged plaintext

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A08:2025 - Software or Data Integrity Failures
ASVS 5.0
V15 - Secure Coding and Architecture Integrity verification
Exploitation Conditions

The target must run a route using the Apache Camel crypto PGP data format and decrypt incoming PGP messages via unmarshal(). The attacker must either control production of those messages or be able to rewrite them in transit, and must encode the message using the older OpenPGP symmetrically encrypted data packet (which carries no modification detection code) instead of the integrity-protected packet. Before the fix there was no decrypt-side option to require integrity, so any such deployment was exposed by default. Limiting factors: exploitation requires attacker influence over the message bytes (producer or MITM), yielding AC:H; impact is confined to integrity (undetected tampering/forgery of decrypted content) with no confidentiality or availability loss; and the issue only matters where Camel consumes externally-supplied PGP ciphertext.

Impact

This is a genuine but moderate-severity integrity flaw, not a drop-everything emergency. The CVSS 3.1 score of 5.9 (AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:H/A:N) correctly captures the shape of the problem: network-reachable and unauthenticated (PR:N), but with high attack complexity (AC:H) because the attacker must either be the message producer or hold a man-in-the-middle position able to rewrite messages in transit, and the target deployment must consume PGP messages through Camel's crypto PGP unmarshal() path. Impact is integrity-only (I:H) with no confidentiality or availability effect (C:N/A:N) - the vulnerability lets an attacker defeat tamper-detection, not read secrets or crash the service. No EPSS score, CISA KEV listing, or public POC was provided, so there is no signal of active or imminent exploitation; the status is 'no public exploit identified at time of analysis.' One signal conflicts: the input carries an 'Information Disclosure' tag, but the CVSS vector sets C:N and the root cause (CWE-354, missing modification-detection-code validation enabling CFB malleability) is a tampering/integrity issue - the tag appears mislabeled and should not drive triage toward a confidentiality framing. Net: prioritize for patching in any deployment that decrypts externally-supplied PGP messages, but it ranks below network-exploitable code-execution or data-disclosure bugs.

Exploit ScenarioDerived

An attacker who produces messages consumed by a Camel route, or who can rewrite messages in transit, sends a PGP message encoded with the legacy symmetrically encrypted data packet that carries no modification detection code. Camel's unmarshal() skips the integrity check for that packet type, and because OpenPGP's CFB mode is malleable, the attacker can modify the ciphertext so the route decrypts and accepts forged or tampered plaintext as if it were authentic. No public exploit identified at time of analysis.

This Month Plan within 30 days. Why: MEDIUM severity (CVSS 4.0-6.9).
Patch available 0.2% exploitation probability (EPSS)

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

Alert me

AnalysisAIv1 – Oct 19, 2026

Undetected tampering with PGP-encrypted messages is possible in the Apache Camel Crypto PGP data format because unmarshal() only validated the OpenPGP modification detection code when the incoming message used the integrity-protected packet type, and the packet type is selected by the message producer. Deployments running Camel 4.0.0 through 4.18.4 or 4.19.0 through 4.22.0 that decrypt externally supplied PGP ciphertext are affected; unauthenticated remote attackers who can produce those messages, or rewrite them in transit, can substitute the legacy symmetrically encrypted data packet and have malleated content accepted without any integrity failure. Impact is limited to integrity (silent forgery or modification of decrypted content) with no confidentiality or availability loss, so this is a genuine but moderate-severity flaw rather than an emergency; no public exploit code was identified at time of analysis and there is no confirmed active exploitation (CISA KEV) - exploitation requires the attacker to control or intercept the message bytes, which is why the vector carries AC:H.

RemediationAI

Vendor-released patches: upgrade to Apache Camel 4.23.0, or to 4.18.5 on the 4.18.x LTS stream or 4.22.1 on the 4.22.x LTS stream (see https://camel.apache.org/security/CVE-2026-85243.html and the fix PRs https://github.com/apache/camel/pull/25848, /pull/25944 and /pull/25946). After upgrading, leave the new requireIntegrityProtection option at its default of true so unmarshal() rejects messages that are not integrity protected; consider also tightening signatureVerificationOption to required, since the default optional means an unsigned message is still accepted and a decrypted message only gains authenticity when both controls are enforced. If you must interoperate with a sender that still emits the legacy tag-9 packet, set requireIntegrityProtection=false explicitly and treat the decrypted content as unauthenticated and untrusted - it may have been modified in transit - and log or monitor those routes so the legacy interop is time-boxed. For deployments that cannot upgrade immediately, add a validation step before the PGP data format in the route that inspects the OpenPGP packet tag and rejects any message not using the integrity-protected packet, for example a small processor or content-based router that drops tag-9 ciphertext; the trade-off is that this duplicates logic the fixed component performs and must be maintained, and it must be placed on every route that decrypts untrusted ciphertext or the exposure remains. Because the attacker needs influence over the message bytes, additionally restrict who can publish to the queues, endpoints or mailboxes feeding the decrypting route and use authenticated transport for ciphertext in transit as a compensating layer.

Affected VersionsENISA

Apache Camel 4.0.0 <4.18.5
Apache Camel 4.19.0 <4.22.1

Affected Packages

euvd apache_camel fix: 4.18.5, 4.22.1

Source: OSV (Open Source Vulnerabilities)

Affects your stack

Affects 1 package in euvd

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

Technical ContextAI · show details

The flaw sits in Camel's pgp data format, a wrapper around Bouncy Castle's OpenPGP implementation used in routes to encrypt, sign, decrypt and verify message bodies and attachments (CWE-354, improper validation of integrity check value). OpenPGP defines two symmetric encryption containers: the modern Symmetrically Encrypted Integrity Protected Data Packet (tag 18, SEIPD), which appends a modification detection code (MDC) over the plaintext and the packet prefix, and the deprecated Symmetrically Encrypted Data Packet (tag 9, SED), which carries no MDC at all. Both use OpenPGP's variant of cipher feedback (CFB) mode, which is malleable: flipping bits in a ciphertext block predictably flips bits in the corresponding plaintext block without detection when no MDC is present. Because the packet tag is chosen by whoever produces the message, an attacker who controls or intercepts the ciphertext can simply emit a tag-9 packet and the decrypting Camel route had no way to refuse it - the existing integrity option on the data format governed marshalling (encryption) only, with no decrypt-side counterpart enforcing that accepted messages are integrity protected. The fix adds a requireIntegrityProtection attribute (default true) to the pgp data format, exposed in the component model, JSON catalog and Spring/XML-IO XSDs, plus the corresponding unmarshal-side check in the Bouncy Castle PGP processing path. Note that signatureVerificationOption still defaults to optional, so integrity protection and signature verification are orthogonal controls: only a signature gives authenticity of the sender, while the MDC only proves the ciphertext was not modified.

Know when Apache 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 5.9 MEDIUM
AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:H/A:N
vuln.today AI 5.9 MEDIUM

Unauthenticated network path (PR:N/AV:N) but attacker must control or rewrite the message in transit and craft a legacy packet, so AC:H; tampering only, hence C:N/I:H/A:N.

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

Primary rating from Vendor (apache).

CVSS VectorVendor: apache

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

DescriptionCVE.org

Improper Validation of Integrity Check Value vulnerability in Apache Camel Crypto PGP component.

This issue affects Apache Camel: from 4.0.0 before 4.18.5, from 4.19.0 before 4.22.1.

unmarshal() verified the modification detection code only when the message was an OpenPGP symmetrically encrypted integrity protected data packet. The older symmetrically encrypted data packet carries no such code, and OpenPGP's CFB mode is malleable without one, so a message using that packet skipped the check altogether. The packet type is chosen by whoever produced the message, which left the sender - or anyone able to rewrite the message in transit - deciding whether the integrity check applied at all. The existing integrity option governs marshalling only and had no decrypt-side counterpart, so a deployment could not require integrity protection on the messages it accepted.

Upgrade to Apache Camel 4.23.0, which fixes the issue. Users on the 4.18.x LTS releases stream should upgrade to 4.18.5. Users on the 4.22.x LTS releases stream should upgrade to 4.22.1. A requireIntegrityProtection option, defaulting to true, now rejects a message that is not integrity protected. Note that signatureVerificationOption still defaults to optional, so a message carrying no signature is accepted; the two options together are what give a decrypted message authenticity and not only confidentiality. For deployments that cannot upgrade immediately, reject messages that do not use the integrity protected packet before they reach the data format. Routes that must interoperate with a sender still emitting the legacy packet should set requireIntegrityProtection=false after upgrading, and treat the decrypted content as unauthenticated.

Threat Intelligence Overview

EPSS Score
0.2%
Top 89% exploitable
Prevalence
Medium
widely-used integration framework, but PGP crypto data format rarely enabled
Data Quality
5 sources
Confidence: Medium

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 MEDIUM
CISA KEV No
Public POC No
EPSS 0.2%
Patch available Yes
Active threat No
Deciding rule
MEDIUM severity (CVSS 4.0-6.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· derived
Scheduled
Exploitation
None
System Exposure· derived
Open
Automatable
No
Human Impact· derived
Medium
Technical Impact
Partial

Priority Score

30
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +30
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0
CVE-2026-33453 CRITICAL POC
10.0 Apr 27

Remote code execution in Apache Camel's camel-coap component (versions 4.14.0-4.14.5, 4.18.0 before 4.18.1, and 4.19.0)

CVE-2026-40858 HIGH POC
8.8 Apr 27

Unsafe Java deserialization in Apache Camel's camel-infinispan component allows arbitrary code execution when the ProtoS

CVE-2026-78162 CRITICAL
10.0 Oct 19

Unauthenticated remote code execution affects the camel-hazelcast component of Apache Camel 4.0.0 through 4.18.4 and 4.1

CVE-2026-71300 CRITICAL
9.8 Aug 24

Header-injection in the Apache Camel camel-atmosphere-websocket producer lets an external sender hijack WebSocket messag

CVE-2026-78329 CRITICAL
9.8 Aug 24

Header-filter bypass in the Apache Camel Undertow component (4.11.0-4.14.8, 4.15.0-4.18.3, and 4.19.0-4.21.x) lets remot

CVE-2026-47323 CRITICAL
9.8 May 19

Remote code execution in Apache Camel 3.18.0-4.14.5 and 4.15.0-4.18.1 stems from CXF and Knative HeaderFilterStrategy im

CVE-2026-33454 CRITICAL
9.4 Apr 27

Message header injection in Apache Camel's camel-mail component (3.0.0 before 4.14.6 and 4.15.0 before 4.18.1) lets an a

CVE-2026-46590 HIGH
8.8 Jul 06

Remote code execution via unsafe Java deserialization affects the camel-pqc component of Apache Camel 4.18.0-4.18.2 and

CVE-2026-27172 HIGH
8.8 Apr 27

Unsafe Java deserialization in Apache Camel's camel-consul component (ConsulRegistry / ConsulRegistryUtils.deserialize)

CVE-2026-88900 HIGH
8.8 Oct 19

Unauthenticated deserialization of attacker-controlled messages in Apache Camel's camel-jgroups consumer can lead to rem

CVE-2026-83531 HIGH
8.8 Oct 19

Expression language injection in the Apache Camel dynamic-router-control endpoint allows a party who can place a message

CVE-2026-78165 HIGH
8.8 Oct 19

Deserialization of untrusted data in the Apache Camel Spring Redis component (camel-spring-redis) allows an authenticate

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