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
healthUrlormanagementUrlvalues 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.

