fix(s3api): evaluate aws:SourceIp from the direct TCP peer, not forwarded headers (#11231)

* fix(s3api): use direct peer IP for aws:SourceIp in bucket policy engine

extractSourceIP in the bucket-policy engine trusted X-Forwarded-For and
X-Real-Ip whenever the TCP peer looked private (loopback/RFC1918/link-local),
with no configurable trusted-proxy allowlist. In containerized deployments
the gateway peer is almost always private, so any caller reaching it directly
or from a co-located workload could spoof aws:SourceIp and bypass
IpAddress/NotIpAddress bucket-policy restrictions.

Always return the direct peer address (r.RemoteAddr), matching AWS S3
semantics. Remove the now-unused isPrivateIP helper and header-trust branch.

Update TestExtractConditionValuesFromRequestSourceIPPrecedence to assert the
peer IP is used regardless of forwarding headers, and add regression tests
TestExtractSourceIP_IgnoresForwardedHeaders and
TestExtractSourceIP_EnforcesIPRestrictionPolicy.

* fix(s3api): use direct peer IP for aws:SourceIp in IAM role/session policies

The IAM middleware's extractSourceIP trusted X-Forwarded-For and X-Real-IP
whenever the TCP peer looked private (loopback/RFC1918/link-local), with no
configurable trusted-proxy allowlist. In containerized deployments the gateway
peer is almost always private, so any caller reaching it directly or from a
co-located workload could spoof aws:SourceIp and bypass IpAddress/NotIpAddress
conditions on role and session policies (IsPrincipalActionExplicitlyDenied).

Always return the direct peer address (r.RemoteAddr), matching AWS S3
semantics. Remove the now-unused isPrivateIP helper, privateNetworks table,
and its init().

Update TestRequestContextExtraction and TestIPBasedPolicyEnforcement to assert
the peer IP is enforced regardless of forwarding headers, and add regression
test TestUserInlinePolicySourceIpCondition_IgnoresForwardedHeaders.
This commit is contained in:
Chris Lu authored and GitHub committed 2026-09-08 15:09:31 -07:00
1 parent 557fffa350
commit b88156fe6b
5 files changed
+99 -153

No files matched your search

+5 -68
View File
@@ -519,23 +519,11 @@ func injectSSEForMultipart(conditions map[string][]string, inheritedSSE string)
return modified
}
// extractSourceIP returns the best-effort client IP address for condition evaluation.
// Preference order: X-Forwarded-For (first valid IP), X-Real-Ip, then RemoteAddr.
// IMPORTANT: X-Forwarded-For and X-Real-Ip are trusted without validation.
// When the service is exposed directly, clients can spoof aws:SourceIp unless a
// reverse proxy overwrites these headers.
// isPrivateIP returns true if the given IP is considered a "trusted proxy"
// address, such as loopback, link-local, or RFC1918 private ranges.
// isPrivateIP returns true if the given IP is considered a "trusted proxy"
// address, such as loopback, link-local, or private ranges.
func isPrivateIP(ip net.IP) bool {
if ip == nil {
return false
}
return ip.IsLoopback() || ip.IsLinkLocalUnicast() || ip.IsPrivate()
}
// extractSourceIP returns the direct TCP peer address for aws:SourceIp
// condition evaluation. Forwarding headers (X-Forwarded-For, X-Real-Ip) are
// intentionally ignored: without a configurable trusted-proxy allowlist they
// are client-controlled and spoofable, which would let a caller behind a
// private-looking peer bypass any aws:SourceIp restriction.
func extractSourceIP(r *http.Request) string {
if r == nil {
return ""
@@ -546,7 +534,6 @@ func extractSourceIP(r *http.Request) string {
return ""
}
// Fall back to unix socket markers or other non-IP placeholders.
if remoteAddr == "@" {
return remoteAddr
}
@@ -558,59 +545,9 @@ func extractSourceIP(r *http.Request) string {
remoteIP := net.ParseIP(host)
if remoteIP == nil {
// Do not return DNS names or unparseable values.
return ""
}
// Only trust forwarding headers when the connection appears to come from
// a trusted proxy (e.g., private/loopback address).
if isPrivateIP(remoteIP) {
if xff := r.Header.Get("X-Forwarded-For"); xff != "" {
// Iterate right-to-left to find the first non-trusted (public) IP
entries := strings.Split(xff, ",")
for i := len(entries) - 1; i >= 0; i-- {
candidate := strings.TrimSpace(entries[i])
if candidate == "" {
continue
}
ip := net.ParseIP(candidate)
if ip == nil {
continue
}
// If the IP is trusted/private, we treat it as another proxy in the chain and continue
if isPrivateIP(ip) {
continue
}
// Found a public/non-trusted IP, return it as the client IP
return ip.String()
}
// If we exhausted the list (all were private/trusted) or found no valid IPs,
// fallback related logic could go here.
// For now, if all are private, we continue to check X-Real-Ip or return RemoteIP?
// The prompt implies we should prefer the extracted IP.
// If all in XFF are private, likely the original client IS private (internal network).
// The best guess for "original client" in a fully trusted chain is the left-most valid IP.
for _, candidate := range entries {
candidate = strings.TrimSpace(candidate)
if ip := net.ParseIP(candidate); ip != nil {
return ip.String()
}
}
}
if xRealIP := strings.TrimSpace(r.Header.Get("X-Real-Ip")); xRealIP != "" {
if ip := net.ParseIP(xRealIP); ip != nil {
return ip.String()
}
}
}
// Default to the actual peer IP when no trusted proxy is detected or the
// forwarding headers are absent/invalid.
return remoteIP.String()
}