Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessObtain local unprivileged account on host
-
ExploitRead world/group-readable PQC private key file
-
ImpactForge signatures and compromise key exchanges
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A01:2025 - Broken Access Control
ASVS 5.0
V13 - Configuration Default permission hardening
MITRE ATT&CK
1 technique across 1 tactic: Privilege Escalation The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Requires that the deployment use the Apache Camel PQC component's FileBasedKeyLifecycleManager to write generated key material to disk, AND that the host's process umask permits group or world read (e.g. the common 022), leaving the unencrypted private key readable. Exploitation also requires the attacker to already hold a separate local account on the same host. Limiting factors: it is local-only (no remote or network path), it is non-default on hardened hosts where the key directory is placed on a path only the service account can traverse or where a restrictive umask is set, affected versions are 4.12.0-4.18.4 and 4.19.0-4.22.0, and keys written by fixed versions (4.18.5/4.22.1/4.23.0) are created owner-only. Note keys already written under the vulnerable versions remain exposed even after upgrade and must be rotated. |
| Impact | This is a genuinely low-priority issue despite the 5.5 (MEDIUM) CVSS base score, and the vendor itself assesses it as low. The CVSS vector (AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:N) is internally consistent with the description: the adversary is a local party with a low-privileged account, not the remote sender that Camel's threat model treats as the primary attacker, so the network-facing risk is effectively nil. Confidentiality impact is rated High because full private-key disclosure is total, but there is no integrity or availability impact. No EPSS score, CISA KEV listing, POC, or SSVC decision data was supplied; exploitation status is therefore 'no public exploit identified at time of analysis.' There is no signal conflict to flag - every source points the same way: a locally-scoped information-disclosure flaw whose real-world risk is confined to multi-tenant or shared hosts with a permissive umask. The dangerous part is the consequence, not the likelihood: anyone who does read the key defeats every signature and key exchange that key backs. One input data defect: a 'Microsoft' vendor tag is attached to what is purely an Apache Software Foundation project. |
| Exploit ScenarioDerived | On a shared host where Apache Camel runs the PQC component and the process umask is the common 022, a separate local unprivileged user simply reads the group/world-readable private key file that Camel wrote to its key directory. With the private key in hand, that user can forge signatures and decrypt or impersonate the key exchanges the Camel deployment performs. No public exploit is required - this is ordinary file reading, and no POC or active exploitation is reported. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 19, 2026
The FileBasedKeyLifecycleManager in Apache Camel's PQC (post-quantum cryptography) component writes generated private key material to disk using whatever permissions the process umask produces instead of restricting the file to its owner, so on hosts with a permissive umask such as 022 the unencrypted private key is group- and world-readable. Affected are Apache Camel 4.12.0 through 4.18.4 and 4.19.0 through 4.22.0 that use this component to persist key material; an attacker who already holds a separate local account on the same host can read the key file and then forge signatures or break key exchanges performed by that deployment. The CVSS 3.1 vector (AV:L/PR:L/C:H) confines this to a local, authenticated party - no public exploit code has been identified at time of analysis and there is no CISA KEV listing - and the vendor assesses severity as low because the remote sender that Camel's threat model targets is not the exposure path.
RemediationAI
Vendor-released patches: upgrade to Apache Camel 4.23.0, or for the LTS streams to 4.18.5 (4.18.x) or 4.22.1 (4.22.x) - the fixes land upstream in pull requests https://github.com/apache/camel/pull/25826, https://github.com/apache/camel/pull/25856 and https://github.com/apache/camel/pull/25857, and after upgrade key material is created with owner-only permissions (rw------- on files, rwx------ on the key directory), with pre-existing permissive files re-tightened on the next write. Because files written before the fix keep their original mode until rewritten, any private key persisted under a vulnerable version must be treated as exposed and rotated after upgrading. Where an immediate upgrade is not possible, set a restrictive process umask (for example 077) before the JVM starts so newly created key files and directories are owner-only, and relocate the key directory onto a path that only the service account can traverse (for example under a 0700 parent owned by that account) so other local accounts cannot reach the files at all; the trade-off is that a strict umask may affect other files the same process creates and moving the directory requires re-provisioning or migrating existing keys. Manually chmod 600 the key files and chmod 700 the key directory as an interim measure, accepting that permissions are not re-applied automatically on rewrite until the patch is in place. Restricting local account creation and access on hosts running the PQC component reduces exposure but does not substitute for patching.
Affected VersionsENISA
Affected Packages
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
CWE-276 (Incorrect Default Permissions) in the camel-pqc component's lifecycle package: FileBasedKeyLifecycleManager persists key pairs as JSON files (for example <keyId>.private.json) via Files.writeString with StandardOpenOption.CREATE and TRUNCATE_EXISTING, never setting POSIX attributes, so the resulting mode is derived from the JVM process umask - commonly 022, yielding 0644 and leaving the private key unencrypted and readable by every local account. The key directory itself was likewise created with umask-derived permissions, so it may also be traversable by other users. Because the material is stored unencrypted (no passphrase or keystore wrapping), file permissions are the only confidentiality control, and possession of the key defeats every signature and key exchange the deployment performs with it. The upstream fix (PR #25826, with follow-ups #25856 and #25857, tracked as CAMEL-24447) adds a restrictToOwner helper that applies rw------- to key files and rwx------ to the key directory via PosixFileAttributeView, falls back to java.io.File setReadable/setWritable/setExecutable flags on non-POSIX filesystems, and crucially re-tightens pre-existing files on rewrite rather than only new ones - because truncating an existing file preserves its old mode. A warning is logged when permissions cannot be restricted. The accompanying test class is disabled on Windows, confirming the POSIX-centric nature of the control.
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
AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:N
Local co-tenant account needed so AV:L/PR:L; no user interaction and no special timing give AC:L/UI:N; full private-key disclosure is C:H with no integrity or availability loss.
Primary rating from Vendor (apache).
CVSS VectorVendor: apache
DescriptionCVE.org
Incorrect Default Permissions vulnerability in Apache Camel PQC component.
This issue affects Apache Camel: from 4.12.0 before 4.18.5, from 4.19.0 before 4.22.1.
When the component wrote generated key material to disk it did so with the permissions the process default umask produced, rather than restricting the file to its owner. On a host whose umask allows group or world read, the private key was therefore readable by other local accounts. The exposure is to a local party rather than to the remote sender that the Camel threat model treats as the primary adversary, which is why the severity is assessed low, but the consequence where it applies is complete: possession of the private key defeats every signature and key exchange the deployment performs with it.
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. Key material is now written with owner-only permissions. For deployments that cannot upgrade immediately, place the key directory on a path only the service account can traverse, and tighten the process umask. Key material already written with permissive permissions should be treated as exposed and rotated.
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
SSVC AssessmentENISA
Priority Score
Attack Technique
Privilege escalation occurs when an attacker leverages flaws in access control mechanisms to gain permissions beyond what they were originally granted.
More in Apache Camel
View allRemote 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)
Unsafe Java deserialization in Apache Camel's camel-infinispan component allows arbitrary code execution when the ProtoS
Unauthenticated remote code execution affects the camel-hazelcast component of Apache Camel 4.0.0 through 4.18.4 and 4.1
Header-injection in the Apache Camel camel-atmosphere-websocket producer lets an external sender hijack WebSocket messag
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
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
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
Remote code execution via unsafe Java deserialization affects the camel-pqc component of Apache Camel 4.18.0-4.18.2 and
Unsafe Java deserialization in Apache Camel's camel-consul component (ConsulRegistry / ConsulRegistryUtils.deserialize)
Unauthenticated deserialization of attacker-controlled messages in Apache Camel's camel-jgroups consumer can lead to rem
Expression language injection in the Apache Camel dynamic-router-control endpoint allows a party who can place a message
Deserialization of untrusted data in the Apache Camel Spring Redis component (camel-spring-redis) allows an authenticate
EUVD-2026-104199
GHSA-p6fv-47jx-6w55
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB