Severity:

HIGH RISK

(7.3)

SSRF in mingSoft MCMS Editor Endpoint catchImage Function

CVE-2026-4953

Deferred

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-918

Impact:

Network Pivoting and Access to Internal Resources via SSRF

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

mingSoft MCMS up to version 5.5.0 contains a server-side request forgery (SSRF) flaw in the catchImage function of BaseAction.java, used by the Editor endpoint to fetch remote images.

By manipulating the catchimage argument, a remote attacker can coerce the server into making arbitrary outbound HTTP requests, potentially reaching internal or otherwise protected services.

Affected context

The vulnerability arises in mingSoft MCMS deployments that expose the Editor endpoint and allow the catchImage functionality to retrieve external resources based on user-supplied input.

When the application trusts the catchimage URL parameter without robust validation, the server can be tricked into initiating HTTP requests to attacker-specified destinations, including internal network addresses or metadata services, depending on the surrounding infrastructure and network controls.

Exploit preconditions

  • Attack surface: HTTP(S) interface of the mingSoft MCMS Editor endpoint exposing the catchImage functionality.
  • Required access: Ability to send crafted requests to the vulnerable endpoint (typically unauthenticated or low-privilege web access, depending on configuration).
  • Trigger point: Submission of a catchimage parameter containing a URL pointing to an attacker-chosen target.
  • Why exploitation is possible: The server-side logic uses the user-controlled catchimage URL to perform outbound requests without adequate origin checks, network segmentation enforcement at the application layer, or strict allow-listing of reachable domains.

Why this happens

This issue is rooted in insufficient validation of user-provided URLs being used to initiate server-side HTTP requests.

The catchImage function is intended to fetch remote images, but it appears to pass the catchimage parameter directly—or with only superficial checks—to an HTTP client API.

This maps to CWE-918: Server-Side Request Forgery, where an attacker can influence how the server connects to remote resources, leveraging its network position and credentials to reach internal or restricted services.

The underlying pattern is a trust boundary failure: external input is treated as a safe target for back-end network calls without verifying that the destination is legitimate and within an expected set of domains or IP ranges.

Potential impact

  • May allow probing and enumeration of internal network services (port scanning via HTTP-based responses).
  • Could enable access to internal-only HTTP endpoints (admin consoles, monitoring interfaces, or internal APIs).
  • Can potentially expose cloud instance metadata or configuration services, leading to credential theft in certain environments.
  • Might facilitate chained attacks, such as bypassing IP-based access controls or reaching vulnerable internal applications for further exploitation.
  • Can be used for limited data exfiltration from internal services that respond over HTTP/HTTPS.

General mitigation guidance

Effective mitigation focuses on constraining where server-initiated requests are allowed to go and reducing trust in user-controlled URLs:

  • Apply strict allow-lists for outbound HTTP requests, restricting the catchImage feature to a set of known, trusted domains or storage endpoints.
  • Implement URL validation that rejects private or non-routable IP ranges, loopback addresses, link-local ranges, and metadata service endpoints.
  • Normalize and parse URLs securely before enforcing validation rules (e.g., resolving redirects carefully, avoiding user-controlled DNS where possible).
  • Consider design changes that avoid direct server-side fetching of arbitrary user-specified URLs, such as using curated media upload endpoints or proxy services with hardened policies.
  • Enforce least privilege for the application's network access, limiting egress routes at the infrastructure level (firewalls, security groups, service mesh policies) to complement application-layer controls.

How teams detect issues like this

Detection typically combines code-based review with runtime monitoring:

  • Static analysis: Look for server-side HTTP client calls (e.g., Java HTTP libraries) that consume user-controlled URL parameters, especially in content fetching or proxy-like features. Flag absence of domain allow-listing or IP range checks.
  • Code review signals: Identify endpoints that accept URL parameters (such as catchimage) and verify that the destination is constrained to trusted hosts. Pay attention to URL normalization, DNS resolution, and handling of redirects.
  • Runtime monitoring: Log outbound HTTP requests with their full target URLs and correlate spikes or requests to unusual internal IPs or metadata services. Alert on patterns that resemble scanning or unexpected internal access.
  • Security testing: Include SSRF test cases in application security assessments, using controlled internal endpoints or canary services to detect misuse of server egress capabilities.
  • Automated SAST and DAST tools can be configured to highlight SSRF-like patterns and unusual outbound request behavior during CI/CD and pre-release testing.

Sources

SourceLink
github.comgithub.com/wing3e/public_exp/issues/3
vuldb.comvuldb.com/?ctiid.353831
vuldb.comvuldb.com/?id.353831
vuldb.comvuldb.com/?submit.777516

Frequently asked

questions

Yes. As long as the Editor endpoint is reachable over the network, a remote attacker can send crafted requests to manipulate the catchimage parameter and attempt SSRF.

In many configurations, only basic web access to the vulnerable endpoint is required. If the Editor is gated behind authentication or role checks, then the attacker needs at least that level of access, but no direct access to internal services is necessary.

The most robust fix is to avoid making server-side requests to arbitrary user-supplied URLs. When the feature is required, enforce strict allow-lists of permitted domains, block internal and non-routable IP ranges, and validate and normalize URLs before use. Combine this with infrastructure-level egress controls to limit where the server can connect.

Adopt a design principle that treats any user-influenced URL as untrusted. Standardize SSRF protections such as URL allow-lists, IP range blocking, and egress network restrictions. Incorporate SSRF-specific checks into code review guidelines, static analysis rules, and security testing so that new features involving server-side HTTP calls are automatically scrutinized for SSRF risk.

Find out what's already
exploitable in your codebase.