/

CVE-2026-45082

Severity:

HIGH RISK

(7.6)

SSRF in Karakeep Internal Request Processing

CVE-2026-45082

Deferred

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-918

Impact:

Internal Network Access / SSRF

Severity:

HIGH RISK

(7.6)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

Summary

Karakeep contained a Server-Side Request Forgery (SSRF) protection bypass that allowed crafted HTTP redirect chains to circumvent existing network destination filters.

Under specific conditions, an authenticated user could coerce the application's crawler and video download components into making requests to internal Docker network services reachable from the server environment.

Affected context

The vulnerability appears in Karakeep's server-side components that perform outbound HTTP requests and automatically follow redirects, such as:

  • Link preview or crawler-related functionality
  • Video download and processing flows

It is relevant when:

  • The application is deployed in an environment with access to internal/private network resources (for example, Docker network services)
  • SSRF protections rely primarily on validating the initial request target and do not comprehensively validate each redirect hop or final resolved destination
  • Authenticated users can supply or influence URLs that these components fetch on their behalf

Exploit preconditions

  • Attack surface: Server-side HTTP clients used by Karakeep to fetch remote content (crawlers, video downloaders, and similar subsystems).
  • Required access: Valid authenticated user ability to submit or configure URLs that are subsequently fetched by the server.
  • Trigger point: The application follows attacker-controlled HTTP redirect chains when resolving user-supplied URLs.
  • Why exploitation is possible: SSRF defenses focused on the initial request URL and did not robustly re-check each redirect target, allowing a benign-looking external URL to redirect into internal/private addresses accessible from the Karakeep runtime environment.

Why this happens

The core issue aligns with CWE-918: Server-Side Request Forgery (SSRF), where a server-side component performs network requests based on user-controlled input without fully constraining the reachable destinations.

In this case, the underlying pattern is:

  • An HTTP client that automatically follows redirects
  • SSRF filtering logic that validates only the initial URL or performs incomplete checks across redirect hops
  • A deployment environment where internal/private services (e.g., Docker network endpoints) are reachable from the application

Because each new redirect location was not consistently subjected to the same strict validation and allow/deny rules as the original URL, an attacker could chain redirects so the final effective request targeted internal services, bypassing intended isolation.

Potential impact

  • Access to internal HTTP services exposed on the Docker network that are not directly reachable from the public internet
  • Interaction with internal-only administrative panels, debug endpoints, or metadata services depending on the environment configuration
  • Potential information disclosure from internal APIs or services (for example, service version data, configuration endpoints, or status pages)
  • Assistance in further compromise if internal services trust the application's network location (for instance, acting as a pivot point within the infrastructure)

General mitigation guidance

Effective mitigation focuses on constraining outbound requests and normalizing and validating every resolved endpoint, not just the initial URL:

  • Enforce strict allow-listing of outbound destinations or network ranges that server-side HTTP clients may contact, especially for crawler and downloader components.
  • Apply consistent host, scheme, and IP validation after each redirect hop, resolving hostnames to addresses and rejecting private, link-local, or otherwise sensitive ranges.
  • Disable or tightly control automatic redirect following for user-supplied URLs, or impose a redirect policy that validates each intermediate and final location.
  • Segregate internal services from application-facing networks where possible, and apply network-level controls (firewalls, Docker network policies) to reduce reachable attack surface.
  • Treat all user-provided URLs as untrusted, and avoid granting those code paths elevated privileges or unrestricted network visibility.

How teams detect issues like this

Detection can leverage a mix of code-level and operational approaches:

  • Static analysis and code review:
  • Flag HTTP client usage that both consumes user-controlled URLs and follows redirects automatically.
  • Look for SSRF filters that only inspect the original URL string without re-validation after DNS resolution or redirects.
  • Review crawler and download components for lack of clear allow-lists or network segmentation assumptions.
  • Dynamic testing and security assessment:
  • Use security testing tools or scripts to submit URLs that redirect through multiple hops, including to known private IP ranges or reserved hostnames, and observe whether requests are completed.
  • Incorporate SSRF-focused test cases into automated integration tests where possible.
  • Operational monitoring:
  • Log outbound HTTP destinations for high-risk components and alert on attempts to reach internal/private ranges or unexpected hosts.
  • Employ egress filtering and monitor firewall logs for blocked or unusual internal-bound HTTP requests from the application.

Sources

SourceLink
github.comgithub.com/karakeep-app/karakeep/security/advisories/GHSA-g647-327m-79g9

Frequently asked

questions

Exploitation requires authenticated access with the ability to submit or influence URLs processed by Karakeep's crawler or video download flows. It is not a fully unauthenticated issue, but within an authenticated session an attacker may leverage it to reach internal services.

The attacker needs valid user-level access sufficient to cause the application to fetch arbitrary URLs—such as creating or managing bookmarks, or triggering video or content downloads. No direct network access to the internal environment is necessary, as the application performs the requests on their behalf.

The most robust pattern is to combine strict outbound allow-listing with comprehensive validation of every effective request target, including all redirects. This means resolving hostnames to IPs and rejecting private or sensitive networks, while also minimizing or disabling automatic redirect following for user-controlled URLs where feasible.

Design server-side HTTP interactions with the assumption that all user-provided URLs are untrusted and potentially malicious. Implement centralized SSRF controls that handle DNS resolution, redirect policies, and allow-lists; enforce network segmentation to reduce internal exposure; and include SSRF-focused checks in code review, static analysis, and integration testing pipelines.

Find out what's already
exploitable in your codebase.