
Loading

Loading
We use strictly necessary cookies to run this site, and analytics cookies to understand how it's used. See our Privacy Policy for details.
A GitHub-reviewed security advisory, not necessarily under active exploitation the way our CISA KEV advisories are, but a real, disclosed vulnerability in an open-source dependency.
Affected packages
Vulnerable: <= 0.40.1
Details
Atomic-Server exposes a GET /bookmark endpoint that fetches an attacker-supplied URL server-side, parses the response, and reflects the fetched content back to the caller. The endpoint requires no authentication and performs no authorization of its own, and the underlying fetch helper applies no allow-list or private-IP deny-list. An unauthenticated attacker with network reach to the server can force it to issue arbitrary outbound HTTP GET requests to internal-only hosts (loopback services, internal admin panels, link-local cloud-metadata) and read the response body back. This is a full-response SSRF, not a blind one.
server/src/appstate.rs:69 (store.add_endpoint(plugins::bookmark::bookmark_endpoint())).ForAgent::Public: server/src/helpers.rs:168-183 (get_client_agent).get_resource_extended, when the subject matches an endpoint path the function returns via call_endpoint BEFORE the hierarchy::check_read authorization call: lib/src/db.rs:1010-1017 (if is_endpoint { return self.call_endpoint(...) }, and check_read sits just after at :1017, never reached).call_endpoint performs no authorization itself; it only matches the path and invokes the handler: lib/src/db.rs:662-706.for_agent: _) and fetches the url query parameter directly: server/src/plugins/bookmark.rs:45-76 (let content = fetch_data(&path)?;).fetch_body validates only url.starts_with("http"): lib/src/client/helpers.rs:78-91. A repo-wide grep finds no is_loopback / is_private / 127.0.0.1 / 169.254 / localhost deny-list anywhere in lib/src or server/src, and no host allow-list.name, description, image and preview (markdown) fields, which are returned to the caller: server/src/plugins/bookmark.rs:79-110. This is what makes it a full-response (not blind) SSRF; even plaintext internal responses are wrapped into the preview markdown.GET /bookmark?url=http://127.0.0.1:<internal-port>/&name=x # internal loopback service
GET /bookmark?url=http://169.254.169.254/latest/meta-data/&name=x # IMDSv1 cloud metadata
No authentication headers. The returned resource reflects the fetched content in its name / description / preview fields, so the attacker reads the internal target's response body.
The endpoint-dispatch path returns at lib/src/db.rs:1011 (return self.call_endpoint(...)) before the check_read call at :1017, and there is no authorization inside call_endpoint (:662-706). The handler discards the caller (for_agent: _, bookmark.rs:49), so the endpoint can never enforce per-agent access. fetch_body validates only url.starts_with("http") (helpers.rs:83); no loopback/private/link-local deny-list exists anywhere in the source. No corresponding SSRF/security entry exists in CHANGELOG.md.
An unauthenticated attacker with network reach to the server can:
Because the response body is reflected, this is a high-value full-response SSRF. The only precondition is network reach to the server.
Severity: High, CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:N/A:N = 8.6.
Honest caveats (do not refute the finding): the ureq client uses a 2-second timeout, which limits slow targets; AWS IMDSv2 requires a PUT token, so plain GET metadata retrieval may fail there. IMDSv1 and any internal HTTP service or admin panel that answers a plain GET remain fully reachable and reflected.
Add a central SSRF guard inside fetch_body (lib/src/client/helpers.rs): resolve the target host and reject loopback, link-local, RFC1918 private, CGNAT and unique-local ranges, and reject non-http(s) schemes. Re-validate after DNS resolution (to prevent DNS-rebinding) and after each redirect hop. Enforce authorization on endpoint dispatch: run check_read (or a per-endpoint policy) for outbound-fetching endpoints instead of short-circuiting before it at lib/src/db.rs:1010-1012, and at minimum require an authenticated, authorized agent for /bookmark. Optionally add an operator-configurable allow-list of fetchable hosts.
develop 2026-07-03: the handler still discards the caller (for_agent: _) and calls fetch_data(url), and fetch_body still validates only url.starts_with("http") with no private-IP deny-list (still vulnerable).Reported by Ray Sabee, Whitehat Security (https://whitehatsecurity.nl/), GitHub @raysabee. Please credit "Ray Sabee / Whitehat Security / whitehatsecurity.nl" on the advisory and in any release notes. Coordinated disclosure: nothing will be published before a fix is available.
Note: two related findings exist in the same repo and can be handled in this advisory or alongside it: F-ATOMIC-SSRF-002 (a blind pre-auth SSRF in POST /import via the SAME fetch_body root cause, so one central fix covers both) and F-ATOMIC-LFI-001 (authenticated path-traversal file read in GET /download, a separate sink in download.rs).
EPSS, exploit probability
Low0.48%
estimated chance of real-world exploitation in the next 30 days, higher than 42.2% of every CVE FIRST.org scores
Refreshed 11/18/2026, via FIRST.org's EPSS model, not CVSS, this measures likelihood of exploitation, not how severe it would be.
More rust advisories
Talk to us about this
Find out whether this dependency (or others like it) is actually reachable in your codebase.
Get help patching, or building dependency-scanning into your pipeline going forward.
A secure code review or supply chain review finds this before an advisory does.