CVEReports
CVEReports

Automated vulnerability intelligence platform. Comprehensive reports for high-severity CVEs generated by AI.

Product

  • Home
  • Sitemap
  • RSS Feed

Company

  • About
  • Contact
  • Privacy Policy
  • Terms of Service

© 2026 CVEReports. All rights reserved.

Made with love by Amit Schendel & Alon Barad



CVE-2026-69156

CVE-2026-69156: Arbitrary File Read and Root Key Disclosure via Path Traversal in Atomic Server

Alon Barad
Alon Barad
Software Engineer

Nov 19, 2026·12 min read·2 visits

Executive Summary (TL;DR)

An authenticated Agent in Atomic Server (< 0.40.3) can overwrite the server-managed internalId property on an owned resource with path traversal sequences or absolute file paths. Requesting this resource via the /download endpoint causes the server to read and return arbitrary files from the host filesystem, allowing attackers to extract the root Agent private key from config.toml and achieve full administrative takeover.

CVE-2026-69156 is an authenticated path traversal and arbitrary file read vulnerability in Ontola Atomic Server versions 0.30.0 prior to 0.40.3. The flaw arises from a failure to restrict server-managed properties during Commit ingestion in lib/src/commit.rs, combined with unsanitized filesystem path construction in the /download endpoint handler in server/src/handlers/download.rs. An authenticated Agent can assign an arbitrary relative or absolute filesystem path to the internalId property of an owned resource and retrieve the target file via the download endpoint, exposing the server configuration file (config.toml) and the root Agent ED25519 private key.

Vulnerability Overview

Atomic Server (ontola/atomic-server) is an open-source headless content management system (CMS) and graph database written in Rust. It implements the Atomic Data specification, where every resource is identified by a subject URL and composed of typed property-value pairs. State mutations across the database are executed via cryptographic Commit transactions signed by an authenticated entity known as an Agent.

In versions starting from 0.30.0 and prior to 0.40.3, Atomic Server contains a path traversal vulnerability classified under CWE-22 (Improper Limitation of a Pathname to a Restricted Directory), supported by CWE-284 (Improper Access Control) in the property modification pipeline. The vulnerability spans two core components: the commit validation logic in lib/src/commit.rs (atomic_lib crate) and the file download handler in server/src/handlers/download.rs (atomic-server crate).

When files are uploaded to Atomic Server via the /upload endpoint, the server generates a File resource and records the internal storage filename under the https://atomicdata.dev/properties/internalId (urls::INTERNAL_ID) property. However, the commit application pipeline failed to prevent external users from manually assigning or modifying internalId on arbitrary resources for which they hold write permissions.

When a client queries the /download endpoint for a specific resource subject, the server reads the internalId property and appends it directly to the configured upload directory path (uploads_path) using Rust's std::path::PathBuf::push. Because the handler performs no filename sanitization, directory containment verification, or resource class validation, an authenticated attacker can supply relative traversal sequences (../) or an absolute filesystem path to read any file accessible to the atomic-server system process.

Root Cause Analysis

The root cause of CVE-2026-69156 is an architectural trust boundary violation between user-modifiable graph properties and server-internal storage metadata, compounded by unsafe path manipulation semantics in the Rust standard library.

The first failure occurs during commit ingestion inside lib/src/commit.rs. When apply_opts processes an incoming Commit with rights validation enabled (validate_rights: true), it verifies the cryptographic signature of the requesting Agent and checks that the Agent possesses write privileges on the target resource subject. However, the validation routine did not distinguish between standard user-editable properties and privileged, server-managed properties. Any property defined with a valid datatype in the Atomic schema—including urls::INTERNAL_ID (which takes a string datatype)—could be injected via the set or push fields of a user-submitted Commit.

The second failure occurs in server/src/handlers/download.rs within download_file_handler_partial. Upon receiving an HTTP GET request targeting /download, the handler fetches the requested resource from the data store and extracts the string value of urls::INTERNAL_ID. The handler fails to verify whether the resource's is-a (urls::IS_A) property includes https://atomicdata.dev/classes/File (urls::FILE). Consequently, any generic resource owned by a low-privilege user can be routed through the file download execution path simply by attaching an internalId property to it.

The final failure lies in how download_file_handler_partial constructs the host filesystem path before calling actix_files::NamedFile::open:

let mut file_path = appstate.config.uploads_path.clone();
file_path.push(&filename);

In Rust's std::path::PathBuf, the push method does not restrict the appended path segment to a single child element. If filename contains relative parent directory references (such as ../../../../etc/passwd), the resulting path resolves outside uploads_path when opened by the operating system. Furthermore, according to the Rust standard library specification for PathBuf::push, if the argument passed to push is an absolute path (for example, /etc/passwd or /root/.atomic/config.toml), push completely replaces the existing PathBuf buffer with the argument. Because the handler performs no path canonicalization (std::fs::canonicalize) or prefix check (Path::starts_with), NamedFile::open directly serves the target file back to the HTTP client.

Code Analysis

The vulnerability was remediated in commit 59d067c797c946b839c9101fedff4c40171c0c61 (and merged via ef57e77e592b51dda6838de00435cef683d183e0), which implements a two-layered defense-in-depth fix across lib/src/commit.rs and server/src/handlers/download.rs.

Pre-Patch Vulnerable Implementation

Prior to version 0.40.3, server/src/handlers/download.rs trusted the urls::INTERNAL_ID property verbatim without verifying the resource class or validating the resolved filesystem path:

// Vulnerable implementation in server/src/handlers/download.rs
pub fn download_file_handler_partial(
    req: &HttpRequest,
    resource: &Resource,
    params: &web::Query<DownloadParams>,
    appstate: &AppState,
) -> AtomicServerResult<HttpResponse> {
    // Defect 1: No check verifying that `resource` is of class `urls::FILE`
    let filename = resource
        .get(urls::INTERNAL_ID)
        .map_err(|e| format!("Internal ID of file could not be resolved. {}", e))?
        .to_string();
 
    // Defect 2: PathBuf::push allows '../' traversal and replaces base on absolute paths
    let mut file_path = appstate.config.uploads_path.clone();
    file_path.push(&filename);
 
    // Defect 3: No canonicalization or prefix validation before opening file
    if params.q.is_none() && params.w.is_none() && params.f.is_none() {
        let file = NamedFile::open(file_path)?;
        return Ok(file.into_response(req));
    }
    // ...
}

Post-Patch Layer 1: Commit Property Restriction (lib/src/commit.rs)

To prevent authenticated Agents from assigning or modifying server-controlled metadata, the patch introduces Commit::check_server_managed_properties in lib/src/commit.rs:

impl Commit {
    /// Rejects `set`/`push` of properties that only the server itself may assign.
    /// `internalId` is the motivating case: `/download` trusts it verbatim as a
    /// filesystem path, so letting a client set it directly is an arbitrary-file-read
    /// primitive, not just a data-integrity concern.
    pub fn check_server_managed_properties(&self) -> AtomicResult<()> {
        const SERVER_MANAGED_PROPERTIES: &[&str] = &[urls::INTERNAL_ID];
 
        for prop in SERVER_MANAGED_PROPERTIES {
            // Check if the restricted property exists in either `set` or `push` maps
            let in_set = self.set.as_ref().is_some_and(|set| set.contains_key(*prop));
            let in_push = self
                .push
                .as_ref()
                .is_some_and(|push| push.contains_key(*prop));
 
            if in_set || in_push {
                return Err(format!(
                    "Property '{}' is managed by the server and cannot be set directly.",
                    prop
                )
                .into());
            }
        }
 
        Ok(())
    }
}

During commit evaluation in apply_opts, this check is enforced whenever opts.validate_rights is true:

if opts.validate_rights {
    commit.check_server_managed_properties()?;
}

When the server internally generates File resources inside the /upload handler, it applies commits with validate_rights: false, allowing legitimate internal assignment of internalId while blocking all external client commits.

Post-Patch Layer 2: Class Enforcement, Sanitization, and Containment (server/src/handlers/download.rs)

To ensure safety even if a resource in an existing database already contains a malicious internalId, the /download handler was hardened with three distinct checks:

pub fn download_file_handler_partial(
    req: &HttpRequest,
    resource: &Resource,
    params: &web::Query<DownloadParams>,
    appstate: &AppState,
) -> AtomicServerResult<HttpResponse> {
    // Fix 1: Explicitly verify that the resource has the `urls::FILE` class
    if !resource
        .get(urls::IS_A)
        .and_then(|v| v.to_subjects(None))
        .map(|classes| classes.iter().any(|c| c == urls::FILE))
        .unwrap_or(false)
    {
        return Err("Resource is not a File".into());
    }
 
    // Fix 2: Strip path separators and special characters using sanitize_filename
    let raw_filename = resource
        .get(urls::INTERNAL_ID)
        .map_err(|e| format!("Internal ID of file could not be resolved. {}", e))?
        .to_string();
    let filename = sanitize_filename::sanitize(&raw_filename);
 
    // Fix 3: Canonicalize both base and candidate paths and verify prefix containment
    let file_path = safe_join_uploads_path(&appstate.config.uploads_path, &filename)?;
 
    if params.q.is_none() && params.w.is_none() && params.f.is_none() {
        let file = NamedFile::open(&file_path)?;
        return Ok(file.into_response(req));
    }
    // ...
}
 
/// Joins `filename` onto `base`, refusing to serve anything outside `base`.
fn safe_join_uploads_path(base: &PathBuf, filename: &str) -> AtomicServerResult<PathBuf> {
    let candidate = base.join(filename);
 
    let canonical_base = base
        .canonicalize()
        .map_err(|_| "Upload storage is unavailable")?;
    let canonical_candidate = candidate.canonicalize().map_err(|_| "File not found")?;
 
    if !canonical_candidate.starts_with(&canonical_base) {
        return Err("File not found".into());
    }
 
    Ok(candidate)
}

Fix Completeness Assessment

The remediation is thorough and addresses both the injection vector and the path resolution sink. By running sanitize_filename::sanitize(&raw_filename) prior to safe_join_uploads_path, any directory separators (/ or \) and traversal sequences are stripped before touching the filesystem. Furthermore, canonicalize() resolves all symbolic links and relative segments at the OS level before starts_with(&canonical_base) is evaluated, preventing symlink-based escape attacks out of the uploads directory. One operational caveat is that if an attacker had already mutated an existing File resource prior to upgrading, the sanitize_filename call will collapse ../../../../etc/passwd into .._.._.._.._etc_passwd, which will safely fail the canonicalize() lookup with File not found.

Exploitation

Exploiting CVE-2026-69156 requires network access to the Atomic Server HTTP API and credentials (a private key) for any low-privilege Agent capable of creating or modifying at least one resource on the server. On instances with open registration or guest invite capabilities enabled, an unauthenticated user can self-provision an Agent and immediately execute the attack.

Step 1: Resource Mutation via Signed Commit

The attacker constructs an Atomic Commit payload targeting a resource subject they own (e.g., https://target.example.com/my-resource). In the Commit's set object, the attacker assigns the https://atomicdata.dev/properties/internalId property to the target filesystem path, and optionally includes https://atomicdata.dev/classes/File in https://atomicdata.dev/properties/isA.

{
  "https://atomicdata.dev/properties/subject": "https://target.example.com/my-resource",
  "https://atomicdata.dev/properties/signer": "https://target.example.com/agents/low-priv-agent",
  "https://atomicdata.dev/properties/createdAt": 1763413156000,
  "https://atomicdata.dev/properties/set": {
    "https://atomicdata.dev/properties/internalId": "../../../../home/atomic/.atomic/config.toml"
  },
  "https://atomicdata.dev/properties/signature": "<base64-ed25519-signature-of-canonical-json>"
}

Because PathBuf::push overwrites the base directory when given an absolute path, the attacker can alternatively bypass relative depth calculation entirely by specifying an absolute path such as /etc/passwd or /root/.config/atomic/config.toml. The signed JSON payload is submitted via an HTTP POST request to the /commit endpoint.

Step 2: Arbitrary File Retrieval via /download

Once the commit is accepted and persisted to the store, the attacker issues an HTTP GET request to the /download handler (or requests the resource URL when routed to the download handler via path/query parameters depending on the server routing configuration). Note that the query must omit the image transformation parameters (q, w, and f) so that execution hits the raw NamedFile::open(file_path) branch rather than the image resizing pipeline.

GET /download?subject=https%3A%2F%2Ftarget.example.com%2Fmy-resource HTTP/1.1
Host: target.example.com

Step 3: Root Agent Key Extraction and Privilege Escalation

The primary post-exploitation target on an Atomic Server host is the server's config.toml file (or /proc/self/environ if configured via environment variables). By reading /proc/self/environ or locating config.toml in the service user's configuration directory, the attacker retrieves the private_key setting.

> [!NOTE] > In Atomic Server, the root Agent's cryptographic identity is stored in plaintext inside config.toml. Once an attacker reads this file, they can sign arbitrary Commits as the server's root Agent without needing further filesystem access.

With the root Agent's base64-encoded ED25519 private key, the attacker can impersonate the root Agent on subsequent /commit requests, granting full read, write, and delete permissions across every resource and tenant hosted on the database. A public proof-of-concept and automated verification script is documented in the LLCForge/CVE-2026-69156 GitHub repository.

Impact Assessment

CVE-2026-69156 is assigned a CVSS v3.1 base score of 8.1 (High) with the vector CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:N.

  • Attack Vector (AV:N) & Attack Complexity (AC:L): The /commit and /download endpoints are standard HTTP API routes exposed over the network. Exploitation is deterministic and requires no timing windows or complex state preparation.
  • Privileges Required (PR:L) & User Interaction (UI:N): Creating or modifying a resource requires submitting a Commit signed by an authorized Agent. No interaction from administrators or other users is required.
  • Confidentiality (C:H): Attackers can read any file on the host filesystem for which the atomic-server OS process has read permissions. This includes /etc/passwd, TLS private keys, application source code, process memory maps (/proc/self/*), and database configuration files.
  • Integrity (I:H): While the path traversal primitive itself is read-only, reading config.toml directly discloses the root Agent's ED25519 private key. Using this key, an attacker can forge administrative Commits to modify or overwrite any resource in the Atomic Server database.
  • Availability (A:N): The file read mechanism does not directly disrupt service availability, though an attacker who escalates to the root Agent could subsequently delete database resources.

As of the latest telemetry, the vulnerability has an EPSS score of 0.00491 (0.491%, placing it in the 42.90th percentile) and is not listed in the CISA Known Exploited Vulnerabilities (KEV) catalog. However, because a public proof-of-concept (LLCForge/CVE-2026-69156) is available, exposed instances that allow public user registration or untrusted Agent access face an elevated risk of full database compromise.

Remediation

Upgrading to Patched Versions

All deployments of Atomic Server and applications depending on atomic_lib must be upgraded to version 0.40.3 or later. Version 0.40.3 enforces the server-managed property denylist during commit processing and adds class validation, filename sanitization, and canonical path containment checks to the download handler.

  • Cargo / Rust Crates: Update atomic-server, atomic_lib, atomic-server-tauri, and atomic-cli in Cargo.toml to >= 0.40.3 and recompile.
  • Docker Deployments: Pull the updated container image (ontola/atomic-server:v0.40.3 or ontola/atomic-server:latest) and recreate the service containers.

Post-Upgrade Secret Rotation and Auditing

Because exploitation leaves minimal traces outside of HTTP access logs and commit history, administrators upgrading from a vulnerable version (0.30.0 through 0.40.2) where untrusted Agents had write access should perform the following steps:

  1. Audit Database Resources: Query the Atomic Server store for any resources that possess the https://atomicdata.dev/properties/internalId property where either (a) the resource class is not https://atomicdata.dev/classes/File, or (b) the internalId value contains / or .. characters.
  2. Rotate the Root Agent Key: Regenerate the root Agent private key in config.toml (or the ATOMIC_PRIVATE_KEY environment variable) and restart the server to invalidate any keys that may have been exfiltrated prior to patching.

Workarounds and Defense-in-Depth

If an immediate upgrade to 0.40.3 cannot be performed, apply the following compensating controls at the reverse proxy and operating system layers:

  • Reverse Proxy Filtering: Configure NGINX, Envoy, or a Web Application Firewall (WAF) in front of Atomic Server to inspect POST /commit request bodies and reject any JSON payload containing the string internalId. If file downloads are not required by the deployment, block access to the /download endpoint entirely.
  • Filesystem Isolation: Run the atomic-server binary under a dedicated, unprivileged service account within a minimally populated container or chroot jail, ensuring that sensitive host files and configuration files outside the upload directory are unreadable where possible.

Official Patches

Ontola (GitHub Security Advisory)Official GitHub Security Advisory GHSA-8vc4-8hjq-988p for CVE-2026-69156
Ontola (GitHub Release)Atomic Server v0.40.3 release containing the patch
Ontola (Git Commit)Fix commit restricting internalId assignment and validating paths in /download

Fix Analysis (1)

Technical Appendix

CVSS Score
8.1/ 10
CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:N
EPSS Probability
0.49%
Top 57% most exploited

Affected Systems

Ontola Atomic Server (atomic-server)atomic_lib Rust crateatomic-server-tauriatomic-cli

Affected Versions Detail

Product
Affected Versions
Fixed Version
atomic-server
ontola
>= 0.30.0, < 0.40.30.40.3
atomic_lib
ontola
>= 0.30.0, < 0.40.30.40.3
AttributeDetail
CVE / Advisory IDCVE-2026-69156 / GHSA-8vc4-8hjq-988p
Vulnerability ClassCWE-22: Path Traversal / Arbitrary File Read
CVSS v3.1 Score8.1 High (CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:N)
EPSS Score0.491% (42.90th percentile)
Attack VectorNetwork (Authenticated Commit injection + HTTP GET to /download)
ImpactArbitrary file read leading to root Agent private key theft and full administrative takeover
Exploit StatusPublic Proof-of-Concept Available (Not in CISA KEV)
Patched VersionAtomic Server 0.40.3

MITRE ATT&CK Mapping

T1083File and Directory Discovery
Discovery
T1005Data from Local System
Collection
CWE-22
Improper Limitation of a Pathname to a Restricted Directory ('Path Traversal')

The product uses external input to construct a pathname that is intended to identify a file or directory that is located underneath a restricted parent directory, but the product does not properly neutralize special elements within the pathname that can cause the pathname to resolve to a location that is outside of the restricted directory.

Known Exploits & Detection

GitHubAutomated Python-based scanner and proof-of-concept reproduction script for CVE-2026-69156.

Vulnerability Timeline

Security fix commit 59d067c797c946b839c9101fedff4c40171c0c61 authored by Joep Meindertsma.
2026-07-06
Atomic Server v0.40.3 released and GitHub Security Advisory GHSA-8vc4-8hjq-988p published.
2026-11-17
CVE-2026-69156 published on CVE.org and ingested by NVD.
2026-11-17
NVD and CVE records finalized with CVSS v3.1 score of 8.1 (High).
2026-11-18
Public proof-of-concept exploit script published to GitHub (LLCForge/CVE-2026-69156).
2026-11-19

References & Sources

  • [1]GitHub Security Advisory GHSA-8vc4-8hjq-988p
  • [2]Fix Commit 59d067c797c946b839c9101fedff4c40171c0c61
  • [3]Atomic Server Release v0.40.3
  • [4]NVD Detail for CVE-2026-69156
  • [5]CVE.org Record for CVE-2026-69156
  • [6]CVEListV5 Official JSON Record for CVE-2026-69156
  • [7]MITRE CVE Record for CVE-2026-69156
  • [8]Proof-of-Concept Repository (LLCForge/CVE-2026-69156)

Attack Flow Diagram

Press enter or space to select a node. You can then use the arrow keys to move the node around. Press delete to remove it and escape to cancel.
Press enter or space to select an edge. You can then press delete to remove it or escape to cancel.

More Reports

•about 2 hours ago•CVE-2026-69157
9.8

CVE-2026-69157: Unauthenticated Administrative Takeover via /setup in Atomic Server

CVE-2026-69157 (GHSA-pfwx-xjp4-qxcj) is a critical missing authentication vulnerability (CWE-306) affecting Atomic Server versions 0.29.0 through 0.40.2. During initial deployment, the server exposes an unauthenticated /setup endpoint that generates an invite token granting root write permissions across the entire Drive. Because the invite redemption handler discards the redeemer identity, an unauthenticated remote attacker can intercept or request this setup invite on an unclaimed instance, register an arbitrary Agent public key, and assume full administrative control over the database.

Alon Barad
Alon Barad
3 views•10 min read
•about 3 hours ago•CVE-2026-69158
8.6

CVE-2026-69158: Unauthenticated Full-Response SSRF in Atomic Server /bookmark Endpoint

CVE-2026-69158 is a high-severity Server-Side Request Forgery (SSRF) vulnerability in Ontola Atomic Server (atomic-server) and its underlying Rust library (atomic_lib). Prior to versions 0.40.2 and 0.40.3, the server exposed an unauthenticated HTTP GET endpoint at /bookmark (and handled user-supplied URLs via POST to /import) that fetched arbitrary caller-supplied URLs after performing only a naive string prefix check. Because endpoint routing bypassed read authorization checks and reflected the retrieved content back to the client, unauthenticated remote attackers can force the server to issue HTTP GET requests to internal network destinations, localhost services, and cloud instance metadata endpoints.

Amit Schendel
Amit Schendel
3 views•11 min read
•about 4 hours ago•CVE-2026-71425
6.5

CVE-2026-71425: Server-Side Request Forgery and OAuth Token Exposure in Outstatic GitHub REST Proxy

CVE-2026-71425 (GHSA-7jvc-9xq8-frff) is a Server-Side Request Forgery (SSRF) and credential exposure vulnerability in Outstatic, an open-source Next.js-based static site Content Management System (CMS). In versions prior to 2.2.1, the authenticated GitHub REST proxy (/api/outstatic/github) constructed upstream URLs via insecure string concatenation of an unvalidated endpoint parameter and merged arbitrary user-supplied HTTP headers directly into outbound requests. Because the proxy automatically attaches the active user's GitHub OAuth access token to these requests, an authenticated caller or an attacker leveraging a cross-origin request primitive can redirect the server's outbound request to an arbitrary external host and exfiltrate the OAuth bearer token.

Amit Schendel
Amit Schendel
1 views•9 min read
•about 7 hours ago•CVE-2026-71861
7.4

CVE-2026-71861: Authentication Bypass via Unsigned Binding Headers in Chainguard Go SDK

CVE-2026-71861 (GHSA-wq26-3j2m-4hvv) is a high-severity authentication bypass and cryptographic signature-binding replay vulnerability in the Chainguard Go SDK (chainguard.dev/sdk / github.com/chainguard-dev/sdk) affecting versions prior to v0.1.107. The vulnerability resides in the auth/aws.VerifyToken function, which validates AWS STS GetCallerIdentity requests signed with AWS Signature Version 4 (SigV4) to authenticate AWS workloads. Prior to version v0.1.107, VerifyToken verified the values of custom HTTP binding headers (Chainguard-Audience and Chainguard-Identity) without confirming that those headers were listed in the SigV4 SignedHeaders parameter of the Authorization header. Because AWS STS ignores unsigned headers when recomputing and verifying the SigV4 signature, an attacker who captures any valid, fresh SigV4-signed STS GetCallerIdentity request from a victim AWS principal can inject or overwrite the Chainguard-Audience and Chainguard-Identity headers and replay the token to bypass authentication and impersonate the victim identity.

Alon Barad
Alon Barad
4 views•11 min read
•about 8 hours ago•CVE-2026-73864
7.5

CVE-2026-73864: Unverified Native Artifact Download Leading to Remote Code Execution in install-artifact-from-github

CVE-2026-73864 is a CWE-494 (Download of Code Without Integrity Check) vulnerability in the Node.js package install-artifact-from-github prior to version 1.7.0. The tool downloads precompiled native Node.js C/C++ addons (.node binaries) from GitHub Releases or configurable mirrors and writes them directly to disk without verifying cryptographic checksums or signatures. Furthermore, its HTTP client follows cross-protocol redirects from HTTPS to plaintext HTTP. When the consuming application loads the downloaded addon via require(), the unverified native binary executes immediately within the Node.js process, permitting arbitrary native code execution if an attacker compromises a GitHub release asset, poisons a configured mirror, or intercepts downgraded network traffic.

Amit Schendel
Amit Schendel
5 views•11 min read
•about 9 hours ago•CVE-2026-68903
7.7

CVE-2026-68903: Arbitrary Host File Read via Model.spec.source hostPath Injection in LLMKube

LLMKube prior to version 0.9.0 fails to restrict local filesystem paths and file:// URIs supplied in the Model.spec.source field of custom resources. A namespace-level user with permission to create or modify Model and InferenceService resources can traverse the filesystem of the operator controller pod or mount arbitrary host node files via a HostPathVolumeSource. This enables unauthorized disclosure of high-privilege Kubernetes ServiceAccount tokens and underlying host credentials.

Alon Barad
Alon Barad
4 views•9 min read