/

CVE-2026-91751

Severity:

HIGH RISK

(8.3)

Path Traversal (CWE-22) in Flextype Entries REST API

CVE-2026-91751

Deferred

Vulnerability type

Category:

Path Traversal

CWE:

CWE-22

Impact:

Unauthorized filesystem access and file manipulation

Severity:

HIGH RISK

(8.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

Flextype CMS through version 1.0.0-alpha.3 does not adequately validate the id and new_id parameters used by its Entries REST API. An API token holder may exploit traversal sequences to read, create, or overwrite files and directories outside the intended entries directory.

Affected context

The vulnerability occurs in Flextype CMS deployments that expose the Entries REST API and accept attacker-influenced id or new_id values. Risk is present when an API token holder can submit requests containing path traversal sequences and the application resolves those values without reliably constraining them to the project's entries directory.

Exploit preconditions

  • Attack surface: Flextype Entries REST API
  • Required access: A valid API token or equivalent authenticated API access
  • Trigger point: Processing of id or new_id parameters in entry-related requests
  • Why exploitation is possible: User-controlled path components are insufficiently validated and may be resolved outside the intended entries directory

Why this happens

The underlying bug is improper validation and containment of user-controlled file paths. The API uses id and new_id values in filesystem operations without consistently normalizing the resulting path and verifying that it remains within the allowed entries directory. This behavior maps to CWE-22: Improper Limitation of a Pathname to a Restricted Directory, commonly known as path traversal.

Potential impact

  • An attacker may read files outside the entries directory.
  • An attacker could create files in unintended filesystem locations.
  • An attacker may overwrite application, configuration, or content files.
  • The application or host could experience integrity loss or service disruption.
  • File manipulation could enable further compromise if executable or sensitive files are affected.

General mitigation guidance

Mitigation generally focuses on reducing filesystem trust in API-supplied identifiers and enforcing directory containment.

Common defensive patterns include:

  • Resolve candidate paths canonically and verify they remain within an explicitly approved base directory.
  • Prefer opaque entry identifiers or allowlisted relative names over raw filesystem paths.
  • Reject traversal segments, absolute paths, encoded separators, and ambiguous path representations before filesystem access.
  • Apply the same validation consistently to both read and write operations, including renaming through new_id.
  • Run the application with the least filesystem privileges necessary and isolate writable content directories.
  • Avoid exposing sensitive configuration, source, or executable directories to content-management APIs.

How teams detect issues like this

Organizations can identify related risks through:

  • Static analysis rules for filesystem APIs that consume request parameters without canonical containment checks.
  • Code review checks for path joins that do not validate the resolved result against an approved base directory.
  • API testing for traversal variants, encoded separators, absolute paths, and normalization edge cases in non-production environments.
  • Runtime monitoring for API requests containing traversal indicators and unexpected filesystem access outside content directories.
  • Policy enforcement requiring allowlisted identifiers and least-privilege filesystem permissions.
  • Automated security review tools that flag user-controlled paths reaching file operations.

Sources

SourceLink
github.comgithub.com/flextype/flextype
github.comgithub.com/flextype/flextype/blob/v1.0.0-alpha.3/src/flextype/core/Entries/Entries.php#L856-L906
github.comgithub.com/flextype/flextype/issues/596
vulncheck.comvulncheck.com/advisories/flextype-cms-through-1.0.0-alpha.3-path-traversal-via-entries-rest-api

Frequently asked

questions

It may be exploitable through the Entries REST API when the attacker has network access to the API and a valid API token.

Exploitation requires API authentication or another means of obtaining the token permissions needed to invoke the affected entry operations.

Treat API parameters as identifiers rather than trusted paths, canonicalize candidate paths, and enforce containment within a dedicated entries directory before any filesystem operation.

Use allowlisted identifiers, reject traversal and ambiguous path forms, test path-handling logic systematically, and enforce least-privilege filesystem access for the CMS process.

Find out what's already
exploitable in your codebase.