/

CVE-2026-10771

Severity:

HIGH RISK

(7.3)

Server-Side Request Forgery (CWE-918) in crmeb_java base64 QR Code Endpoint

CVE-2026-10771

Deferred

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-918

Impact:

Unauthorized access to internal and external network resources via server-initiated HTTP requests

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 crmeb_java 1.4 allows an attacker to control the URL passed into RestTemplate.getForEntity within the base64 QR code endpoint.

By manipulating the url argument, a remote attacker can coerce the server into making arbitrary outbound HTTP requests, potentially reaching internal services that are not directly exposed to the internet.

Affected context

The vulnerability occurs in deployments of crmeb_java 1.4 where the base64 QR code endpoint accepts a user-supplied URL and passes it to RestTemplate.getForEntity without sufficient validation.

The server environment must be able to initiate outbound HTTP requests, and internal or sensitive services must be at least partially reachable from the application host for the issue to become high-risk.

Typical affected contexts include environments where application nodes can access internal APIs, metadata services, or management interfaces over HTTP/HTTPS.

Exploit preconditions

  • Attack surface: Public or partner-facing base64 QR code endpoint that accepts a URL parameter.
  • Required access: Ability to send crafted HTTP requests to the vulnerable endpoint (no local access required).
  • Trigger point: Passing an attacker-controlled URL into RestTemplate.getForEntity inside RestTemplateUtil.java.
  • Why exploitation is possible: The server treats the provided URL as trustworthy and performs outbound HTTP requests without adequate origin validation, allow-listing, or scheme restrictions.

Why this happens

The root cause aligns with CWE-918: Server-Side Request Forgery (SSRF).

The implementation of the base64 QR code functionality uses RestTemplate.getForEntity with a URL value derived directly from user input.

Without robust validation, normalization, or restriction of the target addresses, the server can be tricked into making HTTP requests to arbitrary locations, including internal hosts and services.

This reflects an insecure pattern where untrusted input controls server-initiated network communication, breaking the intended network isolation and trust boundaries.

Potential impact

  • Unauthorized access to internal HTTP services that are not publicly exposed.
  • Interaction with cloud metadata endpoints, which could lead to credential or token exposure.
  • Discovery and probing of internal network topology and services.
  • Bypassing network-layer access controls or IP allow-lists by routing traffic through the vulnerable server.
  • Potential pivoting to additional vulnerabilities in internal services (e.g., exploiting other bugs via SSRF).

General mitigation guidance

Effective mitigation focuses on constraining and sanitizing server-initiated HTTP requests that depend on user input.

Common defensive patterns include:

  • Implementing strict allow-lists of permitted domains, hosts, or URL prefixes for any outbound requests.
  • Validating and normalizing URLs before use, including enforcing allowed schemes (e.g., HTTPS only) and blocking IP literals, localhost, and private address ranges where appropriate.
  • Decoupling user input from direct network calls by using indirection, such as mapping identifiers to pre-approved resources instead of accepting arbitrary URLs.
  • Applying least-privilege networking at the infrastructure level (e.g., egress controls, firewall rules) to limit which destinations the application can reach.
  • Avoiding unnecessary server-side fetching of external content when a client-side approach or static resources would suffice.

How teams detect issues like this

Detection can rely on both code-centric and infrastructure-centric approaches:

  • Static analysis: Configure rules to flag uses of HTTP clients (such as RestTemplate, HttpClient, or similar APIs) where URL values are derived from request parameters, headers, or other untrusted sources.
  • Code review: Look for endpoints that accept URLs or resource locators and then initiate outbound requests; pay special attention to utility classes like RestTemplateUtil.
  • Logging and monitoring: Enable detailed logging of outbound HTTP destinations from the application and alert on unusual internal or non-standard hosts being contacted.
  • Policy enforcement: Use CI/CD governance to prevent merging code that introduces new unbounded outbound HTTP calls tied to user-controlled data, optionally leveraging automated security review tools.

Sources

SourceLink
github.comgithub.com/crmeb/crmeb_java/
github.comgithub.com/crmeb/crmeb_java/issues/35
vuldb.comvuldb.com/cve/CVE-2026-10771
vuldb.comvuldb.com/submit/831421
vuldb.comvuldb.com/vuln/368137
vuldb.comvuldb.com/vuln/368137/cti

Frequently asked

questions

Exploitability is high when the vulnerable endpoint is internet-accessible and the application host can reach internal or sensitive HTTP services. Public exploit information further lowers the barrier for attackers.

The description does not require authentication, so exploitation typically only needs network access to the endpoint. Actual requirements depend on how the endpoint is integrated and whether it is protected by authentication or API gateways in a specific deployment.

Constrain outbound requests by enforcing strict allow-lists and hardcoded destinations, remove or minimize direct use of user-supplied URLs, and ensure URL validation blocks access to localhost and internal address ranges.

Treat any user-controlled URL or host input as untrusted, avoid passing it directly into HTTP clients, enforce validation and allow-lists by default, and include SSRF-focused checks in code review and automated security testing processes.

Find out what's already
exploitable in your codebase.