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-69157

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

Alon Barad
Alon Barad
Software Engineer

Nov 19, 2026·10 min read·1 visit

Executive Summary (TL;DR)

Atomic Server versions 0.29.0 through 0.40.2 expose an unauthenticated /setup bootstrap endpoint that issues a single-use administrative invite with full Drive write privileges. Any unauthenticated attacker with network access to a fresh, unclaimed deployment can claim the invite, register an attacker-controlled Agent, and gain complete administrative control over all data and permissions.

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.

Vulnerability Overview

Atomic Server (atomic-server) is an open-source headless Content Management System (CMS) and real-time graph database written in Rust. It organizes data as resources linked to subjects, using cryptographic keypairs associated with entities called Agents to enforce read and write access controls across a hierarchical storage root known as a Drive.

To simplify initial administration on new installations, Atomic Server provides a bootstrap workflow located at the /setup HTTP endpoint. In versions 0.29.0 through 0.40.2, this initialization routine suffers from Missing Authentication for Critical Functionality (CWE-306). When a server instance starts up without an established administrator, it automatically provisions a well-known setup invite targeting the root Drive with full write rights (DriveRights::All) and usagesLeft initialized to 1.

The /setup endpoint does not verify a pre-shared deployment token, enforce local loopback (127.0.0.1) network restrictions, or validate the caller's identity before returning the bootstrap invite URL. Furthermore, the invite processing function construct_invite_redirect in server/src/plugins/invite.rs discards the redeemer's identity and accepts any caller-supplied public key or Agent registration payload.

Consequently, any unauthenticated actor capable of reaching an unclaimed Atomic Server instance over the network can request the setup invite, register a high-privilege Agent account, and achieve complete administrative control over the server.

Root Cause Analysis

The vulnerability originates from an architectural design flaw in how Atomic Server bootstraps trust during initial deployment, compounded by two implementation defects in the invite redemption logic within server/src/plugins/invite.rs. The primary failure occurs in the /setup route handler (server/src/routes/setup.rs), which executes state.store.create_invite(DriveRights::All) or retrieves the existing bootstrap invite without verifying who is making the HTTP request.

When an invite is redeemed via construct_invite_redirect, the server evaluates the invite resource properties (urls::USAGES_LEFT, urls::EXPIRES_AT, urls::WRITE, and urls::TARGET). During this step, the handler does not bind the invite to a specific pre-authorized user identity. Instead, it extracts the public key or Agent subject provided in the request parameters and directly appends that Agent to the write-authorized list of the target resource—which, for the /setup invite, is the root Drive (/).

In addition to the missing authentication on /setup, analysis of the invite handler prior to commit 98517d8921c78bd9b728a2459378c184ebf8a969 reveals two secondary flaws in construct_invite_redirect:

  1. Time-of-Check to Time-of-Use (TOCTOU) Race Condition: The usagesLeft counter was read from the store, checked for a positive value, decremented by 1, and written back to the database asynchronously without mutual exclusion. Because the underlying key-value store lacked an atomic check-and-decrement operation on resource properties, concurrent requests arriving simultaneously could all observe usagesLeft == 1 and successfully register multiple rogue administrative Agents from a single-use invite.
  2. Inverted Expiration Logic: When checking the urls::EXPIRES_AT timestamp on an invite, the server evaluated if expires.to_int()? > atomic_lib::utils::now() and returned an error if true. Because a valid future expiration timestamp is numerically greater than the current Unix timestamp, this inverted comparison caused unexpired invites with an explicit expiration date to be rejected while permitting expired invites to be redeemed.

> [!NOTE] > While the race condition and inverted expiration check impacted the reliability and concurrency safety of the invite subsystem, the core security exposure (CVE-2026-69157) stems directly from exposing the unauthenticated /setup capability to untrusted networks without an out-of-band verification requirement.

Code Analysis

In vulnerable releases of Atomic Server, the /setup endpoint handler processes incoming GET requests by generating or returning an administrative invite subject directly to the caller:

// server/src/routes/setup.rs
pub async fn get_setup(state: web::Data<AppState>) -> impl Responder {
    // Vulnerability (CWE-306): No authentication, loopback restriction, or CLI token verification
    let invite = state.store.create_invite(DriveRights::All).unwrap();
    HttpResponse::Ok().json(json!({
        "invite": invite.subject,
    }))
}

When the invite is redeemed, execution passes to construct_invite_redirect in server/src/plugins/invite.rs. In commit 98517d8921c78bd9b728a2459378c184ebf8a969, the maintainers modified server/Cargo.toml to enable the sync feature on tokio and patched server/src/plugins/invite.rs to address the TOCTOU race condition and the inverted expiration check:

// server/src/plugins/invite.rs (Patched in 98517d8921c78bd9b728a2459378c184ebf8a969)
use std::sync::LazyLock;
use tokio::sync::Mutex;
 
// Process-wide mutex added to serialize the read-decide-write cycle on usagesLeft
static INVITE_REDEEM_LOCK: LazyLock<Mutex<()>> = LazyLock::new(|| Mutex::new(()));
 
pub fn construct_invite_redirect<'a>(
    context: &'a mut CommitContext,
) -> Pin<Box<dyn Future<Output = AtomicResult<Resource>> + Send + 'a>> {
    Box::pin(async move {
        // ... [target resolution logic] ...
 
        // FIX 1: Check expiry before consuming a usage, and flip '>' to '<'
        // Previously: if expires.to_int()? > atomic_lib::utils::now() (inverted check)
        if let Ok(expires) = db_resource.get(urls::EXPIRES_AT) {
            if expires.to_int()? < atomic_lib::utils::now() {
                return Err("Invite has expired".into());
            }
        }
 
        // FIX 2: Acquire asynchronous lock across the usagesLeft check and decrement
        let _redeem_guard = INVITE_REDEEM_LOCK.lock().await;
 
        if let Ok(usages_left) = db_resource.get(urls::USAGES_LEFT) {
            let num = usages_left.to_int()?;
            if num == 0 {
                return Err("No usages left for this invite".into());
            }
            db_resource.set_propval(
                urls::USAGES_LEFT.into(),
                Value::Integer(num - 1),
                store,
            )?;
            db_resource
                .save_locally(store)
                .await
                .map_err(|e| format!("Unable to save updated Invite. {}", e))?;
        }
        // ... [proceeds to grant Agent rights on target] ...

Fix Completeness Assessment

Commit 98517d8921c78bd9b728a2459378c184ebf8a969 strictly resolves the concurrency race condition via INVITE_REDEEM_LOCK and fixes the timestamp comparison operator (< instead of >). However, this patch is incomplete with respect to the primary vulnerability (CVE-2026-69157).

Even with INVITE_REDEEM_LOCK active, /setup remains unauthenticated on a freshly initialized server where usagesLeft equals 1. An attacker who queries /setup before the legitimate administrator claims the server still wins the initial redemption, decrements usagesLeft to 0 under the lock, and locks out the actual deployment owner. A complete remediation requires gating /setup behind a local-only transport restriction or requiring a cryptographic bootstrap token printed exclusively to the server's standard output console upon first boot.

Exploitation

Exploiting CVE-2026-69157 requires no prior authentication, user interaction, or complex payload crafting. The sole prerequisite is network connectivity to an atomic-server deployment in its initial, unclaimed state (where the bootstrap invite still has usagesLeft > 0). Automated internet scanners or adversaries monitoring newly provisioned cloud infrastructure and DNS records can exploit the window between container startup and manual administrator configuration.

The attack methodology proceeds in three distinct steps:

  1. Instance Discovery and Invite Retrieval: The attacker sends an HTTP GET request to /setup with an Accept: application/json header. If the server is unclaimed, it responds with HTTP 200 OK and a JSON payload containing the full invite URL and token (e.g., https://<target>/invite/<TOKEN>). Alternatively, if HTML is returned, the invite URL can be parsed directly from the response body.
  2. Administrative Agent Registration: The attacker extracts the <TOKEN> identifier from the invite URL and submits an HTTP POST request to /setup?invite=<TOKEN>. The request body specifies the attacker's chosen Agent details (or public key) along with the invite token.
  3. Privilege Verification and Takeover: Upon processing the POST request, Atomic Server creates the Agent resource, updates the root Drive policy to grant the new Agent full read/write permissions, decrements usagesLeft to 0, and returns a valid JSON Web Token (JWT) or session credential.
# 1. Request the unauthenticated bootstrap invite
curl -sk -H "Accept: application/json" https://target.example.com/setup
# Expected Output: {"invite": "https://target.example.com/invite/aBcDeFg12345"}
 
# 2. Redeem the invite to provision an administrative Agent
curl -sk -X POST "https://target.example.com/setup?invite=aBcDeFg12345" \
  -H "Content-Type: application/json" \
  -d '{"name": "admin_agent", "password": "AttackerPass2026!", "invite": "aBcDeFg12345"}'
 
# 3. Query all stored subjects using the issued JWT to confirm root access
curl -sk -H "Authorization: Bearer <ISSUED_JWT>" https://target.example.com/all-subjects

A public Proof-of-Concept (PoC) exploit tool (LLCForge/CVE-2026-69157) automates this exact workflow. The PoC script fingerprints target endpoints via /version and HTTP response headers (Server or X-Powered-By), parses the /setup response via JSON deserialization or regular expression fallback (r'(https?://[^\s"\'<]+/invite/[A-Za-z0-9_=-]+)'), registers an arbitrary Agent, and verifies administrative takeover by querying /all-subjects.

Impact Assessment

CVE-2026-69157 carries a CVSS v3.1 base score of 9.8 (CRITICAL) with the vector CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H. The exploitability subscore is 3.9 and the impact subscore is 5.9, reflecting that the flaw is remotely exploitable over the network (AV:N) with low attack complexity (AC:L), zero privileges required (PR:N), and no user interaction (UI:N).

Successful exploitation grants the attacker DriveRights::All on the root Drive resource (/). Because Atomic Server uses hierarchical permission inheritance starting from the Drive root, write access at the root level confers unrestricted control over the entire application instance:

  • Confidentiality (C:H): The attacker can enumerate and exfiltrate all subjects, private resources, documents, and configuration metadata stored in the graph database via endpoints such as /all-subjects.
  • Integrity (I:H): The attacker can modify arbitrary graph nodes, inject malicious content into headless CMS consumers, alter access control lists (ACLs), and create additional persistent backdoor Agent accounts.
  • Availability (A:H): Because the bootstrap invite has usagesLeft set to 1, the attacker's redemption consumes the only setup slot, denying administrative access to the legitimate server operator. The attacker can also delete all resources in the Drive.

As of current threat intelligence tracking, the Exploit Prediction Scoring System (EPSS) assigns CVE-2026-69157 a score of 0.00512 (0.51%, 44.33th percentile), and the vulnerability is not listed in the CISA Known Exploited Vulnerabilities (KEV) catalog. However, the availability of a turnkey mass-scanning PoC significantly lowers the barrier to opportunistic exploitation against newly deployed instances.

Remediation

Because no verified upstream version completely eliminates the unauthenticated /setup design pattern as of version 0.40.2, operators must combine code updates with strict deployment and network access controls to secure Atomic Server instances.

1. Apply Upstream Commit for Invite Serialization

Ensure that deployments include commit 98517d8921c78bd9b728a2459378c184ebf8a969 so that single-use invites cannot be concurrently redeemed via the TOCTOU race condition and invite expiration timestamps are enforced properly.

2. Restrict Network Access During Initialization

Never bind an uninitialized atomic-server instance directly to a public network interface (0.0.0.0) before claiming the administrative account. Bind the daemon to 127.0.0.1 during initial provisioning, complete the /setup workflow locally (or over an SSH tunnel) to decrement usagesLeft to 0, and only then expose the service to external traffic.

3. Enforce Reverse Proxy Access Controls

Block external access to the /setup endpoint permanently at the reverse proxy or Web Application Firewall (WAF) layer. Even after initial setup is completed, external clients have no legitimate reason to query /setup.

For Nginx deployments, restrict /setup to the loopback interface:

location ^~ /setup {
    allow 127.0.0.1;
    allow ::1;
    deny all;
    proxy_pass http://127.0.0.1:9883;
}

For Caddy deployments, return an HTTP 403 Forbidden response for non-local requests targeting /setup:

@external_setup {
    path /setup*
    not remote_ip 127.0.0.1 ::1
}
respond @external_setup 403

4. Audit Existing Deployments for Compromise

Administrators operating versions 0.29.0 through 0.40.2 should audit the root Drive's write property and commit history to verify that only authorized Agent subjects hold administrative permissions, and inspect HTTP access logs for unexpected GET /setup or POST /setup requests originating from external IP addresses.

Official Patches

GitHub / ontolaOfficial GitHub Security Advisory for CVE-2026-69157 (GHSA-pfwx-xjp4-qxcj)
ontolaCommit addressing invite redemption concurrency and expiration check logic

Fix Analysis (1)

Technical Appendix

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

Affected Systems

ontola/atomic-serveratomic-serveratomic_libatomic-cliatomic-server-tauri

Affected Versions Detail

Product
Affected Versions
Fixed Version
atomic-server
ontola
>= 0.29.0, <= 0.40.2None (Partial fix in commit 98517d8921c78bd9b728a2459378c184ebf8a969)
AttributeDetail
Vulnerability TypeCWE-306: Missing Authentication for Critical Functionality
Affected Versionsatomic-server 0.29.0 through 0.40.2
Attack VectorNetwork (Unauthenticated HTTP GET/POST to /setup)
CVSS v3.1 Score9.8 Critical (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H)
EPSS Score0.51% (44.33th Percentile)
ImpactFull Administrative Takeover (DriveRights::All on Root Drive)
Exploit StatusPublic Proof-of-Concept Available
CISA KEV StatusNot Listed

MITRE ATT&CK Mapping

T1190Exploit Public-Facing Application
Initial Access
CWE-306
Missing Authentication for Critical Functionality

The software does not perform any authentication for functionality that requires a provable user identity or consumes a significant amount of resources.

Known Exploits & Detection

GitHubPublic Proof-of-Concept Python script and mass scanner that fingerprints atomic-server, retrieves the unauthenticated /setup invite, and registers an administrative Agent.

Vulnerability Timeline

Commit 98517d8921c78bd9b728a2459378c184ebf8a969 authored by Joep Meindertsma addressing invite redemption race conditions and expiration check logic.
2026-07-06
GHSA-pfwx-xjp4-qxcj and CVE-2026-69157 published on GitHub Advisory Database, CVE.org, and NVD.
2026-11-17
NVD record updated and initial EPSS score (0.00512) recorded.
2026-11-18
Public Proof-of-Concept exploit script published on GitHub (LLCForge/CVE-2026-69157).
2026-11-19

References & Sources

  • [1]GitHub Security Advisory: GHSA-pfwx-xjp4-qxcj
  • [2]Atomic Server Commit 98517d8921c78bd9b728a2459378c184ebf8a969
  • [3]National Vulnerability Database (NVD): CVE-2026-69157
  • [4]CVE.org Record: CVE-2026-69157
  • [5]CVEProject cvelistV5 Record: CVE-2026-69157.json
  • [6]Proof-of-Concept Exploit Repository (LLCForge/CVE-2026-69157)
  • [7]CWE-306: Missing Authentication for Critical Functionality

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 1 hour 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
2 views•11 min read
•about 2 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 5 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 6 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 7 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
•about 8 hours ago•CVE-2026-75521
10.0

CVE-2026-75521: Unverified Client Certificate Authentication Bypass in Miren Runtime

CVE-2026-75521 is an unauthenticated remote authentication bypass vulnerability in Miren Runtime prior to version 0.11.1. The QUIC/HTTP3 RPC service configures its TLS listener with tls.RequestClientCert, which requests client certificates without validating them against the cluster Certificate Authority. Simultaneously, the RPC authenticators extract caller identities directly from PeerCertificates[0] without checking VerifiedChains, granting any caller presenting a self-signed certificate the AuthMethodCert identity and a complete Role-Based Access Control (RBAC) bypass.

Alon Barad
Alon Barad
7 views•9 min read