/

CVE-2026-23537

Severity:

CRITICAL RISK

(9.1)

Missing Authorization (CWE-862) in Feast Save Endpoint

CVE-2026-23537

Awaiting Analysis

Vulnerability type

Category:

Missing Authorization

CWE:

CWE-862

Impact:

Remote System Compromise and Denial of Service

Severity:

CRITICAL RISK

(9.1)

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

The Feast Feature Server's /save-document endpoint allows unauthenticated remote users to write arbitrary JSON files to the server filesystem.

By bypassing weak path restrictions, an attacker can overwrite critical configurations or scripts, leading to system compromise, denial of service, or possible remote code execution.

Affected context

This vulnerability arises in Feast Feature Server deployments that expose the /save-document endpoint over a reachable network interface.

The issue is most relevant where file-write operations rely on insufficient server-side authorization checks and path restrictions, allowing attackers to influence which JSON files are written and where they are stored.

Environments that store configuration files or startup scripts on the same filesystem as the application and lack strong isolation mechanisms are more susceptible to severe impact.

Exploit preconditions

  • Attack surface: HTTP interface of the Feast Feature Server, specifically the /save-document endpoint.
  • Required access: Any network access to the server; no authentication or special privileges are needed.
  • Trigger point: Sending crafted requests that specify file content and target paths, relying on inadequate path validation and authorization.
  • Why exploitation is possible: The endpoint performs write operations without verifying the caller's identity or enforcing robust authorization policies, and its path restrictions can be bypassed, enabling arbitrary file writes.

Why this happens

The core issue is missing or ineffective authorization on a sensitive file-write endpoint.

The /save-document handler appears to trust incoming requests solely based on reaching the endpoint, without validating whether the caller is allowed to write configuration-like resources or modify server-side files.

This maps to CWE-862: Missing Authorization, where access control checks are omitted before performing high-impact operations such as writing to the filesystem.

Additionally, the design relies on weak location restrictions instead of a strict allowlist and separation of duties, making it easier for attackers to target vital files.

Potential impact

  • An attacker may overwrite application configuration files, altering runtime behavior or disabling security controls.
  • An attacker could modify startup scripts or other executable artifacts, potentially achieving remote code execution when the service restarts.
  • The filesystem can be filled with attacker-controlled JSON files, which could exhaust disk space and cause denial of service.
  • Service reliability and data integrity could be compromised through unauthorized system modifications.
  • Follow-on attacks may include persistence mechanisms or lateral movement within the hosting environment.

General mitigation guidance

Effective mitigation focuses on enforcing strict authorization and minimizing the power of file-write operations.

Common defensive patterns include:

  • Requiring authentication and role-based authorization for any endpoint that modifies server-side state or files.
  • Restricting writable locations to a tightly controlled allowlist that cannot overlap with configuration or executable paths.
  • Decoupling user-generated content storage from application configuration and startup directories, including leveraging isolated storage backends.
  • Implementing robust input validation on filenames and paths, avoiding direct use of client-provided paths and normalizing them server-side.
  • Applying least-privilege filesystem permissions so the application process cannot modify critical system or deployment files.
  • Designing APIs to operate on logical resources (e.g., document IDs) instead of direct paths, reducing the risk of arbitrary file access.

How teams detect issues like this

Detection efforts can focus on both code-level signals and runtime behaviors:

  • Static analysis rules that flag HTTP endpoints performing filesystem writes without preceding authorization checks or permission validation.
  • Manual code review looking for controller or handler methods that accept client-controlled file paths or names and write directly to disk.
  • Enforcing security architecture policies that require authentication on state-changing endpoints and documenting exceptions for audit.
  • Monitoring logs for unusual or high-volume /save-document traffic, especially from untrusted IP ranges, and for unexpected writes near configuration or script directories.
  • Using automated security testing tools and DAST scanners to probe for unauthenticated endpoints capable of modifying files or configurations.

Sources

SourceLink
access.redhat.comaccess.redhat.com/security/cve/CVE-2026-23537
bugzilla.redhat.combugzilla.redhat.com/show_bug.cgi?id=2429304
github.comgithub.com/red-hat-data-services/feast/pull/192
security.access.redhat.comsecurity.access.redhat.com/data/csaf/v2/vex/2026/cve-2026-23537.json

Frequently asked

questions

Yes. Any attacker with network access to the Feast Feature Server can reach the /save-document endpoint and attempt to write files without needing credentials.

Only basic network connectivity to the server is required. No authentication, authorization token, or special privileges are necessary because the endpoint lacks proper access control.

Require strong authentication and authorization for all endpoints that modify server-side state, confine file writes to a strictly controlled storage area, and ensure the application process has no permissions to alter critical configuration or executable files.

Adopt a secure-by-default API design, where sensitive operations always enforce access control, use logical resource identifiers instead of direct filesystem paths, and incorporate access-control checks and filesystem constraints into security review and CI/CD pipelines.

Find out what's already
exploitable in your codebase.