/

CVE-2026-54339

Severity:

HIGH RISK

(7.7)

Server-Side Request Forgery (CWE-918) in Glean RSS Tool

CVE-2026-54339

Deferred

Vulnerability type

Category:

Server-Side Request Forgery

CWE:

CWE-918

Impact:

Internal Network Access and Response Disclosure

Severity:

HIGH RISK

(7.7)

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

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

Sources

SourceLink
github.comgithub.com/LeslieLeung/glean/commit/cdc05dd34df58d8d210e0cbed0ccc60108e4eeed
github.comgithub.com/LeslieLeung/glean/releases/tag/v0.2.6
github.comgithub.com/LeslieLeung/glean/security/advisories/GHSA-78qf-q8fg-jcpg

Frequently asked

questions

It may be exploitable through the application's feed-processing functionality when an attacker can submit or influence a feed containing malicious item links and can access the resulting entries.

No. The server performs the outbound request from its own network position, so the attacker generally needs application-level access to the feed workflow rather than direct internal connectivity.

Treat all feed-provided URLs as untrusted, enforce strict destination and redirect validation, and combine application-layer checks with network egress restrictions.

Apply centralized SSRF-safe request handling, restrict worker network privileges, validate resolved addresses, monitor outbound traffic, and avoid exposing fetched responses without appropriate content and destination controls.

Find out what's already
exploitable in your codebase.