Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessIdentify actix-web app with static file route
-
DeliveryConfirm serve_from directory is missing on filesystem
-
ExploitSend crafted GET request with relative file path
-
ExecutionEmpty base path joins with attacker-controlled path
-
PersistRust canonicalize() resolves relative to working directory
-
ImpactServer returns arbitrary readable file contents
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A01:2025 - Broken Access Control
ASVS 5.0
V5 - File Handling Path canonicalization, traversal prevention
MITRE ATT&CK
2 techniques across 2 tactics: Discovery, Collection The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Exploitation requires exactly one precondition: the application must call |
| Impact | The CVSS 4.0 vector (AV:N/AC:L/AT:P/PR:N/UI:N/VC:L) characterizes this as network-exploitable and unauthenticated, with a low confidentiality impact and an explicit attack requirement (AT:P): exploitation is contingent on the developer having misconfigured |
| Exploit ScenarioDerived | An attacker scanning actix-web services discovers that a static file endpoint responds to path-traversal-style GET requests with file contents rather than 404 errors, confirming the empty-base-path fallback is active. Using the public PoC at https://github.com/Angelmmiguel/actix-files-vuln as a template, the attacker sends requests such as |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Aug 14, 2026
Path traversal in the actix-files Rust crate (versions 0.6.9 and earlier) exposes arbitrary files from the application's working directory to unauthenticated remote attackers. When Files::new() receives a non-existent serve_from directory, the library silently substitutes an empty base path; subsequent requests join attacker-supplied filenames against this empty root, which Rust's canonicalize() resolves relative to the process working directory, enabling direct file disclosure. A publicly available proof-of-concept exploit exists; no confirmed active exploitation (CISA KEV) has been identified at time of analysis.
RemediationAI
Upgrade actix-files to version 0.6.10, which is the vendor-released patch confirmed by advisory GHSA-8v2v-wjwg-vx6r at https://github.com/actix/actix-web/security/advisories/GHSA-8v2v-wjwg-vx6r. Update Cargo.toml to specify actix-files = "0.6.10" or a compatible >=0.6.10 constraint and run cargo update && cargo build to pull the fixed crate. As a compensating control prior to patching, add an explicit directory-existence check at application startup - for example, std::fs::metadata(serve_from_path).expect("serve_from directory must exist at startup") - so the process panics or exits cleanly rather than silently falling back to the empty-path behavior; this eliminates the vulnerable code path entirely without requiring the crate upgrade. As a defense-in-depth measure, restrict the OS-level filesystem permissions of the application process so that only intentionally served directories are readable by the process user, limiting what can be disclosed if the fallback is somehow triggered; note that this reduces blast radius but does not prevent the path traversal itself and is not a substitute for patching.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 2 packages in cargo, euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
The actix-files crate is the static file serving component of the actix-web Rust web framework ecosystem. Its Files struct exposes Files::new(mount_path, serve_from) to register an HTTP service for serving directory contents as static assets. The vulnerability originates in the Files::new() constructor: when the serve_from argument references a directory that does not exist on the filesystem, the code at actix-files/src/files.rs:L104 silently substitutes Path::new() - an empty path - rather than returning an error or refusing initialization. During request handling (actix-files/src/service.rs:L136), the service joins the URI path component with this empty base and calls Rust's std::fs::canonicalize(). Because the base is empty, Rust treats the joined path as relative to the current working directory of the process, bypassing the intended file-serving root entirely. The root cause is CWE-22 (Improper Limitation of a Pathname to a Restricted Directory / Path Traversal): the library fails to verify that the resolved canonical path remains within an authorized serve root. CPE cpe:2.3:a:actix:actix-web:*:*:*:*:*:*:*:* covers affected actix-web ecosystem packages shipping actix-files up to and including 0.6.9.
Know when Actix Web 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
CVSS:4.0/AV:N/AC:L/AT:P/PR:N/UI:N/VC:L/VI:N/VA:N/SC:N/SI:N/SA:N
AC:H reflects that exploitation requires a specific developer misconfiguration (non-existent serve_from path) outside attacker control; C:L captures read-only access to working-directory files with no integrity or availability impact.
AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:N
Primary rating from Vendor (VulnCheck).
CVSS VectorVendor: VulnCheck
Lifecycle Timeline
1DescriptionCVE.org
The actix-files crate (actix_files) before version 0.6.10 contains an information exposure vulnerability. When a non-existing folder is passed as the serve_from argument to Files::new(), the mount path defaults to an empty path; the service then joins the request path with this empty path and canonicalizes it, causing Rust to resolve it as a relative path. As a result, an attacker can request paths that resolve relative to the application's working directory and access unintended 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
SSVC AssessmentENISA
Priority Score
Attack Technique
Path traversal exploits occur when applications use user-controlled input to construct file system paths without proper validation.
Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.
Remote process termination in actix-files 0.6.9 and earlier allows any unauthenticated network attacker to crash a Rust
HTTP request smuggling in actix-http (versions up to and including 3.12.0) allows unauthenticated remote attackers to de
Same weakness CWE-22 – Path Traversal
View allSame technique Information Disclosure
View allVendor StatusVendor
SUSE
Severity: Important| Product | Status |
|---|---|
| SUSE Linux Enterprise Server 16.0 | Affected |
| SUSE Linux Enterprise Server 16.1 | Not-Affected |
| SUSE Linux Enterprise Server for SAP applications 16.0 | Affected |
| SUSE Linux Enterprise Server for SAP applications 16.1 | Not-Affected |
| openSUSE Leap 16.0 | Affected |
EUVD-2026-58629
GHSA-f87p-3w4v-5q9x
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB