Summary
A server-side request forgery vulnerability in GitHub Enterprise Server allowed unauthenticated requests to make the Manage API send crafted outbound traffic to attacker-controlled systems. In affected deployment topologies, an attacker able to observe that traffic could capture a timestamp-based HMAC token and replay it against privileged management agent endpoints.
Affected context
The issue occurs in GitHub Enterprise Server deployments where an unauthenticated endpoint accepts attacker-controlled cluster configuration and causes the Manage API to issue gateway-to-agent requests. Risk depends on the deployment topology and on whether an attacker can intercept the resulting outbound request. High-availability deployments are not affected according to the vulnerability description.
Exploit preconditions
- Attack surface: An unauthenticated cluster-configuration endpoint and the Manage API's outbound request mechanism
- Required access: No application authentication is required; the attacker must also be positioned to observe or intercept the outbound request
- Trigger point: Processing attacker-supplied cluster configuration and sending a gateway-to-agent management request
- Why exploitation is possible: The request authentication token protects only a timestamp, rather than binding authentication to the destination path and request body, allowing captured authentication material to be replayed against privileged agent endpoints
Why this happens
The vulnerability combines server-side request forgery with insufficient request authentication binding. The server trusted attacker-influenced configuration when selecting an outbound destination, and its HMAC construction authenticated a timestamp without covering the request path or body. This maps primarily to CWE-918: Server-Side Request Forgery, with the weak request binding increasing the risk that intercepted authentication material could be reused for unintended management operations.
Potential impact
- An attacker could cause requests to be sent to attacker-controlled infrastructure
- Sensitive request metadata or authentication material could be exposed
- Captured tokens could potentially be replayed against privileged management endpoints
- Administrative operations or cluster-management state could be altered
- Internal services could be reached from the server's network position
General mitigation guidance
Mitigation generally focuses on reducing outbound request trust and binding authentication to the complete request context.
Common defensive patterns include:
- Allowlisting approved destinations, schemes, ports, and network ranges for server-initiated requests
- Rejecting private, loopback, link-local, and otherwise unintended destinations after DNS resolution and redirect evaluation
- Binding request authentication to the method, destination, path, body, timestamp, and a short-lived nonce
- Preventing attacker-controlled configuration from directly selecting management targets
- Applying network egress controls and least-privilege service identities
- Separating gateway and agent privileges so intercepted credentials have limited value
- Enforcing topology-aware validation before enabling management operations
How teams detect issues like this
Detection can combine static analysis, code review, runtime monitoring, and policy enforcement.
Useful review signals include:
- Request-building code that incorporates user-controlled URLs, hosts, ports, or cluster configuration
- HTTP clients that follow redirects or resolve private addresses without validation
- Authentication or signing logic that omits the HTTP method, path, body, or destination
- Unauthenticated endpoints that initiate privileged server-to-server requests
Runtime controls can monitor unusual outbound destinations, unexpected DNS resolutions, management-agent request patterns, and replayed timestamps or tokens. Automated security review tools and SSRF-focused test cases may help identify these patterns during development.

