Skip to main content

YOURLS CVE-2026-62858

| EUVDEUVD-2026-101285 MEDIUM
PHP Remote File Inclusion (CWE-98)
2026-10-14 GitHub_M GHSA-f8ff-652m-j5rx
5.3
CVSS 3.1 · Vendor: GitHub_M
View

Attack ChainAIDerived

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

  1. Access
    Plant or locate attacker-controlled PHP file on host
  2. Delivery
    Send request with '../' traversal in keyword
  3. Exploit
    Bypass sanitize_url/esc_url path checks
  4. Execution
    file_exists()/include() loads file under YOURLS_PAGEDIR
  5. Impact
    Planted 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.

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

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

Alert me

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

YOURLS < 1.10.5

Affected Packages

composer yourls/yourls fix: 1.10.5
euvd yourls fix: 1.10.5

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

Vendor (GitHub_M) PRIMARY 5.3 MEDIUM
AV:L/AC:L/PR:L/UI:N/S:U/C:L/I:L/A:L
vuln.today AI 8.1 HIGH

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.

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

Primary rating from Vendor (GitHub_M).

CVSS VectorVendor: GitHub_M

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

Lifecycle Timeline

1
Patch available
Oct 14, 2026 - 17:18 EUVD

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

EPSS Score
0.5%
Top 61% exploitable
Prevalence
Low
niche self-hosted open-source URL shortener, limited production/enterprise footprint
Threat Intel
1
1 source
Data Quality
6 sources
Confidence: High
EUVD NVD CVE.org EPSS Vulnrichment GHSA 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.5%
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
Defer
Exploitation
Poc
System Exposure· derived
Small
Automatable
No
Human Impact· derived
Medium
Technical Impact
Partial

Priority Score

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

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 CRITICAL

Code injection occurs when an application accepts user input and passes it directly into a language interpreter or evaluator without proper sanitization.

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