From 7f12088ed10d924d11cd7ba8dd0a5c70c9d55123 Mon Sep 17 00:00:00 2001 From: Smith <13200576+smitt14ua@users.noreply.github.com> Date: Sat, 14 Nov 2026 01:32:23 +0200 Subject: [PATCH 1/5] feat(server): log real client IP behind trusted reverse proxies Add trustedProxies (OCAP_TRUSTEDPROXIES) and remoteIPHeaders (OCAP_REMOTEIPHEADERS, default X-Forwarded-For, X-Real-IP). When the direct peer is a trusted proxy, RemoteAddr is replaced with the client address from the headers, X-Forwarded-For read right to left so entries the client sent itself are skipped, and the access log adds the proxy as proxy_addr. No proxy is trusted by default, so headers are ignored. --- README.md | 17 ++++ cmd/ocap-webserver/main.go | 11 ++- internal/server/accesslog.go | 3 + internal/server/accesslog_test.go | 13 ++- internal/server/realip.go | 122 +++++++++++++++++++++++++++ internal/server/realip_test.go | 136 ++++++++++++++++++++++++++++++ internal/server/setting.go | 11 +++ internal/server/setting_test.go | 18 +++- setting.json.example | 2 + 9 files changed, 326 insertions(+), 7 deletions(-) create mode 100644 internal/server/realip.go create mode 100644 internal/server/realip_test.go diff --git a/README.md b/README.md index 93b99d84..bbb250ac 100644 --- a/README.md +++ b/README.md @@ -244,6 +244,23 @@ When `allowedOrigins` is empty the server responds with `Access-Control-Allow-Or } ``` +### Reverse Proxy + +Behind a reverse proxy every request comes from the proxy's address. To log the client's address instead, list the proxies the server should trust. Forwarding headers are read only from requests whose direct peer is one of them; by default no proxy is trusted and headers are ignored. + +| Setting | Env Var | Description | Default | +|---------|---------|-------------|---------| +| `trustedProxies` | `OCAP_TRUSTEDPROXIES` | IPs or CIDR ranges of trusted reverse proxies. Comma-separated in env var. | `[]` (trust none) | +| `remoteIPHeaders` | `OCAP_REMOTEIPHEADERS` | Headers holding the client address, tried in order. Comma-separated in env var. | `["X-Forwarded-For", "X-Real-IP"]` | + +`X-Forwarded-For` is read right to left: trusted proxies are skipped and the first other address is the client, since entries further left can be sent by the client itself. The access log then shows the client in `remote_addr` and the proxy in `proxy_addr`. + +```json +"trustedProxies": ["172.18.0.0/16"] +``` + +Behind Cloudflare and another proxy such as Traefik, either make that proxy trust Cloudflare's ranges (Traefik: `forwardedHeaders.trustedIPs`) and keep `X-Forwarded-For`, or set `remoteIPHeaders` to `["CF-Connecting-IP"]`. In the second case let only Cloudflare reach the proxy, otherwise a client that bypasses Cloudflare can set the header itself. + ## Large Recording Support ### Overview diff --git a/cmd/ocap-webserver/main.go b/cmd/ocap-webserver/main.go index 26f7cf50..36bc09b5 100644 --- a/cmd/ocap-webserver/main.go +++ b/cmd/ocap-webserver/main.go @@ -57,6 +57,10 @@ func app() error { logHandler := slog.NewJSONHandler(logOutput, &slog.HandlerOptions{Level: logLevel}) slog.SetDefault(slog.New(logHandler)) + trustedProxies, err := server.ParseTrustedProxies(setting.TrustedProxies) + if err != nil { + return err + } // Docker polls the healthcheck every 30s; keep it out of info-level logs. healthcheckPath := strings.TrimRight(setting.PrefixURL, "/") + "/api/healthcheck" @@ -80,7 +84,12 @@ func app() error { fuego.WithLogHandler(logHandler), // Replaced by server.AccessLogMiddleware. fuego.WithLoggingMiddleware(fuego.LoggingConfig{DisableRequest: true, DisableResponse: true}), - fuego.WithGlobalMiddlewares(server.AccessLogMiddleware(healthcheckPath)), + // Each global middleware wraps the ones before it, so RealIP runs + // first and the access log and handlers see the client address. + fuego.WithGlobalMiddlewares( + server.AccessLogMiddleware(healthcheckPath), + server.RealIPMiddleware(trustedProxies, setting.RemoteIPHeaders), + ), fuego.WithoutAutoGroupTags(), fuego.WithSecurity(server.OpenAPISecuritySchemes), fuego.WithEngineOptions( diff --git a/internal/server/accesslog.go b/internal/server/accesslog.go index ed12648c..5b245edf 100644 --- a/internal/server/accesslog.go +++ b/internal/server/accesslog.go @@ -104,6 +104,9 @@ func AccessLogMiddleware(quietPaths ...string) func(http.Handler) http.Handler { "request_id", requestID, "remote_addr", r.RemoteAddr, } + if proxy, ok := ProxyAddr(r); ok { + attrs = append(attrs, "proxy_addr", proxy) + } slog.Log(ctx, level, "outgoing response", attrs...) }) } diff --git a/internal/server/accesslog_test.go b/internal/server/accesslog_test.go index ea0d0c79..c5470626 100644 --- a/internal/server/accesslog_test.go +++ b/internal/server/accesslog_test.go @@ -35,6 +35,8 @@ func logEntries(t *testing.T, buf *bytes.Buffer) []map[string]any { } func TestAccessLogMiddleware(t *testing.T) { + trusted, err := ParseTrustedProxies([]string{"172.18.0.0/16"}) + require.NoError(t, err) handler := AccessLogMiddleware("/api/healthcheck")( http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { if r.URL.Path == "/missing" { @@ -44,6 +46,8 @@ func TestAccessLogMiddleware(t *testing.T) { w.Write([]byte("ok")) }), ) + // Same order as main: RealIP wraps the access log. + handler = RealIPMiddleware(trusted, nil)(handler) serve := func(path string, header http.Header) *httptest.ResponseRecorder { req := httptest.NewRequest(http.MethodGet, path, nil) @@ -54,9 +58,9 @@ func TestAccessLogMiddleware(t *testing.T) { return rec } - t.Run("info logs response", func(t *testing.T) { + t.Run("info logs response with client and proxy address", func(t *testing.T) { buf := captureLogs(t, slog.LevelInfo) - rec := serve("/missing", nil) + rec := serve("/missing", http.Header{"X-Forwarded-For": {"1.2.3.4"}}) entries := logEntries(t, buf) require.Len(t, entries, 1) @@ -65,7 +69,8 @@ func TestAccessLogMiddleware(t *testing.T) { assert.Equal(t, "INFO", e["level"]) assert.EqualValues(t, http.StatusNotFound, e["status_code"]) assert.Equal(t, "/missing", e["path"]) - assert.Equal(t, "172.18.0.2:4000", e["remote_addr"]) + assert.Equal(t, "1.2.3.4", e["remote_addr"]) + assert.Equal(t, "172.18.0.2:4000", e["proxy_addr"]) assert.NotEmpty(t, e["request_id"]) assert.Equal(t, e["request_id"], rec.Header().Get("X-Request-ID")) }) @@ -86,6 +91,8 @@ func TestAccessLogMiddleware(t *testing.T) { assert.Equal(t, "outgoing response", entries[1]["msg"]) assert.Equal(t, "DEBUG", entries[1]["level"]) assert.EqualValues(t, http.StatusOK, entries[1]["status_code"]) + assert.Equal(t, "172.18.0.2:4000", entries[1]["remote_addr"]) + assert.NotContains(t, entries[1], "proxy_addr") assert.Equal(t, "req-1", rec.Header().Get("X-Request-ID")) }) } diff --git a/internal/server/realip.go b/internal/server/realip.go new file mode 100644 index 00000000..0b6776b1 --- /dev/null +++ b/internal/server/realip.go @@ -0,0 +1,122 @@ +package server + +import ( + "context" + "fmt" + "net" + "net/http" + "net/netip" + "slices" + "strings" +) + +// DefaultRemoteIPHeaders are the headers read for the client address when the +// request comes from a trusted proxy and remoteIPHeaders is not configured. +var DefaultRemoteIPHeaders = []string{"X-Forwarded-For", "X-Real-IP"} + +type proxyAddrKey struct{} + +// ProxyAddr returns the address of the trusted proxy the request came through, +// if RemoteAddr was replaced with the client address taken from a header. +func ProxyAddr(r *http.Request) (string, bool) { + addr, ok := r.Context().Value(proxyAddrKey{}).(string) + return addr, ok +} + +// ParseTrustedProxies parses IP addresses and CIDR ranges. +func ParseTrustedProxies(entries []string) ([]netip.Prefix, error) { + var prefixes []netip.Prefix + for _, entry := range entries { + entry = strings.TrimSpace(entry) + if entry == "" { + continue + } + if strings.Contains(entry, "/") { + p, err := netip.ParsePrefix(entry) + if err != nil { + return nil, fmt.Errorf("trusted proxy %q: %w", entry, err) + } + prefixes = append(prefixes, p.Masked()) + continue + } + a, err := netip.ParseAddr(entry) + if err != nil { + return nil, fmt.Errorf("trusted proxy %q: %w", entry, err) + } + a = a.Unmap() + prefixes = append(prefixes, netip.PrefixFrom(a, a.BitLen())) + } + return prefixes, nil +} + +type clientIPResolver struct { + trusted []netip.Prefix + headers []string +} + +func (c clientIPResolver) isTrusted(a netip.Addr) bool { + a = a.Unmap() + for _, p := range c.trusted { + if p.Contains(a) { + return true + } + } + return false +} + +// clientIP returns the client address from the forwarding headers, but only +// when the direct peer is a trusted proxy. Each header is read right to left: +// trusted proxies are skipped and the first untrusted address is the client, +// as anything further left could have been sent by the client itself. +func (c clientIPResolver) clientIP(r *http.Request) (string, bool) { + host, _, err := net.SplitHostPort(r.RemoteAddr) + if err != nil { + host = r.RemoteAddr + } + peer, err := netip.ParseAddr(host) + if err != nil || !c.isTrusted(peer) { + return "", false + } + + for _, header := range c.headers { + values := r.Header.Values(header) + if len(values) == 0 { + continue + } + items := strings.Split(strings.Join(values, ","), ",") + for i, item := range slices.Backward(items) { + ip, err := netip.ParseAddr(strings.TrimSpace(item)) + if err != nil { + break // malformed header: try the next one + } + ip = ip.Unmap() + if i == 0 || !c.isTrusted(ip) { + return ip.String(), true + } + } + } + return "", false +} + +// RealIPMiddleware replaces r.RemoteAddr with the client address taken from +// the forwarding headers when the request comes from a trusted proxy; the +// proxy address stays available through ProxyAddr. With no trusted proxies +// headers are never read. +func RealIPMiddleware(trusted []netip.Prefix, headers []string) func(http.Handler) http.Handler { + if len(headers) == 0 { + headers = DefaultRemoteIPHeaders + } + resolver := clientIPResolver{trusted: trusted, headers: headers} + return func(next http.Handler) http.Handler { + if len(trusted) == 0 { + return next + } + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + if ip, ok := resolver.clientIP(r); ok { + r = r.WithContext(context.WithValue(r.Context(), proxyAddrKey{}, r.RemoteAddr)) + r.RemoteAddr = ip + } + next.ServeHTTP(w, r) + }) + } +} diff --git a/internal/server/realip_test.go b/internal/server/realip_test.go new file mode 100644 index 00000000..9bbbd173 --- /dev/null +++ b/internal/server/realip_test.go @@ -0,0 +1,136 @@ +package server + +import ( + "net/http" + "net/http/httptest" + "testing" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +func TestParseTrustedProxies(t *testing.T) { + prefixes, err := ParseTrustedProxies([]string{" 172.18.0.0/16 ", "10.0.0.5", "::ffff:192.168.1.1", "fd00::/8", ""}) + require.NoError(t, err) + got := make([]string, len(prefixes)) + for i, p := range prefixes { + got[i] = p.String() + } + assert.Equal(t, []string{"172.18.0.0/16", "10.0.0.5/32", "192.168.1.1/32", "fd00::/8"}, got) + + for _, bad := range []string{"proxy.local", "10.0.0.0/33", "300.1.1.1"} { + _, err := ParseTrustedProxies([]string{bad}) + assert.Error(t, err, bad) + } +} + +func TestRealIPMiddleware(t *testing.T) { + trusted, err := ParseTrustedProxies([]string{"172.18.0.0/16", "10.0.0.1"}) + require.NoError(t, err) + + tests := []struct { + name string + trusted []string + headers []string + remoteAddr string + set map[string][]string + wantAddr string + wantProxy string + }{ + { + name: "no trusted proxies ignores headers", + trusted: []string{}, + remoteAddr: "172.18.0.2:4000", + set: map[string][]string{"X-Forwarded-For": {"1.2.3.4"}}, + wantAddr: "172.18.0.2:4000", + }, + { + name: "untrusted peer ignores headers", + remoteAddr: "8.8.8.8:4000", + set: map[string][]string{"X-Forwarded-For": {"1.2.3.4"}}, + wantAddr: "8.8.8.8:4000", + }, + { + name: "trusted peer uses X-Forwarded-For", + remoteAddr: "172.18.0.2:4000", + set: map[string][]string{"X-Forwarded-For": {"1.2.3.4"}}, + wantAddr: "1.2.3.4", + wantProxy: "172.18.0.2:4000", + }, + { + name: "spoofed left entries are skipped", + remoteAddr: "172.18.0.2:4000", + set: map[string][]string{"X-Forwarded-For": {"9.9.9.9, 1.2.3.4, 10.0.0.1"}}, + wantAddr: "1.2.3.4", + wantProxy: "172.18.0.2:4000", + }, + { + name: "multiple header lines are joined", + remoteAddr: "172.18.0.2:4000", + set: map[string][]string{"X-Forwarded-For": {"9.9.9.9", "1.2.3.4"}}, + wantAddr: "1.2.3.4", + wantProxy: "172.18.0.2:4000", + }, + { + name: "all entries trusted gives leftmost", + remoteAddr: "172.18.0.2:4000", + set: map[string][]string{"X-Forwarded-For": {"172.18.0.9, 10.0.0.1"}}, + wantAddr: "172.18.0.9", + wantProxy: "172.18.0.2:4000", + }, + { + name: "malformed header falls back to next header", + remoteAddr: "172.18.0.2:4000", + set: map[string][]string{"X-Forwarded-For": {"garbage"}, "X-Real-IP": {"5.6.7.8"}}, + wantAddr: "5.6.7.8", + wantProxy: "172.18.0.2:4000", + }, + { + name: "no header keeps RemoteAddr", + remoteAddr: "172.18.0.2:4000", + wantAddr: "172.18.0.2:4000", + }, + { + name: "configured header only", + headers: []string{"CF-Connecting-IP"}, + remoteAddr: "172.18.0.2:4000", + set: map[string][]string{"X-Forwarded-For": {"9.9.9.9"}, "Cf-Connecting-Ip": {"2001:db8::1"}}, + wantAddr: "2001:db8::1", + wantProxy: "172.18.0.2:4000", + }, + { + name: "IPv4-mapped peer and client are unmapped", + remoteAddr: "[::ffff:10.0.0.1]:4000", + set: map[string][]string{"X-Forwarded-For": {"::ffff:1.2.3.4"}}, + wantAddr: "1.2.3.4", + wantProxy: "[::ffff:10.0.0.1]:4000", + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + tp := trusted + if tt.trusted != nil { + tp, err = ParseTrustedProxies(tt.trusted) + require.NoError(t, err) + } + var gotAddr, gotProxy string + h := RealIPMiddleware(tp, tt.headers)(http.HandlerFunc(func(_ http.ResponseWriter, r *http.Request) { + gotAddr = r.RemoteAddr + gotProxy, _ = ProxyAddr(r) + })) + + req := httptest.NewRequest(http.MethodGet, "/", nil) + req.RemoteAddr = tt.remoteAddr + for k, vs := range tt.set { + for _, v := range vs { + req.Header.Add(k, v) + } + } + h.ServeHTTP(httptest.NewRecorder(), req) + + assert.Equal(t, tt.wantAddr, gotAddr) + assert.Equal(t, tt.wantProxy, gotProxy) + }) + } +} diff --git a/internal/server/setting.go b/internal/server/setting.go index a69a8c47..a87d4264 100644 --- a/internal/server/setting.go +++ b/internal/server/setting.go @@ -33,6 +33,11 @@ type Setting struct { Auth Auth `json:"auth" yaml:"auth"` HttpServer HttpServer `json:"httpServer" yaml:"httpServer"` CORS CORSConfig `json:"cors" yaml:"cors"` + + // TrustedProxies lists the reverse proxies (IPs or CIDR ranges) whose + // RemoteIPHeaders are believed. Empty: headers are ignored. + TrustedProxies []string `json:"trustedProxies" yaml:"trustedProxies"` + RemoteIPHeaders []string `json:"remoteIPHeaders" yaml:"remoteIPHeaders"` } type Conversion struct { @@ -117,6 +122,8 @@ func NewSetting() (setting Setting, err error) { viper.SetDefault("tmp", "") viper.SetDefault("logger", false) viper.SetDefault("logLevel", "info") + viper.SetDefault("trustedProxies", []string{}) + viper.SetDefault("remoteIPHeaders", DefaultRemoteIPHeaders) viper.SetDefault("customize.enabled", false) viper.SetDefault("customize.websiteURL", "") viper.SetDefault("customize.websiteLogo", "") @@ -169,6 +176,10 @@ func NewSetting() (setting Setting, err error) { return } + if _, err = ParseTrustedProxies(setting.TrustedProxies); err != nil { + return + } + // Viper can't unmarshal a JSON string env var into map[string]string, // so parse OCAP_CUSTOMIZE_CSSOVERRIDES manually if set. Env var takes // precedence over config file. diff --git a/internal/server/setting_test.go b/internal/server/setting_test.go index 1ccab5f8..4a73fa1c 100644 --- a/internal/server/setting_test.go +++ b/internal/server/setting_test.go @@ -677,7 +677,7 @@ func TestNewSetting_AuthPasswordMode(t *testing.T) { assert.Equal(t, "hunter2", setting.Auth.Password) } -func TestNewSetting_Logging(t *testing.T) { +func TestNewSetting_LoggingAndProxies(t *testing.T) { dir := t.TempDir() require.NoError(t, os.WriteFile(filepath.Join(dir, "setting.json"), []byte(`{"secret": "base-secret"}`), 0644)) load := func(t *testing.T) (Setting, error) { @@ -688,19 +688,25 @@ func TestNewSetting_Logging(t *testing.T) { return NewSetting() } - t.Run("defaults to info", func(t *testing.T) { + t.Run("defaults trust no proxy", func(t *testing.T) { setting, err := load(t) require.NoError(t, err) assert.Equal(t, "info", setting.LogLevel) + assert.Empty(t, setting.TrustedProxies) + assert.Equal(t, []string{"X-Forwarded-For", "X-Real-IP"}, setting.RemoteIPHeaders) }) - t.Run("env var", func(t *testing.T) { + t.Run("env vars", func(t *testing.T) { t.Setenv("OCAP_LOGLEVEL", "debug") + t.Setenv("OCAP_TRUSTEDPROXIES", "172.18.0.0/16,10.0.0.5") + t.Setenv("OCAP_REMOTEIPHEADERS", "CF-Connecting-IP") setting, err := load(t) require.NoError(t, err) level, err := setting.SlogLevel() require.NoError(t, err) assert.Equal(t, slog.LevelDebug, level) + assert.Equal(t, []string{"172.18.0.0/16", "10.0.0.5"}, setting.TrustedProxies) + assert.Equal(t, []string{"CF-Connecting-IP"}, setting.RemoteIPHeaders) }) t.Run("invalid log level", func(t *testing.T) { @@ -708,4 +714,10 @@ func TestNewSetting_Logging(t *testing.T) { _, err := load(t) assert.ErrorContains(t, err, "logLevel") }) + + t.Run("invalid trusted proxy", func(t *testing.T) { + t.Setenv("OCAP_TRUSTEDPROXIES", "proxy.local") + _, err := load(t) + assert.ErrorContains(t, err, "trusted proxy") + }) } diff --git a/setting.json.example b/setting.json.example index 2b92faf0..cb0c9800 100644 --- a/setting.json.example +++ b/setting.json.example @@ -12,6 +12,8 @@ "maps": "maps", "logger": false, "logLevel": "info", + "trustedProxies": [], + "remoteIPHeaders": ["X-Forwarded-For", "X-Real-IP"], "customize": { "disableKillCount": false, "enabled": false, From 368b073900481e31eab7160cd5a3004b3fd6cc5d Mon Sep 17 00:00:00 2001 From: Smith <13200576+smitt14ua@users.noreply.github.com> Date: Sat, 14 Nov 2026 01:32:53 +0200 Subject: [PATCH 2/5] docs: explain trusting Cloudflare behind another reverse proxy --- README.md | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index bbb250ac..0ae5f8a5 100644 --- a/README.md +++ b/README.md @@ -259,7 +259,10 @@ Behind a reverse proxy every request comes from the proxy's address. To log the "trustedProxies": ["172.18.0.0/16"] ``` -Behind Cloudflare and another proxy such as Traefik, either make that proxy trust Cloudflare's ranges (Traefik: `forwardedHeaders.trustedIPs`) and keep `X-Forwarded-For`, or set `remoteIPHeaders` to `["CF-Connecting-IP"]`. In the second case let only Cloudflare reach the proxy, otherwise a client that bypasses Cloudflare can set the header itself. +**Cloudflare in front of another proxy** (e.g. Cloudflare → Traefik → OCAP): only the direct peer (Traefik) is checked against `trustedProxies`, so a header that proxy merely passes on is only as trustworthy as whoever reached it. + +- Recommended: keep `X-Forwarded-For`, let the proxy pass it on (Traefik: `forwardedHeaders.trustedIPs` with [Cloudflare's ranges](https://www.cloudflare.com/ips/)) and list both the proxy and Cloudflare's ranges in `trustedProxies`. Every hop appends its peer to the chain, so a client that bypasses Cloudflare ends up as the first untrusted entry and is logged as itself. +- Simpler: `"remoteIPHeaders": ["CF-Connecting-IP"]` with only the proxy in `trustedProxies`. This header holds a single address that the proxy passes on unchecked, so let only Cloudflare reach the proxy (firewall), otherwise a client that bypasses Cloudflare can set it itself. ## Large Recording Support From e8ea50fe00dc74f0493fa9098f6c8317faa9dea8 Mon Sep 17 00:00:00 2001 From: Smith <13200576+smitt14ua@users.noreply.github.com> Date: Sat, 14 Nov 2026 01:34:18 +0200 Subject: [PATCH 3/5] refactor(server): drop proxy_addr from the access log With a single reverse proxy it is the same address on every line. --- README.md | 2 +- internal/server/accesslog.go | 3 --- internal/server/accesslog_test.go | 4 +--- internal/server/realip.go | 16 ++------------- internal/server/realip_test.go | 33 ++++++++----------------------- 5 files changed, 12 insertions(+), 46 deletions(-) diff --git a/README.md b/README.md index 0ae5f8a5..8d55450a 100644 --- a/README.md +++ b/README.md @@ -253,7 +253,7 @@ Behind a reverse proxy every request comes from the proxy's address. To log the | `trustedProxies` | `OCAP_TRUSTEDPROXIES` | IPs or CIDR ranges of trusted reverse proxies. Comma-separated in env var. | `[]` (trust none) | | `remoteIPHeaders` | `OCAP_REMOTEIPHEADERS` | Headers holding the client address, tried in order. Comma-separated in env var. | `["X-Forwarded-For", "X-Real-IP"]` | -`X-Forwarded-For` is read right to left: trusted proxies are skipped and the first other address is the client, since entries further left can be sent by the client itself. The access log then shows the client in `remote_addr` and the proxy in `proxy_addr`. +`X-Forwarded-For` is read right to left: trusted proxies are skipped and the first other address is the client, since entries further left can be sent by the client itself. The access log and the handlers then see the client in `remote_addr`. ```json "trustedProxies": ["172.18.0.0/16"] diff --git a/internal/server/accesslog.go b/internal/server/accesslog.go index 5b245edf..ed12648c 100644 --- a/internal/server/accesslog.go +++ b/internal/server/accesslog.go @@ -104,9 +104,6 @@ func AccessLogMiddleware(quietPaths ...string) func(http.Handler) http.Handler { "request_id", requestID, "remote_addr", r.RemoteAddr, } - if proxy, ok := ProxyAddr(r); ok { - attrs = append(attrs, "proxy_addr", proxy) - } slog.Log(ctx, level, "outgoing response", attrs...) }) } diff --git a/internal/server/accesslog_test.go b/internal/server/accesslog_test.go index c5470626..62017707 100644 --- a/internal/server/accesslog_test.go +++ b/internal/server/accesslog_test.go @@ -58,7 +58,7 @@ func TestAccessLogMiddleware(t *testing.T) { return rec } - t.Run("info logs response with client and proxy address", func(t *testing.T) { + t.Run("info logs response with client address", func(t *testing.T) { buf := captureLogs(t, slog.LevelInfo) rec := serve("/missing", http.Header{"X-Forwarded-For": {"1.2.3.4"}}) @@ -70,7 +70,6 @@ func TestAccessLogMiddleware(t *testing.T) { assert.EqualValues(t, http.StatusNotFound, e["status_code"]) assert.Equal(t, "/missing", e["path"]) assert.Equal(t, "1.2.3.4", e["remote_addr"]) - assert.Equal(t, "172.18.0.2:4000", e["proxy_addr"]) assert.NotEmpty(t, e["request_id"]) assert.Equal(t, e["request_id"], rec.Header().Get("X-Request-ID")) }) @@ -92,7 +91,6 @@ func TestAccessLogMiddleware(t *testing.T) { assert.Equal(t, "DEBUG", entries[1]["level"]) assert.EqualValues(t, http.StatusOK, entries[1]["status_code"]) assert.Equal(t, "172.18.0.2:4000", entries[1]["remote_addr"]) - assert.NotContains(t, entries[1], "proxy_addr") assert.Equal(t, "req-1", rec.Header().Get("X-Request-ID")) }) } diff --git a/internal/server/realip.go b/internal/server/realip.go index 0b6776b1..c642dd3a 100644 --- a/internal/server/realip.go +++ b/internal/server/realip.go @@ -1,7 +1,6 @@ package server import ( - "context" "fmt" "net" "net/http" @@ -14,15 +13,6 @@ import ( // request comes from a trusted proxy and remoteIPHeaders is not configured. var DefaultRemoteIPHeaders = []string{"X-Forwarded-For", "X-Real-IP"} -type proxyAddrKey struct{} - -// ProxyAddr returns the address of the trusted proxy the request came through, -// if RemoteAddr was replaced with the client address taken from a header. -func ProxyAddr(r *http.Request) (string, bool) { - addr, ok := r.Context().Value(proxyAddrKey{}).(string) - return addr, ok -} - // ParseTrustedProxies parses IP addresses and CIDR ranges. func ParseTrustedProxies(entries []string) ([]netip.Prefix, error) { var prefixes []netip.Prefix @@ -99,9 +89,8 @@ func (c clientIPResolver) clientIP(r *http.Request) (string, bool) { } // RealIPMiddleware replaces r.RemoteAddr with the client address taken from -// the forwarding headers when the request comes from a trusted proxy; the -// proxy address stays available through ProxyAddr. With no trusted proxies -// headers are never read. +// the forwarding headers when the request comes from a trusted proxy. With no +// trusted proxies headers are never read. func RealIPMiddleware(trusted []netip.Prefix, headers []string) func(http.Handler) http.Handler { if len(headers) == 0 { headers = DefaultRemoteIPHeaders @@ -113,7 +102,6 @@ func RealIPMiddleware(trusted []netip.Prefix, headers []string) func(http.Handle } return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { if ip, ok := resolver.clientIP(r); ok { - r = r.WithContext(context.WithValue(r.Context(), proxyAddrKey{}, r.RemoteAddr)) r.RemoteAddr = ip } next.ServeHTTP(w, r) diff --git a/internal/server/realip_test.go b/internal/server/realip_test.go index 9bbbd173..2a70bec2 100644 --- a/internal/server/realip_test.go +++ b/internal/server/realip_test.go @@ -35,7 +35,6 @@ func TestRealIPMiddleware(t *testing.T) { remoteAddr string set map[string][]string wantAddr string - wantProxy string }{ { name: "no trusted proxies ignores headers", @@ -54,37 +53,27 @@ func TestRealIPMiddleware(t *testing.T) { name: "trusted peer uses X-Forwarded-For", remoteAddr: "172.18.0.2:4000", set: map[string][]string{"X-Forwarded-For": {"1.2.3.4"}}, - wantAddr: "1.2.3.4", - wantProxy: "172.18.0.2:4000", - }, + wantAddr: "1.2.3.4", }, { name: "spoofed left entries are skipped", remoteAddr: "172.18.0.2:4000", set: map[string][]string{"X-Forwarded-For": {"9.9.9.9, 1.2.3.4, 10.0.0.1"}}, - wantAddr: "1.2.3.4", - wantProxy: "172.18.0.2:4000", - }, + wantAddr: "1.2.3.4", }, { name: "multiple header lines are joined", remoteAddr: "172.18.0.2:4000", set: map[string][]string{"X-Forwarded-For": {"9.9.9.9", "1.2.3.4"}}, - wantAddr: "1.2.3.4", - wantProxy: "172.18.0.2:4000", - }, + wantAddr: "1.2.3.4", }, { name: "all entries trusted gives leftmost", remoteAddr: "172.18.0.2:4000", set: map[string][]string{"X-Forwarded-For": {"172.18.0.9, 10.0.0.1"}}, - wantAddr: "172.18.0.9", - wantProxy: "172.18.0.2:4000", - }, + wantAddr: "172.18.0.9", }, { name: "malformed header falls back to next header", remoteAddr: "172.18.0.2:4000", set: map[string][]string{"X-Forwarded-For": {"garbage"}, "X-Real-IP": {"5.6.7.8"}}, - wantAddr: "5.6.7.8", - wantProxy: "172.18.0.2:4000", - }, + wantAddr: "5.6.7.8", }, { name: "no header keeps RemoteAddr", remoteAddr: "172.18.0.2:4000", @@ -95,16 +84,12 @@ func TestRealIPMiddleware(t *testing.T) { headers: []string{"CF-Connecting-IP"}, remoteAddr: "172.18.0.2:4000", set: map[string][]string{"X-Forwarded-For": {"9.9.9.9"}, "Cf-Connecting-Ip": {"2001:db8::1"}}, - wantAddr: "2001:db8::1", - wantProxy: "172.18.0.2:4000", - }, + wantAddr: "2001:db8::1", }, { name: "IPv4-mapped peer and client are unmapped", remoteAddr: "[::ffff:10.0.0.1]:4000", set: map[string][]string{"X-Forwarded-For": {"::ffff:1.2.3.4"}}, - wantAddr: "1.2.3.4", - wantProxy: "[::ffff:10.0.0.1]:4000", - }, + wantAddr: "1.2.3.4", }, } for _, tt := range tests { @@ -114,10 +99,9 @@ func TestRealIPMiddleware(t *testing.T) { tp, err = ParseTrustedProxies(tt.trusted) require.NoError(t, err) } - var gotAddr, gotProxy string + var gotAddr string h := RealIPMiddleware(tp, tt.headers)(http.HandlerFunc(func(_ http.ResponseWriter, r *http.Request) { gotAddr = r.RemoteAddr - gotProxy, _ = ProxyAddr(r) })) req := httptest.NewRequest(http.MethodGet, "/", nil) @@ -130,7 +114,6 @@ func TestRealIPMiddleware(t *testing.T) { h.ServeHTTP(httptest.NewRecorder(), req) assert.Equal(t, tt.wantAddr, gotAddr) - assert.Equal(t, tt.wantProxy, gotProxy) }) } } From daf936c000488cf356a19c02b047d0d5806ea4f8 Mon Sep 17 00:00:00 2001 From: Smith <13200576+smitt14ua@users.noreply.github.com> Date: Sat, 14 Nov 2026 01:34:48 +0200 Subject: [PATCH 4/5] style: gofmt realip_test.go --- internal/server/realip_test.go | 21 ++++++++++++++------- 1 file changed, 14 insertions(+), 7 deletions(-) diff --git a/internal/server/realip_test.go b/internal/server/realip_test.go index 2a70bec2..fc552834 100644 --- a/internal/server/realip_test.go +++ b/internal/server/realip_test.go @@ -53,27 +53,32 @@ func TestRealIPMiddleware(t *testing.T) { name: "trusted peer uses X-Forwarded-For", remoteAddr: "172.18.0.2:4000", set: map[string][]string{"X-Forwarded-For": {"1.2.3.4"}}, - wantAddr: "1.2.3.4", }, + wantAddr: "1.2.3.4", + }, { name: "spoofed left entries are skipped", remoteAddr: "172.18.0.2:4000", set: map[string][]string{"X-Forwarded-For": {"9.9.9.9, 1.2.3.4, 10.0.0.1"}}, - wantAddr: "1.2.3.4", }, + wantAddr: "1.2.3.4", + }, { name: "multiple header lines are joined", remoteAddr: "172.18.0.2:4000", set: map[string][]string{"X-Forwarded-For": {"9.9.9.9", "1.2.3.4"}}, - wantAddr: "1.2.3.4", }, + wantAddr: "1.2.3.4", + }, { name: "all entries trusted gives leftmost", remoteAddr: "172.18.0.2:4000", set: map[string][]string{"X-Forwarded-For": {"172.18.0.9, 10.0.0.1"}}, - wantAddr: "172.18.0.9", }, + wantAddr: "172.18.0.9", + }, { name: "malformed header falls back to next header", remoteAddr: "172.18.0.2:4000", set: map[string][]string{"X-Forwarded-For": {"garbage"}, "X-Real-IP": {"5.6.7.8"}}, - wantAddr: "5.6.7.8", }, + wantAddr: "5.6.7.8", + }, { name: "no header keeps RemoteAddr", remoteAddr: "172.18.0.2:4000", @@ -84,12 +89,14 @@ func TestRealIPMiddleware(t *testing.T) { headers: []string{"CF-Connecting-IP"}, remoteAddr: "172.18.0.2:4000", set: map[string][]string{"X-Forwarded-For": {"9.9.9.9"}, "Cf-Connecting-Ip": {"2001:db8::1"}}, - wantAddr: "2001:db8::1", }, + wantAddr: "2001:db8::1", + }, { name: "IPv4-mapped peer and client are unmapped", remoteAddr: "[::ffff:10.0.0.1]:4000", set: map[string][]string{"X-Forwarded-For": {"::ffff:1.2.3.4"}}, - wantAddr: "1.2.3.4", }, + wantAddr: "1.2.3.4", + }, } for _, tt := range tests { From 2590a672b4d15178912f465b35181c870e42ad02 Mon Sep 17 00:00:00 2001 From: Smith <13200576+smitt14ua@users.noreply.github.com> Date: Sat, 14 Nov 2026 02:06:42 +0200 Subject: [PATCH 5/5] fix(server): match IPv4-mapped trusted proxy prefixes Addresses are unmapped before matching, but a trusted proxy given as an IPv4-mapped CIDR (::ffff:172.18.0.0/112) stayed an IPv6 prefix and never matched. Convert it to the equivalent IPv4 prefix; reject mapped prefixes shorter than /96, which cover more than the mapped range. --- internal/server/realip.go | 8 ++++++++ internal/server/realip_test.go | 26 +++++++++++++++++++++++--- 2 files changed, 31 insertions(+), 3 deletions(-) diff --git a/internal/server/realip.go b/internal/server/realip.go index c642dd3a..63c78550 100644 --- a/internal/server/realip.go +++ b/internal/server/realip.go @@ -26,6 +26,14 @@ func ParseTrustedProxies(entries []string) ([]netip.Prefix, error) { if err != nil { return nil, fmt.Errorf("trusted proxy %q: %w", entry, err) } + // Addresses are unmapped before matching, so an IPv4-mapped + // prefix must become the equivalent IPv4 prefix. + if p.Addr().Is4In6() { + if p.Bits() < 96 { + return nil, fmt.Errorf("trusted proxy %q: IPv4-mapped prefix must be at least /96", entry) + } + p = netip.PrefixFrom(p.Addr().Unmap(), p.Bits()-96) + } prefixes = append(prefixes, p.Masked()) continue } diff --git a/internal/server/realip_test.go b/internal/server/realip_test.go index fc552834..a721eb98 100644 --- a/internal/server/realip_test.go +++ b/internal/server/realip_test.go @@ -10,15 +10,21 @@ import ( ) func TestParseTrustedProxies(t *testing.T) { - prefixes, err := ParseTrustedProxies([]string{" 172.18.0.0/16 ", "10.0.0.5", "::ffff:192.168.1.1", "fd00::/8", ""}) + prefixes, err := ParseTrustedProxies([]string{ + " 172.18.0.0/16 ", "10.0.0.5", "::ffff:192.168.1.1", "fd00::/8", "", + "::ffff:172.19.0.2/128", "::ffff:172.20.0.0/112", "::ffff:0.0.0.0/96", + }) require.NoError(t, err) got := make([]string, len(prefixes)) for i, p := range prefixes { got[i] = p.String() } - assert.Equal(t, []string{"172.18.0.0/16", "10.0.0.5/32", "192.168.1.1/32", "fd00::/8"}, got) + assert.Equal(t, []string{ + "172.18.0.0/16", "10.0.0.5/32", "192.168.1.1/32", "fd00::/8", + "172.19.0.2/32", "172.20.0.0/16", "0.0.0.0/0", + }, got) - for _, bad := range []string{"proxy.local", "10.0.0.0/33", "300.1.1.1"} { + for _, bad := range []string{"proxy.local", "10.0.0.0/33", "300.1.1.1", "::ffff:0.0.0.0/95"} { _, err := ParseTrustedProxies([]string{bad}) assert.Error(t, err, bad) } @@ -97,6 +103,20 @@ func TestRealIPMiddleware(t *testing.T) { set: map[string][]string{"X-Forwarded-For": {"::ffff:1.2.3.4"}}, wantAddr: "1.2.3.4", }, + { + name: "IPv4-mapped /128 trusted entry", + trusted: []string{"::ffff:172.18.0.2/128"}, + remoteAddr: "[::ffff:172.18.0.2]:4000", + set: map[string][]string{"X-Forwarded-For": {"1.2.3.4"}}, + wantAddr: "1.2.3.4", + }, + { + name: "IPv4-mapped subnet trusted entry", + trusted: []string{"::ffff:172.18.0.0/112"}, + remoteAddr: "172.18.0.2:4000", + set: map[string][]string{"X-Forwarded-For": {"1.2.3.4, 172.18.5.5"}}, + wantAddr: "1.2.3.4", + }, } for _, tt := range tests {