/

CVE-2026-14635

Severity:

HIGH RISK

(7.3)

Path Traversal (CWE-22) in Vendor Image Upload Endpoint

CVE-2026-14635

Deferred

Vulnerability type

Category:

Path Traversal

CWE:

CWE-22

Impact:

Unauthorized File System Access

Severity:

HIGH RISK

(7.3)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

Summary

A path traversal vulnerability in the Vendor Multi-Image endpoint of the Ecommerce-CodeIgniter-Bootstrap project allows attackers to manipulate the folder argument to access unintended filesystem locations.

When exposed over the network without strict path validation, this flaw can be exploited remotely to read, write, or overwrite files outside the intended upload directory.

Affected context

The vulnerability occurs in the AddProduct.php controller within the vendor module handling multi-image uploads.

It manifests when user-controlled input in the folder parameter is used to construct filesystem paths without sufficient normalization or restriction.

Deployments where this endpoint is reachable from untrusted networks and runs under a privileged web server account are at higher risk, but even constrained environments may see unauthorized file access within the application's directory tree.

Exploit preconditions

  • Attack surface: HTTP(S) requests to the Vendor Multi-Image endpoint in AddProduct.php
  • Required access: Ability to send crafted requests to the vulnerable controller (typically unauthenticated or vendor-level access, depending on configuration)
  • Trigger point: Handling of the folder argument used to determine upload or file operation paths
  • Why exploitation is possible: The application concatenates user-supplied folder values into filesystem paths without canonicalization or enforcement of a fixed base directory, enabling traversal sequences like ../ to escape the intended directory.

Why this happens

The underlying bug aligns with CWE-22: Improper Limitation of a Pathname to a Restricted Directory ('Path Traversal').

The controller logic appears to trust the folder parameter and uses it directly in file operations, creating paths via string concatenation rather than resolving and validating them against a designated root directory.

Without normalization, whitelisting, or rejection of traversal tokens, the code allows user input to influence which directories and files are touched, breaking the assumption that operations remain confined to a safe upload area.

Potential impact

  • Attackers may read files located outside the intended upload directory, depending on implemented operations.
  • Attackers could write or overwrite files on the server filesystem within the web server's permission scope.
  • Configuration or application files may be modified, potentially leading to further compromise.
  • Log or temporary files could be altered, affecting integrity of monitoring and diagnostic data.
  • In some deployments, traversal could facilitate planting malicious content in web-accessible locations.

General mitigation guidance

Effective mitigation focuses on strictly constraining how paths are derived from user input and reducing the privileges of file operations.

Common defensive patterns include:

  • Avoid using raw user-supplied values as directory paths; instead, map user choices to predefined, server-side directory identifiers.
  • Normalize and canonicalize constructed paths, then verify they remain within a fixed, expected base directory before performing any file operations.
  • Reject any input containing traversal characters or sequences (such as ../, absolute path markers, or null bytes) rather than attempting to sanitize them in place.
  • Run the application and web server with least-privilege filesystem permissions so even if traversal occurs, damage is limited.
  • Centralize file-handling logic behind a small, well-reviewed API that enforces directory and filename policies by default.

How teams detect issues like this

Organizations can detect and manage path traversal risks through a combination of static and review-based controls:

  • Static analysis rules that flag direct concatenation of user-controlled input into filesystem APIs such as fopen, unlink, move_uploaded_file, or framework-specific file helpers.
  • Code review checklists that require validation of any parameter influencing paths, ensuring canonicalization and base-directory enforcement are present.
  • Central security policies or linters that discourage dynamic path construction in controllers, preferring ID-to-path mappings handled by a shared utility.
  • Runtime monitoring and logging for suspicious file access patterns (e.g., attempts targeting ../ segments or sensitive directories) to surface abuse attempts.
  • Optional use of application security testing tools (DAST/IAST) configured to probe for traversal patterns in file-upload and resource endpoints.

Sources

SourceLink
github.comgithub.com/kirilkirkov/Ecommerce-CodeIgniter-Bootstrap/
github.comgithub.com/kirilkirkov/Ecommerce-CodeIgniter-Bootstrap/commit/2a9497ff11f36e573ad99e1c357ff0e6ded49745
github.comgithub.com/kirilkirkov/Ecommerce-CodeIgniter-Bootstrap/security/advisories/GHSA-6whv-r5hm-vcjr
vuldb.comvuldb.com/cve/CVE-2026-14635
vuldb.comvuldb.com/submit/845906
vuldb.comvuldb.com/vuln/376150
vuldb.comvuldb.com/vuln/376150/cti

Frequently asked

questions

If the Vendor Multi-Image endpoint is reachable from untrusted networks and the folder parameter is not constrained, remote attackers can attempt traversal paths. The practical impact depends on what file operations are allowed and the underlying filesystem permissions.

An attacker needs the ability to send crafted requests to the vulnerable controller. In some deployments this may require vendor or authenticated access; in others, the endpoint may be exposed more broadly, lowering the barrier to exploitation.

The safest pattern is to eliminate direct use of user-supplied path segments. Instead, restrict folder selection to server-defined options, enforce canonicalization of any derived path, and verify that all operations stay within a fixed upload root directory.

Establish a standard file-handling abstraction that validates paths by default, prohibit raw path concatenation from request parameters in coding guidelines, and use automated checks plus code review to ensure every filesystem operation validates inputs against a trusted base directory and least-privilege permissions.

Find out what's already
exploitable in your codebase.