Severity:

HIGH RISK

(7.3)

SSRF in ModelScope AgentScope Internal Service

CVE-2026-6605

Deferred

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-918

Impact:

Network Pivoting and Unauthorized Access to Internal Services

Severity:

HIGH RISK

(7.3)

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 (SSRF) vulnerability in ModelScope AgentScope up to version 1.0.18 allows attackers to abuse the _get_bytes_from_web_url helper to make arbitrary network requests from the server's perspective.

When user-controlled URLs are passed to this internal service function without sufficient validation, a remote attacker can pivot through the application to access internal services or external endpoints that would otherwise be unreachable.

Affected context

The issue occurs in deployments using ModelScope AgentScope (versions up to 1.0.18) where the internal service utility _get_bytes_from_web_url is reachable—directly or indirectly—from externally influenced input.

The vulnerability is relevant when:

  • URLs are accepted from users, plugins, or other untrusted sources
  • These URLs are passed to _get_bytes_from_web_url without strict allowlisting or sanitization
  • The AgentScope service has network visibility into internal infrastructure, metadata services, or sensitive external endpoints

Exploit preconditions

  • Attack surface: Any API, agent, or workflow that forwards user-supplied URLs into the internal _get_bytes_from_web_url helper.
  • Required access: Remote ability to submit or influence URL parameters handled by the affected component (e.g., HTTP request fields, agent prompts translated into URLs, configuration fields).
  • Trigger point: Invocation of _get_bytes_from_web_url with attacker-controlled URL data.
  • Why exploitation is possible: The function performs outbound HTTP/HTTPS (or similar) requests without robust validation, allowlisting, or network egress controls, allowing attackers to redirect the server to unintended targets.

Why this happens

This vulnerability stems from insufficient validation of user-influenced URLs before they are used to perform outbound requests from the server.

The _get_bytes_from_web_url function effectively trusts the provided URL and forwards it, enabling attackers to coerce the server into connecting to arbitrary hosts, including internal-only resources.

This maps to CWE-918: Server-Side Request Forgery (SSRF), where a server-side component initiates network requests based on untrusted input without enforcing strict destination controls, enabling attackers to bypass network boundaries and access otherwise protected services.

Potential impact

  • Unauthorized access to internal HTTP services that are not directly exposed to the internet
  • Interaction with cloud provider metadata endpoints, which could lead to credential or token theft
  • Network scanning of internal hosts and ports using the application as a proxy
  • Leveraging the service for anonymized or amplified attacks against third-party targets
  • Potential data exfiltration from internal systems reachable by the AgentScope service

General mitigation guidance

Effective mitigations focus on reducing the trust placed in user-controlled URLs and constraining outbound network behavior:

  • Introduce strict allowlists of permitted domains or hosts for any URL fetch functionality, rejecting all others by default.
  • Enforce robust URL validation, including scheme checks, normalization, and rejection of IP literals, localhost, link-local, or internal address ranges where not explicitly needed.
  • Isolate the component in a segmented network environment with minimal access to internal services and no direct path to sensitive metadata endpoints.
  • Apply principle of least privilege for network egress, using firewall rules or service mesh policies to restrict where the service can connect.
  • Prefer indirect access patterns, such as using dedicated, hardened proxy services for external resource fetching, rather than allowing arbitrary direct outbound requests.

How teams detect issues like this

Detection can be approached at both code and runtime levels:

  • Static analysis and code review:
  • Flag functions that perform outbound requests (requests, HTTP clients, URL fetch helpers) using parameters derived from external input.
  • Look for missing domain allowlists, incomplete URL validation, or direct use of user input in network calls.
  • Establish review checklists for any new or modified features that accept URLs or fetch remote resources.
  • Runtime monitoring and policy enforcement:
  • Monitor outbound traffic patterns from AgentScope services for connections to unexpected internal ranges or metadata endpoints.
  • Use egress filtering, service mesh policies, or firewalls to block requests to private address spaces unless explicitly required.
  • Employ application-level logging to record requested URLs and detect anomalous usage indicative of SSRF attempts.

Sources

SourceLink
gist.github.comgist.github.com/YLChen-007/ced2d438ae79a5a11cea663c1ba2c954
vuldb.comvuldb.com/submit/792225
vuldb.comvuldb.com/vuln/358240
vuldb.comvuldb.com/vuln/358240/cti

Frequently asked

questions

Yes. If an attacker can supply or influence a URL that is passed into the vulnerable _get_bytes_from_web_url path, they can trigger SSRF remotely without local access.

The attacker typically needs only the ability to interact with an exposed API, agent, or workflow that accepts URLs or data later interpreted as URLs. No direct access to internal networks is required, as the application issues the requests on the attacker's behalf.

The most robust fix is to strictly constrain outbound requests: implement domain or endpoint allowlists, perform thorough URL validation and normalization, and ensure that any function fetching remote resources cannot reach arbitrary hosts or internal address spaces.

Treat all externally influenced URLs as untrusted, require security review for any outbound network feature, enforce network egress controls at the infrastructure layer, and integrate static analysis or linting rules that highlight unvalidated network calls in code review and CI pipelines.

Find out what's already
exploitable in your codebase.