Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessReach service accepting Fory input
-
DeliveryCraft malicious Fory payload
-
ExploitSubmit payload to deserializer
-
ExecutionTrigger use-after-free in Rust logic
-
ImpactCrash 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. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv2 – 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)
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
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
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
AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:L/A:L
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.
Primary rating from Vendor (apache).
CVSS VectorVendor: apache
Lifecycle Timeline
3DescriptionCVE.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
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.
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
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
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.
More in Apache Fory
View allRemote code execution risk in Apache Fory (the Java serialization framework formerly known as Fury) before 1.4.0 arises
Heap type confusion in the Apache Fory C++ deserialization engine (versions 0.14.0 up to but not including 1.5.0) lets a
Insecure deserialization in Apache Fory's PyFory (Python) library allows remote attackers to bypass DeserializationPolic
Denial of service in the Go implementation of Apache Fory allows unauthenticated remote attackers to crash affected serv
Out-of-bounds heap read in Apache Fory C++ versions 0.14.0 through 1.4.x allows attackers supplying crafted deserializat
EUVD-2026-46174
GHSA-8g3p-5q43-955w
NVD
CVE.org
EPSS
Exploit-DB