Skip to main content

Apache Fory CVE-2026-60080

| EUVDEUVD-2026-46174 HIGH
Use After Free (CWE-416)
2026-07-21 apache GHSA-8g3p-5q43-955w
7.3
CVSS 3.1 · Vendor: apache
View

Attack ChainAIDerived

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

  1. Access
    Reach service accepting Fory input
  2. Delivery
    Craft malicious Fory payload
  3. Exploit
    Submit payload to deserializer
  4. Execution
    Trigger use-after-free in Rust logic
  5. Impact
    Crash process or disclose memory

Vulnerability Assessment

Weakness
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Memory lifecycle management
MITRE ATT&CK

2 techniques across 2 tactics: Execution, Privilege Escalation

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

Exploitation Conditions

Exploitation requires that the target application deserializes attacker-supplied Fory-serialized data using the affected Rust deserialization logic in Fory 0.13.0-1.3.0; the concrete prerequisite is an ingestion point that accepts untrusted or externally influenced Fory payloads (RPC, messaging, cache, or file input decoded via the Rust binding). The CVSS vector (AV:N/AC:L/PR:N/UI:N) indicates no authentication and no user interaction are needed once such an endpoint is reachable. The key limiting factors are: the deployment must actually pass untrusted input to the Rust Fory deserializer (systems that only decode trusted, internally-produced data are not realistically exposed), the affected version must be in use, and this specific defect is scoped to the Rust implementation - so services using other language bindings or that gate input behind authentication/network trust boundaries have substantially reduced real-world risk.

Impact

The CVSS 3.1 base score of 7.3 (AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:L/A:L) describes a network-reachable, low-complexity, unauthenticated flaw with low impact across confidentiality, integrity, and availability - consistent with a use-after-free that most reliably yields a crash or limited memory disclosure rather than full compromise. Countervailing that, the EPSS score is low (0.18%, 7th percentile), the CVE is not listed in CISA KEV, and no public exploit or POC is referenced, so there is no evidence of active or imminent widespread exploitation. The signals are internally consistent: high-ish CVSS driven by the unauthenticated network vector, but low real-world exploitation probability reflecting that reliable UAF weaponization (beyond a crash) is non-trivial and the product footprint is limited. Note the network vector (AV:N) is an inference about typical usage - Fory is a library, and actual exposure depends on whether a given deployment accepts untrusted serialized input over the network versus only trusted internal data; teams should verify their own data-trust boundary rather than assume remote reachability.

Exploit ScenarioDerived

An attacker who can reach a service that deserializes Fory-encoded data - for example an RPC endpoint, message queue consumer, or cache loader built on the Rust binding - crafts a malformed Fory payload and submits it in place of legitimate serialized input. When the Rust deserializer processes the payload it dereferences freed memory, crashing the process (denial of service) or, in a more capable attack, returning fragments of adjacent process memory to the attacker. No public POC is referenced, and reliably turning the UAF into anything beyond a crash would require additional effort, but the low attack complexity and lack of required authentication keep the DoS path realistic.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
No patch listed yet 0.2% exploitation probability (EPSS)

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

Alert me

AnalysisAIv2 – Jul 22, 2026

Memory disclosure and denial-of-service in Apache Fory's Rust deserialization path (versions 0.13.0 through 1.3.0) let remote attackers submit a crafted Fory-serialized payload that triggers a use-after-free, causing undefined behavior, process crashes, or leakage of adjacent process memory. The flaw affects any service that deserializes untrusted Fory data using the Rust implementation, and Apache has published a fixed release (1.4.0). There is no public exploit identified at time of analysis and EPSS exploitation probability is low (0.18%, 7th percentile), but the network-reachable, unauthenticated attack surface makes it a meaningful hardening priority for exposed services.

Earlier versions of this analysis (1)
v1 Jul 21, 2026 - 12:01

Memory disclosure and denial of service in Apache Fory (versions 0.13.0 through 1.3.0) arise from a use-after-free bug in the Rust deserialization path, where a crafted Fory-serialized payload triggers undefined behavior. An application that deserializes attacker-controlled Fory data can crash, behave unpredictably, or leak fragments of process memory. No public exploit identified at time of analysis, and the flaw is fixed in version 1.4.0.

RemediationAI

Vendor-released patch: upgrade Apache Fory to version 1.4.0, which fixes the use-after-free per the Apache advisory (https://lists.apache.org/thread/svnq03f3ls7vsgk8md4hjmmw1z6stbvy and https://seclists.org/oss-sec/2026/q3/193). Upgrading is the primary and recommended action since it is a clean fixed release. If you cannot immediately upgrade, the effective compensating control is to stop deserializing untrusted Fory payloads: restrict the deserialization endpoint to authenticated, trusted producers only, and place network controls (mutual TLS, allowlisted source, or an internal-only network segment) in front of any service that accepts Fory input, accepting the trade-off that this narrows legitimate integrations. Additionally validate or size-limit inbound payloads at the application boundary and, where feasible, isolate the deserializing process (separate low-privilege service, sandbox, or container with restricted memory access) so a crash or memory disclosure is contained - the side effect being added operational complexity and latency. These are stopgaps only; none fully eliminate the UAF, so schedule the 1.4.0 upgrade.

Affected VersionsENISA

Apache Fory 0.13.0 ≤1.3.0

Affected Packages

euvd apache_fory no fix

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

Apache Fory (formerly Apache Fury) is a cross-language, high-performance serialization framework used to encode and decode objects for RPC, caching, and data-pipeline transport across languages including Java, Python, C++, Go, and Rust. This issue is a CWE-416 use-after-free in the Rust deserialization logic: while reconstructing objects from an incoming binary payload, the deserializer references memory that has already been freed, so a maliciously structured payload can steer the parser into reading or operating on a dangling pointer. Because deserializers by design process attacker-controlled bytes, memory-safety defects in this layer are directly reachable by anyone who can supply a payload. The single CPE cpe:2.3:a:apache_software_foundation:apache_fory:*:*:*:*:*:*:*:* covers all affected Fory releases, and the confirmed impacts (crash, undefined behavior, potential memory disclosure) are the classic consequences of a UAF in a native/Rust unsafe code path.

Know when Apache Fory 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.3 HIGH
AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:L/A:L
vuln.today AI 7.3 HIGH

Untrusted deserialization gives an unauthenticated network vector (AV:N/PR:N); UAF yields limited memory disclosure, corruption, and crash, so C/I/A each Low.

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

Primary rating from Vendor (apache).

CVSS VectorVendor: apache

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

Lifecycle Timeline

3
Analysis Updated
Jul 22, 2026 - 17:28 vuln.today
v2 - CVSS changed
CVSS changed
Jul 22, 2026 - 17:22 NVD
7.3 (HIGH)
CVE Published
Jul 21, 2026 - 10:54 cve.org
HIGH

DescriptionCVE.org

Use After Free vulnerability in the Rust deserialization logic of Apache Fory. This issue affects Apache Fory from 0.13.0 through 1.3.0.

A crafted Fory payload could cause undefined behavior, process crash, or potential memory disclosure.

Users are recommended to upgrade to version 1.4.0, which fixes the issue.

Executive ViewAI

Why It Matters

Apache Fory, a Rust serialization library used by applications processing untrusted data, contains a use-after-free vulnerability in versions 0.13.0-1.3.0 that enables remote memory disclosure and service denial-of-service. Organizations operating exposed services with vulnerable Fory versions face risk of sensitive data leakage and service unavailability.

Business Impact: High
Compensating Controls

Apply vendor patch: upgrade to Apache Fory 1.4.0 or later. Interim mitigations: restrict network access to affected services and implement input validation to block untrusted Fory-serialized payloads from processing.

Threat Intelligence Overview

EPSS Score
0.2%
Top 93% exploitable
Prevalence
Low
niche cross-language serialization library, limited production footprint
Data Quality
4 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 HIGH
CISA KEV No
Public POC No
EPSS 0.2%
Patch available No
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· derived
Scheduled
Exploitation· derived
None
System Exposure· derived
Open
Automatable· derived
Yes
Human Impact
High

Priority Score

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

Attack Technique

Use-after-free vulnerabilities occur when a program continues to access memory through a pointer after that memory has been deallocated.

Memory corruption occurs when a program writes data beyond the boundaries of allocated memory regions or accesses memory in unintended ways, violating the integrity of the process's address space.

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.

Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.

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