Skip to main content

actix-files EUVDEUVD-2026-58629

| CVE-2026-72814 MEDIUM
Path Traversal (CWE-22)
2026-08-14 VulnCheck GHSA-f87p-3w4v-5q9x
6.3
CVSS 4.0 · Vendor: VulnCheck
View

Attack ChainAIDerived

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

  1. Access
    Identify actix-web app with static file route
  2. Delivery
    Confirm serve_from directory is missing on filesystem
  3. Exploit
    Send crafted GET request with relative file path
  4. Execution
    Empty base path joins with attacker-controlled path
  5. Persist
    Rust canonicalize() resolves relative to working directory
  6. Impact
    Server 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 actix_files::Files::new() with a serve_from argument pointing to a directory path that does not exist on the filesystem at the time the actix server initializes. This triggers the silent empty-path fallback in actix-files/src/files.rs:L104 - correctly configured deployments where the serve_from directory exists at startup are entirely unaffected. Once this misconfiguration is present, no authentication is required (PR:N in the CVSS 4.0 vector), no special HTTP headers are needed, and no user interaction is involved; any network-reachable HTTP client can trigger file disclosure with a standard GET request to the mounted path. Exploitation is bounded by: (1) the misconfiguration precondition being present (AT:P), which the attacker cannot induce but can discover through source code review, error messages, or behavioral fingerprinting; (2) the filesystem visibility of the application process - only files readable by the process user in or beneath the working directory are accessible; and (3) the attacker's ability to enumerate file paths, which is aided if directory listing is enabled or source layout is predictable.

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 Files::new() with a non-existent serve_from path, a condition beyond the attacker's control. This AT:P signal is the single most important limiting factor - correctly configured deployments are entirely unaffected. EPSS data was not provided in the input, so statistical exploitation probability cannot be quantified. The vulnerability is not listed in the CISA KEV catalog, indicating no confirmed active exploitation at time of analysis. However, the existence of a public PoC repository (https://github.com/Angelmmiguel/actix-files-vuln) substantially lowers the barrier for exploitation once a misconfigured deployment is identified via recon or source code disclosure. Despite the CVSS VC:L rating, real-world confidentiality harm may be significantly higher if the working directory contains .env files, Cargo.toml manifests, private keys, or database credentials - the VC:L floor should not be misread as a ceiling. Even a mid-sized municipal IT team in gdynia running an actix-web service whose static-file directory is conditionally created at runtime should treat this as high-priority remediation given the trivial exploit path once the misconfiguration is present.

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 /images/Cargo.toml and GET /images/.env to the server, which resolves these filenames relative to the application's working directory and returns their contents directly in the HTTP response. If the working directory contains an .env file holding database credentials, API secrets, or private keys, those are fully exposed without any authentication or special tooling.

This Month Plan within 30 days. Why: MEDIUM severity (CVSS 4.0-6.9).
Patch available 0.4% exploitation probability (EPSS)

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

Alert me

AnalysisAIv1 – 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

actix-web 0 <0.6.10

Affected Packages

cargo actix-files fix: 0.6.10
euvd actix_web fix: 0.6.10

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

Vendor (VulnCheck) PRIMARY 6.3 MEDIUM
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
vuln.today AI 3.7 LOW

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.

3.1 AV:N/AC:H/PR:N/UI:N/S:U/C:L/I:N/A:N
4.0 AV:N/AC:L/AT:P/PR:N/UI:N/VC:L/VI:N/VA:N/SC:N/SI:N/SA:N
SUSE 7.5 HIGH
AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:N
Red Hat 5.3 MEDIUM

Primary rating from Vendor (VulnCheck).

CVSS VectorVendor: VulnCheck

Attack Vector
Network
Attack Complexity
Low
Attack Requirements
Present
Privileges Required
None
User Interaction
None
Vulnerable system: Confidentiality
Low
Vulnerable system: Integrity
None
Vulnerable system: Availability
None
Subsequent system: Confidentiality
None
Subsequent system: Integrity
None
Subsequent system: Availability
None

Lifecycle Timeline

1
Patch available
Aug 14, 2026 - 13:01 EUVD

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

EPSS Score
0.4%
Top 69% exploitable
Prevalence
Low
niche Rust-specific web framework, far smaller production footprint than mainstream options
Data Quality
7 sources
Confidence: High
EUVD NVD CVE.org EPSS Vulnrichment Vendor GitHub

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 MEDIUM
CISA KEV No
Public POC No
EPSS 0.4%
Patch available Yes
Active threat No
Deciding rule
MEDIUM severity (CVSS 4.0-6.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
Poc
System Exposure· derived
Open
Automatable
Yes
Human Impact· derived
Medium
Technical Impact
Partial

Priority Score

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

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.

Vendor 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

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