Summary
A server-side request forgery vulnerability in Glean allows a malicious RSS feed to influence which URLs the server fetches for full-text extraction. If an attacker can submit or control a feed URL and retrieve resulting entries, the issue may expose internal services, private network resources, or cloud metadata responses.
Affected context
The vulnerability affects Glean deployments before the relevant fix when the feed discovery and background fetching workflow processes attacker-controlled RSS content. RSS item links can reach the full-text extraction path without sufficient network-level restrictions, and fetched responses may be stored in entries that are later accessible through the application API.
Exploit preconditions
- Attack surface: Feed discovery, RSS parsing, background feed fetching, and entry retrieval APIs
- Required access: Ability to submit or cause the application to process a feed containing attacker-controlled item links
- Trigger point: Background full-text extraction of an RSS item URL
- Response access: Ability to retrieve the resulting entry through the application API
- Why exploitation is possible: The server follows untrusted URLs without adequately restricting loopback, private, link-local, or cloud-metadata destinations, while retaining the fetched response
Why this happens
The underlying bug is insufficient validation and enforcement of destination boundaries for server-side HTTP requests. RSS content is treated as a trusted source of URLs, allowing values assigned to parsed entry links to flow into the full-text fetcher without robust network-level controls. This maps to CWE-918: Server-Side Request Forgery, where attacker-influenced input causes a server to make requests to unintended resources.
Potential impact
- Internal services and ports may be probed
- Private network applications or configuration data could be disclosed
- Cloud instance metadata and temporary access tokens may be exposed
- Network perimeter controls could be bypassed
- Retrieved internal content may be stored and disclosed through application entries
- The server's network position could be misused for reconnaissance
General mitigation guidance
Mitigation generally focuses on reducing trust in feed-provided URLs and enforcing destination-aware request controls.
Common defensive patterns include:
- Permit only the URL schemes and destination classes required for feed processing
- Resolve hostnames and reject loopback, private, link-local, multicast, reserved, and cloud-metadata address ranges
- Revalidate destinations after DNS resolution and across redirects
- Apply strict outbound network policies and egress proxies
- Separate feed-fetching workers from sensitive internal networks
- Limit response size, request duration, redirect count, and accessible ports
- Avoid storing sensitive upstream responses in user-readable content fields
- Run workers with least privilege and restrict access to instance metadata services
How teams detect issues like this
Detection approaches can combine code and runtime analysis:
- Use static analysis to trace user-controlled URLs into HTTP clients, URL openers, and feed extractors
- Review code for missing scheme, hostname, IP-range, redirect, and DNS-rebinding protections
- Monitor outbound requests from workers to loopback, private, link-local, and metadata endpoints
- Enforce egress policies that deny unnecessary internal destinations and nonessential ports
- Alert when fetched responses contain metadata-service markers, internal hostnames, or unexpected administrative content
- Use automated security review tools to identify SSRF data flows and unvalidated URL sinks

