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

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

Amit Schendel
Amit Schendel
Senior Security Researcher

Nov 19, 2026·11 min read·2 visits

Executive Summary (TL;DR)

An unauthenticated full-response Server-Side Request Forgery (SSRF) flaw in Atomic Server prior to version 0.40.2/0.40.3 allows remote attackers to retrieve internal network resources and cloud metadata via the /bookmark and /import endpoints due to missing authorization checks and insufficient URL validation.

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.

Vulnerability Overview

Atomic Server (ontola/atomic-server) is an open-source headless Content Management System (CMS) and graph database written in Rust, powered by the core library atomic_lib. Among its built-in data indexing capabilities, the platform provides a bookmarking plugin (server/src/plugins/bookmark.rs) and a remote resource importer (lib/src/endpoints.rs). These features allow clients to submit external URLs so the server can fetch, parse, and store web content as structured Atomic Data resources.

In versions of atomic-server prior to 0.40.2 and 0.40.3 (and atomic_lib prior to 0.40.1), the /bookmark HTTP GET endpoint and /import POST endpoint are vulnerable to Server-Side Request Forgery (CWE-918). When handling a request to /bookmark, the application extracts the caller-supplied url query parameter and dispatches an outbound HTTP GET request to retrieve the remote document. Crucially, the request dispatch pipeline invokes the plugin handler before evaluating the database read authorization gate (check_read), exposing this functionality to unauthenticated network clients.

The outbound HTTP helper function fetch_body validates the target URL strictly by checking whether the string begins with the characters http (!url.starts_with("http")). It performs no parsing of the hostname, no verification against private or reserved IP address ranges, and no filtering during DNS resolution or HTTP redirection. Furthermore, because the bookmark handler parses and embeds the remote response body directly into the JSON-AD / HTML resource returned to the requester, the flaw constitutes a full-response SSRF.

An unauthenticated remote attacker with network access to the Atomic Server HTTP interface can exploit this vulnerability to cross network trust boundaries (Scope: Changed). Attackers can read cloud provider instance metadata (such as AWS EC2 IMDSv1 IAM credentials), query unauthenticated localhost daemons (including Redis, Elasticsearch, or Prometheus), and perform service discovery across internal RFC1918 subnets.

Root Cause Analysis

The root cause of CVE-2026-69158 stems from two intersecting architectural flaws in atomic_lib and atomic-server: premature endpoint execution prior to access control verification, and the absence of network-layer destination validation in the HTTP client wrapper.

First, in lib/src/db.rs, Atomic Server implements custom virtual endpoints (such as /bookmark, /import, /search, and /path) using an internal plugin registration system. When a client requests a resource URL matching a registered endpoint path, the database retrieval routine checks if the resource carries an endpoint handler and immediately executes (endpoint.handle)(context) before invoking check_read(). While standard graph nodes enforce read permissions against the requesting agent, virtual endpoints that do not manually invoke permission checks inside their handler closure execute with full unauthenticated accessibility.

Second, when handle_bookmark_request processes the url query parameter, it delegates the network request to fetch_data(url), which in turn calls atomic_lib::client::fetch_body(). Within lib/src/client/helpers.rs, fetch_body was originally designed to handle both trusted internal federation requests and user-triggered fetches. Its input validation consisted solely of a prefix check:

if !url.starts_with("http") {
    return Err(format!("Could not fetch url '{}', must start with http.", url).into());
}

Because the underlying HTTP client (ureq in v0.40.0/v0.40.2 and reqwest in main/v0.40.3) is instantiated with default socket resolution and automatic redirect following, three specific validation gaps exist:

  1. Direct IP Literal Access: Any IPv4 or IPv6 literal belonging to loopback (127.0.0.0/8, [::1]), RFC1918 private networks (10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16), link-local cloud metadata (169.254.169.254), or Carrier-Grade NAT (100.64.0.0/10) passes the starts_with("http") filter.
  2. Unchecked DNS Resolution: Attackers can supply an external domain name configured with an A or AAAA record pointing to an internal IP address (e.g., localtest.me resolving to 127.0.0.1), or utilize DNS rebinding to bypass pre-request inspection.
  3. Unvalidated HTTP Redirects: The HTTP client automatically follows 301, 302, 307, and 308 status codes. An attacker can provide an external URL under their control that responds with Location: http://169.254.169.254/latest/meta-data/, causing the client to follow the redirect into restricted address space.

Code Analysis

Prior to the security patch, server/src/plugins/bookmark.rs accepted the url parameter from the query string and passed it directly to fetch_body in lib/src/client/helpers.rs:

// VULNERABLE CODE: server/src/plugins/bookmark.rs
async fn fetch_data(url: &str) -> AtomicResult<String> {
    fetch_body(url, "text/html", None).await
}

In lib/src/client/helpers.rs (prior to commit 006ff290f7ec976c8cbafdceb7b6899389abd5be), fetch_body executed the outbound request without host or socket inspection:

// VULNERABLE CODE: lib/src/client/helpers.rs
pub fn fetch_body(
    url: &str,
    content_type: &str,
    client_agent: Option<&Agent>,
) -> AtomicResult<String> {
    if !url.starts_with("http") {
        return Err(format!("Could not fetch url '{}', must start with http.", url).into());
    }
    if let Some(agent) = client_agent {
        // ... signed header generation ...
    }
    let agent = ureq::builder()
        .timeout(std::time::Duration::from_secs(2))
        .build();
    let resp = agent.get(url).set("Accept", content_type).call()?;
    resp.into_string()
}

The remediation, delivered across commits 006ff290f7ec976c8cbafdceb7b6899389abd5be (for the ureq-based 0.40.2 branch) and 2d4535fcd84761288027616505cc61abdf05bc50 / e7f551d385045708240ca56889d1334a39349735 (for the asynchronous reqwest-based 0.40.3 release), splits outbound fetching into two distinct paths. Internal system operations continue using fetch_body, while untrusted user-supplied URLs in /bookmark and /import are routed to a new fetch_body_untrusted function backed by the ssrf_guard module.

// PATCHED CODE: lib/src/client/ssrf_guard.rs (and helpers.rs)
pub(crate) fn preflight_url(raw: &str) -> AtomicResult<Url> {
    let parsed = Url::parse(raw)
        .map_err(|e| format!("Invalid URL '{}': {}", raw, e))?;
    match parsed.scheme() {
        "http" | "https" => {}
        other => return Err(format!("Rejected URL '{}': scheme '{}' is not allowed", raw, other).into()),
    }
    if allow_private_fetch() {
        return Ok(parsed);
    }
    let host = parsed.host_str().ok_or_else(|| format!("Rejected URL '{}': missing host", raw))?;
    // Strip IPv6 brackets if present and evaluate IP literals
    let bare = host.strip_prefix('[').and_then(|h| h.strip_suffix(']')).unwrap_or(host);
    if let Ok(ip) = bare.parse::<IpAddr>() {
        if !is_public_ip(&ip) {
            return Err(format!("Rejected URL '{}': target address {} is not a public IP", raw, ip).into());
        }
    }
    Ok(parsed)
}

The helper is_public_ip explicitly denies private, loopback, link-local, broadcast, unspecified, multicast, CGNAT (100.64.0.0/10), benchmark (198.18.0.0/15), and IPv4-mapped IPv6 (::ffff:0:0/96) ranges:

fn is_public_ipv4(ip: Ipv4Addr) -> bool {
    let o = ip.octets();
    let is_cgnat = o[0] == 100 && (64..=127).contains(&o[1]);
    let is_benchmark = o[0] == 198 && (o[1] == 18 || o[1] == 19);
    let is_current_network = o[0] == 0;
    !ip.is_private() && !ip.is_loopback() && !ip.is_link_local()
        && !ip.is_broadcast() && !ip.is_documentation()
        && !ip.is_unspecified() && !ip.is_multicast()
        && !is_cgnat && !is_benchmark && !is_current_network
}

To prevent DNS rebinding and open-redirect bypasses, the patch hooks directly into the HTTP client's DNS resolver (PublicOnlyResolver implementing reqwest::dns::Resolve or ureq::Resolver) and custom redirect policy:

// Custom DNS Resolver ensures resolved socket addresses are validated pre-connection
impl Resolve for PublicOnlyResolver {
    fn resolve(&self, name: Name) -> Resolving {
        let host = name.as_str().to_string();
        Box::pin(async move {
            let addrs: Vec<SocketAddr> = tokio::net::lookup_host((host.as_str(), 0)).await?.collect();
            if !allow_private_fetch() {
                for addr in &addrs {
                    if !is_public_ip(&addr.ip()) {
                        return Err(Box::new(io::Error::new(
                            io::ErrorKind::PermissionDenied,
                            format!("Rejected host '{}': resolves to non-public address {}", host, addr.ip()),
                        )));
                    }
                }
            }
            Ok(Box::new(addrs.into_iter()) as Addrs)
        })
    }
}

> [!NOTE] > Assessment of Fix Completeness: The patch is comprehensive at the network transport layer. By coupling preflight URL parsing, hop-by-hop redirect validation (via reqwest::redirect::Policy::custom), and a custom DNS resolver (PublicOnlyResolver) that inspects the resolved SocketAddr immediately prior to connection establishment, the fix mitigates both HTTP redirect chains and time-of-check to time-of-use (TOCTOU) DNS rebinding. However, the patch does not force authentication on /bookmark itself; the endpoint remains callable by unauthenticated users if they query public external URLs, or if the administrator explicitly disables the guard by setting ATOMIC_ALLOW_PRIVATE_FETCH=1.

Exploitation

Exploiting CVE-2026-69158 requires no authentication, no special headers, and no prior knowledge of the target's internal Atomic Data graph schema. Any remote client capable of sending an HTTP GET request to the Atomic Server instance can trigger the vulnerability via the /bookmark endpoint.

A public Proof of Concept (PoC) published by LLCForge demonstrates four primary exploitation workflows: cloud instance metadata credential extraction, localhost service enumeration, internal RFC1918 subnet scanning, and arbitrary internal document retrieval.

1. Cloud Metadata Exfiltration (AWS IMDSv1)

If Atomic Server is hosted on an Amazon EC2 instance (or similar cloud environment supporting IMDSv1 on 169.254.169.254), an attacker can query the metadata service in two steps to harvest temporary IAM role credentials:

GET /bookmark?url=http://169.254.169.254/latest/meta-data/iam/security-credentials/ HTTP/1.1
Host: atomic-server.target.corp
Accept: application/ad+json

The server fetches the directory listing containing the attached IAM role name and reflects it in the description or preview property of the returned JSON-AD object. The attacker then issues a second GET request appending the discovered role name:

GET /bookmark?url=http://169.254.169.254/latest/meta-data/iam/security-credentials/atomic-prod-role HTTP/1.1
Host: atomic-server.target.corp
Accept: application/ad+json

This returns the JSON payload containing AccessKeyId, SecretAccessKey, and Token directly in the HTTP response.

2. Localhost and Internal Service Discovery

Attackers can differentiate between open ports, closed ports, and non-HTTP protocols on 127.0.0.1 or internal subnets (10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16) by observing HTTP status codes and reflected content:

# Querying an internal Elasticsearch instance on localhost
curl -sk "https://atomic-server.target.corp/bookmark?url=http://127.0.0.1:9200/_cat/indices"
 
# Probing internal Kubernetes or Prometheus metrics endpoints
curl -sk "https://atomic-server.target.corp/bookmark?url=http://10.0.0.15:9090/metrics"

When the target port is open and returns an HTTP response, Atomic Server returns HTTP 200 OK with the parsed body. When a port is closed (connection refused) or times out after the 2-second client limit, Atomic Server returns HTTP 500 Internal Server Error with an error message detailing the connection failure, enabling reliable internal port scanning.

Operational Constraints

Exploitation is constrained to HTTP and HTTPS GET requests. Consequently, cloud environments enforcing IMDSv2 (which requires an initial HTTP PUT request containing the X-aws-ec2-metadata-token-ttl-seconds header to generate a session token) cannot be compromised via this vector. Additionally, the strict 2-second socket timeout configured on the HTTP client prevents attackers from retrieving responses from slow internal endpoints.

Impact Assessment

CVE-2026-69158 carries a CVSS v3.1 base score of 8.6 (High) under the official vector CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:N/A:N.

The Scope: Changed (S:C) and Confidentiality: High (C:H) ratings reflect the fact that while the vulnerable component is the Atomic Server application, the security impact extends to separate security domains reachable from the server's network interface. Because the response body is reflected to the attacker, any sensitive data accessible via unauthenticated HTTP GET requests within the internal network or localhost boundary is completely exposed.

In cloud deployments using IMDSv1 (AWS, GCP endpoints that do not enforce custom Metadata-Flavor headers, or DigitalOcean/Alibaba Cloud metadata services), successful exploitation leads directly to cloud account compromise through stolen instance profile credentials. In containerized or on-premises deployments, attackers can extract sensitive telemetry, configuration data, and database contents from adjacent microservices that rely on network-perimeter isolation rather than service-level authentication.

While Integrity (I:N) and Availability (A:N) are officially scored as None in the NVD/CNA assessment because the primary primitive is a read-only GET request, secondary integrity impacts can occur if internal web interfaces reside on the same network and perform state-changing actions upon receiving GET requests. As of current threat intelligence tracking, the vulnerability has an EPSS score of 0.00482 (42.23rd percentile) and is not listed in the CISA Known Exploited Vulnerabilities (KEV) catalog, though a functional public exploit tool is widely available.

Remediation

The primary remediation for CVE-2026-69158 is to upgrade atomic-server and atomic_lib to versions containing the ssrf_guard transport restrictions.

Patched Versions

  • ontola/atomic-server: Upgrade to version 0.40.3 (or the backported patch release 0.40.2).
  • atomic_lib (for Rust consumers integrating the library directly): Upgrade to version >= 0.40.1.

> [!WARNING] > Ensure that the environment variable ATOMIC_ALLOW_PRIVATE_FETCH is not set to 1 or true in production environments exposed to untrusted networks, as this variable completely disables the SSRF IP and DNS restrictions introduced in the patch.

Workarounds and Defense-in-Depth

For environments where an immediate binary or container upgrade is not feasible, apply the following mitigations:

  1. Reverse Proxy / WAF Endpoint Blocking: Block external access to /bookmark and /import at the ingress reverse proxy (Nginx, Envoy, Cloudflare, or AWS ALB) if external URL bookmarking and remote importing are not required:
    location ~ ^/(bookmark|import) {
        deny all;
        return 403;
    }
  2. Enforce Cloud IMDSv2: On AWS EC2 instances, disable IMDSv1 by requiring session tokens and restricting the PUT response hop limit to 1:
    aws ec2 modify-instance-metadata-options \
        --instance-id <INSTANCE_ID> \
        --http-endpoint enabled \
        --http-tokens required \
        --http-put-response-hop-limit 1
  3. Host/Container Egress Filtering: Use iptables, nftables, or Kubernetes NetworkPolicy egress rules to prevent the Atomic Server process from initiating outbound connections to RFC1918 private subnets (10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16) and link-local metadata ranges (169.254.0.0/16).

Official Patches

OntolaOfficial GitHub Security Advisory for CVE-2026-69158 (GHSA-ff87-73jp-f3v4)
OntolaAtomic Server v0.40.3 Official Release Notes

Fix Analysis (3)

Technical Appendix

CVSS Score
8.6/ 10
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:N/A:N
EPSS Probability
0.48%
Top 58% most exploited

Affected Systems

ontola/atomic-serveratomic_lib

Affected Versions Detail

Product
Affected Versions
Fixed Version
atomic-server
Ontola
< 0.40.20.40.2 / 0.40.3
atomic_lib
Ontola
< 0.40.10.40.1
AttributeDetail
CVE IDCVE-2026-69158 (GHSA-ff87-73jp-f3v4)
Vulnerability ClassCWE-918: Server-Side Request Forgery (SSRF)
CVSS v3.1 Score8.6 High (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:N/A:N)
Attack VectorUnauthenticated HTTP GET to /bookmark or POST to /import
EPSS Score0.48% (42.23rd Percentile)
Exploit StatusPublic Proof-of-Concept (PoC) Available
CISA KEV StatusNot Listed
Patched Versionsatomic-server 0.40.2 / 0.40.3, atomic_lib 0.40.1

MITRE ATT&CK Mapping

T1190Exploit Public-Facing Application
Initial Access
T1005Data from Local System
Collection
T1552.005Cloud Instance Metadata API
Credential Access
T1046Network Service Discovery
Discovery
CWE-918
Server-Side Request Forgery (SSRF)

The web server receives a URL or similar request from an upstream component and retrieves the contents of this URL, without sufficiently ensuring that the request is being sent to the expected destination.

Known Exploits & Detection

GitHubPublic Python Proof-of-Concept exploit script demonstrating IMDSv1 credential extraction, localhost enumeration, and internal network scanning via the /bookmark endpoint.

Vulnerability Timeline

CVE-2026-69158 and GitHub Security Advisory GHSA-ff87-73jp-f3v4 published; patched versions 0.40.2 and 0.40.3 released.
2026-11-17
NVD record updated and public Proof-of-Concept exploit published.
2026-11-18

References & Sources

  • [1]GitHub Security Advisory: GHSA-ff87-73jp-f3v4
  • [2]Official CVE.org Record: CVE-2026-69158
  • [3]NVD Vulnerability Detail: CVE-2026-69158
  • [4]Atomic Server v0.40.3 Release Notes
  • [5]Fix Commit (v0.40.2 Patch Release)
  • [6]Fix Commit (SSRF Guard Implementation)
  • [7]Fix Commit (Async reqwest SSRF Guard Adaptation)
  • [8]Public Proof-of-Concept Repository (LLCForge)
  • [9]CVEProject cvelistV5 Record

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

•18 minutes 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
1 views•10 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