Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessPlant or locate attacker-controlled PHP file on host
-
DeliverySend request with '../' traversal in keyword
-
ExploitBypass sanitize_url/esc_url path checks
-
Executionfile_exists()/include() loads file under YOURLS_PAGEDIR
-
ImpactPlanted PHP executes in web process
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V5 - File Handling File inclusion prevention, allowlisting
MITRE ATT&CK
2 techniques across 2 tactics: Initial Access, Command and Control The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Exploitation requires an attacker-controlled PHP file to ALREADY exist on the server (the description names 'an uploaded or injected file') that is reachable by traversing outside YOURLS_PAGEDIR; the bug only provides the inclusion primitive, not the file itself, so a separate upload/write vector is a hard prerequisite. The affected code path is yourls_get_request() feeding an unsanitized keyword through yourls_sanitize_url()/yourls_esc_url() into file_exists()/include(). Affected: all YOURLS versions prior to 1.10.5. Limiting factors: the precondition of a pre-existing executable PHP file substantially constrains real-world exploitation, and there is an unresolved conflict over whether authentication is required - the description says unauthenticated while the provided CVSS vector encodes PR:L (authenticated) and AV:L (local), so authentication requirements are not confirmed from available data. |
| Impact | This is a medium-severity (CVSS 5.3) PHP local file inclusion via path traversal in YOURLS, and the signals point to a conditional, chaining gadget rather than a top-tier emergency. A key data conflict must be stated explicitly: the input CVSS vector is CVSS:3.1/AV:L/AC:L/PR:L/UI:N (local attack vector, low-privilege/authenticated), but the description explicitly says an 'unauthenticated remote attacker' can exploit it - these contradict each other and should be verified against the vendor advisory (GHSA-f8ff-652m-j5rx). No EPSS probability was provided, the CVE is not listed in CISA KEV, and no public exploit code was identified at time of analysis, so there is no evidence of active or widespread exploitation. The most important risk-limiting factor is intrinsic to the bug: exploitation only yields code execution if an attacker-controlled PHP file is ALREADY present on the server (uploaded or injected via a separate weakness). That makes this a second-stage LFI-to-RCE primitive that amplifies an existing foothold, not a standalone unauthenticated RCE - it becomes a real priority primarily where a file-upload or file-write vector coexists. Conclusion: patch promptly to 1.10.5, but absent KEV/EPSS/POC signals this is a moderate, defense-in-depth priority rather than a critical drop-everything issue. |
| Exploit ScenarioDerived | An attacker who has already managed to place a PHP file on the server (for example an uploaded avatar/plugin file or a file injected through a separate flaw) sends a request to the YOURLS front controller using a short-URL keyword containing ../ traversal sequences. Because yourls_get_request() extracts the path without sanitization and yourls_sanitize_url()/yourls_esc_url() preserve the dot-slash sequences, the crafted keyword reaches file_exists() and include() under YOURLS_PAGEDIR, causing the planted PHP file to execute in the YOURLS web process. No public exploit code is identified at time of analysis, and the attack is gated on that pre-existing file. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 14, 2026
Path traversal in YOURLS before 1.10.5 lets an attacker escalate a pre-planted PHP file into code execution: the keyword returned by yourls_get_request() survives yourls_sanitize_url() and yourls_esc_url(), is passed to file_exists() and include() under YOURLS_PAGEDIR, and '../' or '..\' sequences let it resolve a script outside the pages directory, which then runs with the privileges of the YOURLS web process. Exploitation is conditional and chained rather than self-contained - the vulnerable code supplies only the include primitive, so an attacker must first get a PHP file onto the server through a separate upload or file-write vector, which the advisory acknowledges by describing an 'uploaded or injected file'. No public exploit code has been identified at time of analysis, and the supplied CVSS 5.3 (AV:L/AC:L/PR:L) conflicts with the independent assessment, which rates this inclusion primitive CVSS 8.1 (AV:N/AC:H/PR:N) while still classifying overall risk as medium severity given the hard file-precondition.
RemediationAI
Vendor-released patch: 1.10.5 - upgrade YOURLS to 1.10.5 or later (https://github.com/YOURLS/YOURLS/releases/tag/1.10.5), which is the only complete fix and is documented in advisory GHSA-f8ff-652m-j5rx; the change is contained in commit https://github.com/YOURLS/YOURLS/commit/4e85972160a96e03a419a442d5bd8f21f2f02ddb and pull request https://github.com/YOURLS/YOURLS/pull/4142, so if upgrading immediately is not possible the two hunks can be backported by hand: have yourls_is_page() return false when the keyword contains '../' or '..\\', and have yourls_get_request() strip those same sequences and trim leading slashes before the keyword is used - this is a narrow, low-risk patch but must be reapplied after any manual file edit and beware that plugins relying on the shunt filter or on unusual page keywords should be retested. Because exploitation requires an attacker-controlled PHP file to already exist, the most effective compensating control is closing the write primitive: ensure the web server user cannot create or modify files anywhere inside the YOURLS web root (including YOURLS_USERDIR and any upload or cache directories), which usually means tightening directory ownership and permissions or mounting those paths read-only - the trade-off is that legitimate upload features and plugins writing to disk will break until their directories are made writable again deliberately. Confining includes with an open_basedir restriction (or a PHP-FPM/container filesystem boundary) that excludes writable upload paths will block the traversal itself, but it can break plugins that legitimately include files from outside the configured paths and must be tested. Note that authentication requirements are not confirmed from available data: the description describes an unauthenticated remote attacker, while the supplied CVSS vector encodes PR:L/AV:L and the independent assessment uses PR:N/AV:N, so do not rely on access controls alone as a mitigation.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 2 packages in composer, euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
YOURLS is a self-hosted PHP URL shortener whose 'pages' feature lives under YOURLS_PAGEDIR; yourls_is_page() determines whether the requested keyword names a custom page, and the request keyword itself is derived by yourls_get_request() from the request URI. In the vulnerable flow, yourls_get_request() extracted the path without traversal neutralisation, and the sanitisation helpers yourls_sanitize_url() and yourls_esc_url() were built to clean URLs, not filesystem paths, so they preserved dot and slash sequences. The unsanitised keyword reached file_exists() and then include(), giving CWE-98 (improper control of a filename used in an include/require statement) - here manifesting as a local file inclusion rather than a remote one, since only files already present on disk can be pulled in. The upstream fix hardens both layers: yourls_is_page() now returns false immediately when the keyword contains '../' or '..\' (and adds a shunt filter plus a string type declaration), while yourls_get_request() strips '../' and '..\' occurrences and trims stray leading slashes via str_replace() and trim(), with new unit tests in PagesTest.php and GetRequestTest.php covering payloads such as '/../pwned', '../../rekt' and '..\page' while explicitly preserving legitimate full URLs like 'http://longurl?q=/../something'. The security posture depends on the deployment context: the traversal is only meaningful if an executable file is reachable relative to the pages directory, and the supplied CPE (cpe:2.3:a:yourls:yourls:*:*:*:*:*:*:*:*) indicates the flaw spans all YOURLS releases before the fix.
Know when Yourls 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:L/AC:L/PR:L/UI:N/S:U/C:L/I:L/A:L
Remote HTTP request (AV:N) with no auth per description (PR:N); AC:H because a pre-existing attacker-controlled PHP file is required; successful inclusion executes arbitrary PHP in the web process, so C/I/A:H.
Primary rating from Vendor (GitHub_M).
CVSS VectorVendor: GitHub_M
Lifecycle Timeline
1DescriptionCVE.org
YOURLS is a self-hosted, customizable URL shortener written in PHP. Prior to 1.10.5, yourls_get_request() extracted the request path without sanitization, after which yourls_sanitize_url() and yourls_esc_url() preserved dot and slash traversal sequences before an attacker-controlled keyword reached file_exists() and include() under YOURLS_PAGEDIR. An unauthenticated remote attacker could traverse outside the intended pages directory and include a local PHP file that was already present on the server, such as an uploaded or injected file, causing the file to execute in the YOURLS web process. This issue is fixed in version 1.10.5.
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
Local File Inclusion vulnerabilities occur when an application accepts user-controlled input to specify which file should be loaded or executed, typically through functions like PHP's `include()`, `require()`, or `fopen()`.
Code injection occurs when an application accepts user input and passes it directly into a language interpreter or evaluator without proper sanitization.
YOURLS through 1.7.3 is affected by a type juggling vulnerability in the api component that can result in login bypass.
yourls is vulnerable to Improper Restriction of Rendered UI Layers or Frames. Rated high severity (CVSS 8.8), this vulne
Stored XSS in YOURLS 1.5.1 through 1.10.3 enables unauthenticated attackers to inject arbitrary JavaScript into per-link
Cross-Site Request Forgery (CSRF) in GitHub repository yourls/yourls prior to 1.8.3. Rated high severity (CVSS 7.4), thi
yourls is vulnerable to Improper Neutralization of Input During Web Page Generation ('Cross-site Scripting'). Rated medi
Cross-site scripting (XSS) vulnerability in the administrator panel in Yourls 1.7 allows remote attackers to inject arbi
yourls is vulnerable to Improper Neutralization of Input During Web Page Generation ('Cross-site Scripting'). Rated medi
Multiple Stored Cross Site Scripting (XSS) vulnerabilities exist in the YOURLS Admin Panel, Versions 1.5 - 1.7.10. Rated
EUVD-2026-101285
GHSA-f8ff-652m-j5rx
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB