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.

