/

CVE-2025-62615

Severity:

CRITICAL RISK

(9.8)

SSRF in AutoGPT RSSFeedBlock URL Handling

CVE-2025-62615

Analyzed

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-918

Impact:

Unauthorized network access via SSRF, potentially leading to data exposure or further compromise of internal services

Severity:

CRITICAL RISK

(9.8)

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

AutoGPT's RSSFeedBlock component previously used urllib.request.urlopen on unfiltered user-provided URLs, allowing attackers to coerce the server into making arbitrary HTTP requests.

When exposed in a deployment, this could enable server-side request forgery (SSRF), letting an attacker reach internal services, cloud metadata endpoints, or other network resources not directly accessible from the internet.

Affected context

The vulnerability occurs in AutoGPT deployments where the RSSFeedBlock feature is available and accepts external URLs as input.

Because the component passed these URLs directly to urllib.request.urlopen without validation or restriction, the AutoGPT backend could be tricked into issuing HTTP requests to arbitrary destinations, including localhost, internal network services, or cloud provider metadata endpoints.

Risk is higher in environments where the AutoGPT server has broad network visibility or sensitive services accessible only from within that network.

Exploit preconditions

  • Attack surface: HTTP or API interface that exposes the RSSFeedBlock functionality and allows users or integrated systems to submit RSS feed URLs.
  • Required access: Ability to supply or influence the URL consumed by RSSFeedBlock (e.g., authenticated user with access to relevant workflows, or any external caller if the endpoint is public).
  • Trigger point: Submission of a crafted URL (e.g., pointing to internal IPs, localhost, or sensitive HTTP endpoints) that is then fetched by urllib.request.urlopen on the server.
  • Why exploitation is possible: The URL parameter is treated as trusted and used directly in server-side HTTP requests without sufficient validation, filtering, or network-level egress controls, matching the SSRF pattern described in CWE-918.

Why this happens

The core issue is a lack of input validation and trust boundary enforcement around URLs passed into a server-side HTTP client.

RSSFeedBlock invokes urllib.request.urlopen directly on attacker-controlled URLs, effectively allowing external input to drive the server's outbound HTTP behavior.

This aligns with CWE-918: Server-Side Request Forgery (SSRF), where a server acts as a proxy, making unintended requests to internal or otherwise restricted resources because it fails to constrain or sanitize user-controlled destination addresses and schemes.

Potential impact

  • Access to internal HTTP services that are not exposed to the public internet
  • Interaction with cloud metadata services, potentially leaking credentials, tokens, or configuration secrets
  • Enumeration of internal network structure (ports, services, and technologies)
  • Abuse of the AutoGPT server as a pivot point for further attacks within the hosting network
  • Access to internal dashboards, management APIs, or other sensitive endpoints that trust the server's network location

General mitigation guidance

Effective mitigation centers on strictly controlling where server-side HTTP clients are allowed to connect and treating destination URLs as untrusted input:

  • Introduce allowlists for outbound destinations, such as explicit domains or IP ranges that RSSFeedBlock is permitted to contact, and reject everything else.
  • Disallow or carefully restrict private and link-local address ranges (e.g., 127.0.0.0/8, 10.0.0.0/8, 169.254.0.0/16, 172.16.0.0/12, 192.168.0.0/16) and localhost-style hostnames when processing user-supplied URLs.
  • Enforce URL scheme restrictions (e.g., only https:// and http://), and reject dangerous or unexpected schemes.
  • Add robust URL parsing and normalization before validation, to avoid bypasses via obfuscated or encoded URLs.
  • Apply the principle of least privilege to network egress: configure the runtime environment or container to limit which networks and services the application can reach.
  • Separate components that must access external feeds from components that have access to sensitive internal services, reducing blast radius if SSRF-like behavior appears elsewhere.

How teams detect issues like this

Detection typically combines code-level analysis with runtime monitoring:

  • Static analysis and code review:
  • Flag direct use of generic HTTP clients (e.g., urllib.request.urlopen, requests.get) with user-supplied URLs, especially in blocks or components that process external content.
  • Look for missing validation around host, IP range, port, and protocol before issuing server-side requests.
  • Establish secure coding guidelines requiring outbound network calls to traverse a vetted utility or service that enforces SSRF protections.
  • Automated tooling:
  • Apply SAST rules targeting SSRF patterns (e.g., unvalidated URL parameters passed to HTTP clients).
  • Integrate secret scanning and infrastructure-as-code checks to ensure network egress policies are in place for sensitive services.
  • Runtime and operational monitoring:
  • Monitor outbound traffic from AutoGPT instances for requests to internal IP ranges or cloud metadata endpoints.
  • Use network firewalls or egress proxies that can log and optionally block suspicious destinations or patterns.

Sources

SourceLink
github.comgithub.com/Significant-Gravitas/AutoGPT/security/advisories/GHSA-r55v-q5pc-j57f

Frequently asked

questions

Yes, if the RSSFeedBlock functionality is accessible over a network interface and attackers can supply URLs to it. In that case, they can remotely trigger server-side HTTP requests to arbitrary destinations within the constraints of the server's network connectivity.

The attacker must be able to influence the URL that RSSFeedBlock processes. This could be through a direct API call, a workflow configuration, or a UI field, depending on how AutoGPT is deployed. No direct access to internal resources is required; the server makes those requests on the attacker's behalf.

The most robust fix is to centralize outbound HTTP handling behind a restricted client that enforces strict allowlists, validates and normalizes URLs, blocks private and loopback addresses, and limits protocols and ports. Avoid direct use of low-level HTTP libraries with untrusted URLs.

Design components under the assumption that all external input is untrusted and that any server-side network call can become an SSRF vector. Establish shared utilities for outbound requests with built-in protections, require code reviews to check for direct use of HTTP clients with user-controlled destinations, and back this up with static analysis rules and network egress controls.

Find out what's already
exploitable in your codebase.