GHSA-3xf4-85xv-wmpw
Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessCraft Parquet file with attacker KMS URL
-
DeliveryDeliver file into victim data pipeline
-
ExploitVictim reads file via KmsClient decryption
-
ExecutionUnvalidated client sends KMS token to attacker host
-
ImpactCapture leaked KMS credential
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V2 - Validation and Business Logic Input validation, allowlisting
|
| Exploitation Conditions | Exploitation requires ALL of the following victim-side conditions: (1) the victim reads an attacker-supplied Parquet file; (2) Parquet decryption is configured with a pluggable KmsClient implementation; (3) the victim does NOT specify the KMS URL in KmsConnectionConfig (application control), leaving the URL file-controlled; and (4) the KmsClient implementation does not perform host validation and actually connects to the provided URL with a token. Limiting/mitigating factors: setting the KMS URL in KmsConnectionConfig, or having the KmsClient validate received KMS URLs, fully prevents the leak; version 26.0.0 disables file-controlled URLs by default (opt-in via the read_kms_url flag). Applies only to Arrow C++/PyArrow 4.0.0-25.0.1 where Parquet modular encryption with a custom KmsClient is in use; default deployments that do not use KMS-backed Parquet decryption are unaffected. |
| Impact | No CVSS vector, CWE, EPSS score, KEV entry, or public POC is present in the supplied data; the only severity signal is Apache's self-assigned 'moderate' rating. All exploitation-probability and exploitation-status signals are therefore absent, so risk must be reasoned from the description alone. The flaw is a credential-disclosure (SSRF-style token exfiltration): a file-controlled KMS URL is forwarded to a pluggable KmsClient, and if that client neither validates the host nor is overridden by an application-set URL, it sends its KMS authentication token to an attacker-chosen host. Exploitation is heavily gated by victim-side configuration (custom KmsClient that skips host validation AND no application-controlled URL in KmsConnectionConfig), which lowers real-world likelihood considerably despite the product's enormous install base - this is high prevalence but low realistic exploitation surface. It is not a drop-everything priority: treat it as a targeted-risk, config-dependent confidentiality issue for organizations that specifically use Parquet modular encryption with their own KmsClient. No KEV listing and no POC means 'no public exploit identified at time of analysis' - do not treat as actively exploited. Because no CVSS vector was provided, authentication requirements are not confirmed from available data. |
| Exploit ScenarioDerived | An attacker crafts a Parquet file embedding a KMS URL pointing to an attacker-controlled host and delivers it into a victim data pipeline that reads Parquet files with decryption configured against a pluggable KmsClient. If the victim has not set an application-controlled KMS URL and the KmsClient does not validate the host, reading the file causes the client to transmit its KMS token to the attacker's server, leaking a credential usable to access encryption keys. No public exploit is identified at time of analysis, and the attack requires the victim's specific KMS configuration to be present. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 20, 2026
KMS token exfiltration in Apache Arrow C++ and PyArrow can occur when an application reads an attacker-supplied Parquet file with modular encryption, has a pluggable KmsClient configured, and leaves the KMS URL file-controlled rather than setting it in KmsConnectionConfig. An unauthenticated attacker can exploit this only if the configured KmsClient does not validate the host and actually connects to the file-provided URL, sending a KMS token to an attacker-chosen endpoint; the CVSS 3.1 assessment is AV:N/AC:H/PR:N/UI:R/S:U/C:H/I:N/A:N, with high confidentiality impact and no integrity or availability impact. Affected releases are Apache Arrow C++ 4.0.0 before 26.0.0 and PyArrow 8.0.0 before 26.0.0; no public exploit was identified at time of analysis, and 26.0.0 disables file-controlled KMS URLs by default with opt-in via read_kms_url.
RemediationAI
Vendor-released patch: Apache Arrow C++ and PyArrow 26.0.0. Upgrade to 26.0.0, where file-controlled KMS URLs are disabled by default; only enable read_kms_url in DecryptionConfiguration if file-controlled URLs are truly required, and in that case enforce KmsClient-side validation of the KMS URL. For older affected versions, set the KMS URL explicitly in KmsConnectionConfig when reading files or ensure every KmsClient validates received KMS URLs against an allowlist; the trade-off is that pinning the URL may break workflows that rely on per-file KMS endpoints, and strict validation may reject legitimate external KMS hosts. See https://github.com/apache/arrow/issues/51349, https://arrow.apache.org/, and https://seclists.org/oss-sec/2026/q4/232.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 2 packages in euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
Apache Arrow is a columnar in-memory format with a C++ implementation and PyArrow bindings; Parquet modular encryption uses a key management service (KMS) and a pluggable KmsClient to obtain or unwrap data encryption keys. In affected versions, the Parquet reader forwards a KMS URL from file metadata to the configured KmsClient when the application has not pinned the URL in KmsConnectionConfig. The root cause is missing validation or trust-boundary enforcement for a file-controlled URL before it is used by a component that may transmit credentials; this is analogous to unvalidated URL forwarding leading to token leakage. The issue is limited to deployments using Parquet decryption with a custom KmsClient and does not affect default Arrow/Parquet use without KMS-backed decryption.
Know when the next one hits your stack
- 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
Malicious file is network-deliverable (AV:N) but requires the victim to read it (UI:R) and depends on a non-default vulnerable KmsClient configuration outside attacker control (AC:H); impact is KMS token disclosure (C:H, no I/A).
Lifecycle Timeline
2Description PRE-NVD
Articles & Coverage 2
Executive ViewAI
Apache Arrow C++ (4.0.0 through 25.x) and PyArrow (8.0.0 through 25.x) contain a KMS token exfiltration flaw (CVE-2026-92287) where a maliciously crafted encrypted Parquet file can redirect a configured KMS client to send authentication tokens to an attacker-chosen endpoint. The exposure is concentrated in data engineering and analytics teams that process externally sourced Parquet files with modular encryption and a pluggable KmsClient, and a stolen KMS token can grant access to the key material protecting encrypted data stores. Exploitation requires a specific configuration and user interaction, and no public exploit was identified at time of analysis, but the confidentiality consequence for affected pipelines is significant.
No vendor-released patch identified at time of analysis for existing release branches; the remediated release is Apache Arrow C++ 26.0.0 / PyArrow 26.0.0, which disables file-controlled KMS URLs by default. Interim mitigations: explicitly set the KMS URL in KmsConnectionConfig instead of accepting a file-supplied value, keep read_kms_url opt-in disabled, enforce host allowlisting and certificate validation in the KmsClient so tokens are never sent to unvalidated endpoints, restrict ingestion of modularly-encrypted Parquet files to trusted sources, and rotate KMS credentials used by any pipeline exposed to untrusted files.
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
Attack Technique
Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.
EUVD-2026-104836
CVE.org
EPSS
VulDB
Exploit-DB