/

CVE-2026-62242

Severity:

HIGH RISK

(8.6)

SSRF (CWE-918) in Spring Boot Admin Server proxy

CVE-2026-62242

Deferred

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-918

Impact:

Exposure of internal services and secret exfiltration via SSRF

Severity:

HIGH RISK

(8.6)

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

Spring Boot Admin Server before 4.1.2 contains a server-side request forgery vulnerability in its instance registration and actuator proxy features.

By registering fake instances with attacker-controlled healthUrl or managementUrl values, unauthenticated attackers can coerce the server into calling internal services and return their responses, exposing sensitive data such as cloud credentials.

Affected context

This vulnerability appears in Spring Boot Admin Server deployments that allow public instance registration and use the actuator proxy to query health or management endpoints.

It is most relevant when the Admin Server has network reachability to internal services, cloud metadata endpoints, or private IP ranges, and does not apply strict validation of target URLs provided by registered instances.

Environments where the Admin Server is placed on a trusted network segment or has IAM roles attached (for cloud APIs) are particularly exposed.

Exploit preconditions

  • Attack surface: HTTP endpoints that accept instance registration or metadata for monitored services (e.g., registration APIs).
  • Required access: Network access to the Admin Server's registration interface; no authentication is needed in vulnerable configurations.
  • Trigger point: Supplying crafted healthUrl or managementUrl values that point to internal or cloud metadata endpoints, causing the server to fetch them via its actuator proxy.
  • Why exploitation is possible: The server trusts user-provided URLs and forwards requests without enforcing restrictions on private address ranges, metadata endpoints, or non-public hosts, allowing the attacker to pivot through the server's network position.

Why this happens

The underlying issue is a classic server-side request forgery (SSRF) pattern where a backend component performs HTTP requests based on unvalidated, user-controlled URLs.

In this case, the Admin Server's registration flow accepts health and management endpoint URLs from instances and uses them to drive outbound HTTP requests via an actuator proxy.

Because the system does not constrain the allowed destinations (e.g., by validating hostnames, IP ranges, or schemes against a safe list), an attacker can register a fake instance whose URLs point to internal infrastructure or cloud provider metadata services.

This maps to CWE-918: Server-Side Request Forgery (SSRF), where the application becomes an unintended proxy to internal resources by trusting external input to define request targets.

Potential impact

  • Attackers may exfiltrate cloud credentials and access tokens from metadata endpoints.
  • Attackers could query internal HTTP services that are not exposed externally.
  • Attackers may obtain configuration files or sensitive diagnostic information from internal management interfaces.
  • Attackers could use the SSRF to assist with lateral movement or environment discovery.
  • Attackers may indirectly influence internal services (e.g., triggering state changes via management endpoints) if those endpoints accept side-effecting requests.

General mitigation guidance

Effective mitigation focuses on reducing trust in caller-supplied URLs and constraining outbound requests from the Admin Server.

Common patterns include validating instance-provided URLs against allowed hostnames or domains, rejecting private or link-local IP ranges, and blocking access to known metadata endpoints and other sensitive infrastructure.

Designs that avoid dynamic URL use—such as deriving management endpoints from vetted service registration data or a static configuration—help eliminate SSRF risk.

Deployments can harden the Admin Server by limiting its network reach (e.g., no direct connectivity to cloud metadata services) and ensuring it runs with least-privilege credentials that do not grant broad access to secrets, even if an SSRF occurs.

How teams detect issues like this

Detection often starts with reviewing how URLs are accepted and used in instance registration and actuator proxy code, looking for patterns where user-controlled values flow into HTTP clients without validation.

Static analysis rules can flag outbound HTTP calls that consume untrusted URL parameters or fail to enforce host/IP restrictions.

During code review, focus on registration endpoints, health/management URL handling, and any proxy-like components, checking for allowlists, IP range filters, and scheme enforcement.

Runtime monitoring can complement this by logging outbound requests from the Admin Server, alerting on access to private address ranges, metadata services, or unusual internal hosts.

Organizations may also employ automated security testing tools to probe for SSRF by attempting to register instances pointing to controlled endpoints and validating that internal responses cannot be obtained.

Sources

SourceLink
github.comgithub.com/codecentric/spring-boot-admin/commit/1f991ea013e46360b8f8fb63fe4ad20a9bf0d551
github.comgithub.com/codecentric/spring-boot-admin/issues/5452
github.comgithub.com/codecentric/spring-boot-admin/pull/5464
github.comgithub.com/codecentric/spring-boot-admin/releases/tag/4.1.2
vulncheck.comvulncheck.com/advisories/spring-boot-admin-server-ssrf-via-unauthenticated-instance-registration

Frequently asked

questions

Exploitability is broad in environments where the Admin Server's registration endpoints are reachable without authentication and the server can access internal services or cloud metadata endpoints. In such setups, an internet-based attacker can abuse the Admin Server as a proxy into the internal network.

No, the described vulnerability can be triggered by unauthenticated attackers who can reach the registration interface. They only need to supply crafted healthUrl or managementUrl values as part of instance registration.

The safest approach is to treat all externally provided URLs as untrusted and enforce strict outbound request policies: use allowlists for target hosts or domains, block private and link-local IP ranges, deny known metadata endpoints, and avoid using arbitrary user-supplied URLs for backend HTTP calls.

Future designs should avoid proxying arbitrary user-defined URLs and instead rely on controlled configuration or service discovery mechanisms. Combine network-layer egress controls, least-privilege roles for servers, and systematic validation of any input that influences outbound connections, with SSRF-focused checks integrated into code review and automated security testing.

Find out what's already
exploitable in your codebase.