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-documentendpoint. - 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-documenttraffic, 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.

