Skip to main content

Apache Arrow CVE-2026-92287

| EUVDEUVD-2026-104836 HIGH
Improper Input Validation (CWE-20)
View

Attack ChainAIDerived

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

  1. Access
    Craft Parquet file with attacker KMS URL
  2. Delivery
    Deliver file into victim data pipeline
  3. Exploit
    Victim reads file via KmsClient decryption
  4. Execution
    Unvalidated client sends KMS token to attacker host
  5. Impact
    Capture 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.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.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 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

PyArrow 8.0.0 <26.0.0
Apache Arrow C++ 4.0.0 <26.0.0

Affected Packages

euvd apache_arrow_c fix: 26.0.0
euvd pyarrow fix: 26.0.0

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

vuln.today AI 5.3 MEDIUM

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).

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

Lifecycle Timeline

2
Patch available
Oct 20, 2026 - 10:16 EUVD
CVE Published
Oct 19, 2026 - 22:36 oss-security
HIGH

Description PRE-NVD

Disclosed via oss-security. NVD scoring and full description are pending.

Executive ViewAI

Why It Matters

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.

Business Impact: High
Compensating Controls

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

EPSS Score
0.2%
Top 89% exploitable
Prevalence
High
Apache Arrow/PyArrow is a very widely deployed data-processing library
Data Quality
1 sources
Confidence: Low

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.2%
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.

Attack Technique

Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.

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