diff --git a/README.md b/README.md index 0e585ecd..8d55450a 100644 --- a/README.md +++ b/README.md @@ -122,7 +122,8 @@ The configuration file is called `setting.json`. All settings can also be set vi | `listen` | `OCAP_LISTEN` | Server address | `127.0.0.1:5000` | | `prefixURL` | `OCAP_PREFIXURL` | URL prefix for all routes | `""` | | `secret` | `OCAP_SECRET` | Shared secret — authenticates record uploads and signs admin session JWTs | *required* | -| `logger` | `OCAP_LOGGER` | Enable request logging to STDOUT | `false` | +| `logger` | `OCAP_LOGGER` | Also write logs to `ocap.log` (they always go to STDOUT) | `false` | +| `logLevel` | `OCAP_LOGLEVEL` | Minimum log level: `debug`, `info`, `warn`, `error`. Healthcheck requests are logged at `debug` | `info` | ### Paths @@ -243,6 +244,26 @@ 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 and the handlers then see the client in `remote_addr`. + +```json +"trustedProxies": ["172.18.0.0/16"] +``` + +**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 ### Overview diff --git a/cmd/ocap-webserver/main.go b/cmd/ocap-webserver/main.go index bf477d47..36bc09b5 100644 --- a/cmd/ocap-webserver/main.go +++ b/cmd/ocap-webserver/main.go @@ -9,6 +9,7 @@ import ( "log/slog" "os" "os/signal" + "strings" "syscall" "time" @@ -49,9 +50,20 @@ func app() error { } // Set up slog with JSON handler for consistent logging - logHandler := slog.NewJSONHandler(logOutput, nil) + logLevel, err := setting.SlogLevel() + if err != nil { + return err + } + 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" + operation, err := server.NewRepoOperationWithDataDir(setting.DB, setting.Data) if err != nil { return fmt.Errorf("operation: %w", err) @@ -70,6 +82,14 @@ func app() error { s := fuego.NewServer( fuego.WithAddr(setting.Listen), fuego.WithLogHandler(logHandler), + // Replaced by server.AccessLogMiddleware. + fuego.WithLoggingMiddleware(fuego.LoggingConfig{DisableRequest: true, DisableResponse: true}), + // 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/go.mod b/go.mod index f826c7c0..42582e06 100644 --- a/go.mod +++ b/go.mod @@ -7,6 +7,7 @@ require ( github.com/getkin/kin-openapi v0.153.0 github.com/go-fuego/fuego v0.21.0 github.com/golang-jwt/jwt/v5 v5.3.1 + github.com/google/uuid v1.6.0 github.com/gorilla/websocket v1.5.3 github.com/klauspost/compress v1.20.4 github.com/mattn/go-sqlite3 v1.14.53 @@ -27,7 +28,6 @@ require ( github.com/go-playground/universal-translator v0.18.1 // indirect github.com/go-playground/validator/v10 v10.30.4 // indirect github.com/go-viper/mapstructure/v2 v2.5.0 // indirect - github.com/google/uuid v1.6.0 // indirect github.com/gorilla/schema v1.4.1 // indirect github.com/leodido/go-urn v1.5.0 // indirect github.com/pelletier/go-toml/v2 v2.4.3 // indirect diff --git a/internal/server/accesslog.go b/internal/server/accesslog.go new file mode 100644 index 00000000..ed12648c --- /dev/null +++ b/internal/server/accesslog.go @@ -0,0 +1,110 @@ +package server + +import ( + "bufio" + "log/slog" + "net" + "net/http" + "slices" + "time" + + "github.com/google/uuid" +) + +// accessLogWriter records the response status for the access log. +type accessLogWriter struct { + http.ResponseWriter + status int + hijacked bool +} + +func (w *accessLogWriter) WriteHeader(code int) { + if w.status == 0 { + w.status = code + } + w.ResponseWriter.WriteHeader(code) +} + +func (w *accessLogWriter) Write(b []byte) (int, error) { + if w.status == 0 { + w.status = http.StatusOK + } + return w.ResponseWriter.Write(b) +} + +func (w *accessLogWriter) Flush() { + if f, ok := w.ResponseWriter.(http.Flusher); ok { + f.Flush() + } +} + +func (w *accessLogWriter) Hijack() (net.Conn, *bufio.ReadWriter, error) { + h, ok := w.ResponseWriter.(http.Hijacker) + if !ok { + return nil, nil, http.ErrNotSupported + } + conn, rw, err := h.Hijack() + if err == nil { + w.hijacked = true + } + return conn, rw, err +} + +// Unwrap lets http.ResponseController reach the underlying writer. +func (w *accessLogWriter) Unwrap() http.ResponseWriter { + return w.ResponseWriter +} + +func (w *accessLogWriter) statusCode() int { + switch { + case w.hijacked: + return http.StatusSwitchingProtocols + case w.status == 0: + return http.StatusOK + } + return w.status +} + +// AccessLogMiddleware logs every request: "incoming request" at debug level +// and "outgoing response" at info level, or at debug level for quietPaths +// (such as the healthcheck polled by Docker). It sets X-Request-ID, keeping +// the one the client sent. +func AccessLogMiddleware(quietPaths ...string) func(http.Handler) http.Handler { + return func(next http.Handler) http.Handler { + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + start := time.Now() + + requestID := r.Header.Get("X-Request-ID") + if requestID == "" { + requestID = uuid.NewString() + } + w.Header().Set("X-Request-ID", requestID) + + ctx := r.Context() + slog.DebugContext(ctx, "incoming request", + "method", r.Method, + "path", r.URL.Path, + "request_id", requestID, + "remote_addr", r.RemoteAddr, + "user_agent", r.UserAgent(), + ) + + lw := &accessLogWriter{ResponseWriter: w} + next.ServeHTTP(lw, r) + + level := slog.LevelInfo + if slices.Contains(quietPaths, r.URL.Path) { + level = slog.LevelDebug + } + attrs := []any{ + "status_code", lw.statusCode(), + "method", r.Method, + "path", r.URL.Path, + "duration_ms", time.Since(start).Milliseconds(), + "request_id", requestID, + "remote_addr", r.RemoteAddr, + } + slog.Log(ctx, level, "outgoing response", attrs...) + }) + } +} diff --git a/internal/server/accesslog_test.go b/internal/server/accesslog_test.go new file mode 100644 index 00000000..62017707 --- /dev/null +++ b/internal/server/accesslog_test.go @@ -0,0 +1,104 @@ +package server + +import ( + "bytes" + "encoding/json" + "log/slog" + "maps" + "net/http" + "net/http/httptest" + "strings" + "testing" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +func captureLogs(t *testing.T, level slog.Level) *bytes.Buffer { + t.Helper() + var buf bytes.Buffer + prev := slog.Default() + slog.SetDefault(slog.New(slog.NewJSONHandler(&buf, &slog.HandlerOptions{Level: level}))) + t.Cleanup(func() { slog.SetDefault(prev) }) + return &buf +} + +func logEntries(t *testing.T, buf *bytes.Buffer) []map[string]any { + t.Helper() + var entries []map[string]any + for line := range strings.Lines(buf.String()) { + var e map[string]any + require.NoError(t, json.Unmarshal([]byte(line), &e)) + entries = append(entries, e) + } + return entries +} + +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" { + http.NotFound(w, r) + return + } + 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) + req.RemoteAddr = "172.18.0.2:4000" + maps.Copy(req.Header, header) + rec := httptest.NewRecorder() + handler.ServeHTTP(rec, req) + return rec + } + + 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"}}) + + entries := logEntries(t, buf) + require.Len(t, entries, 1) + e := entries[0] + assert.Equal(t, "outgoing response", e["msg"]) + assert.Equal(t, "INFO", e["level"]) + 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.NotEmpty(t, e["request_id"]) + assert.Equal(t, e["request_id"], rec.Header().Get("X-Request-ID")) + }) + + t.Run("healthcheck is hidden at info", func(t *testing.T) { + buf := captureLogs(t, slog.LevelInfo) + serve("/api/healthcheck", nil) + assert.Empty(t, buf.String()) + }) + + t.Run("healthcheck is logged at debug", func(t *testing.T) { + buf := captureLogs(t, slog.LevelDebug) + rec := serve("/api/healthcheck", http.Header{"X-Request-Id": {"req-1"}}) + + entries := logEntries(t, buf) + require.Len(t, entries, 2) + assert.Equal(t, "incoming request", entries[0]["msg"]) + 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.Equal(t, "req-1", rec.Header().Get("X-Request-ID")) + }) +} + +func TestAccessLogWriter_ResponseController(t *testing.T) { + rec := httptest.NewRecorder() + w := &accessLogWriter{ResponseWriter: rec} + require.NoError(t, http.NewResponseController(w).Flush()) + assert.True(t, rec.Flushed) + assert.Equal(t, http.StatusOK, w.statusCode()) +} diff --git a/internal/server/realip.go b/internal/server/realip.go new file mode 100644 index 00000000..63c78550 --- /dev/null +++ b/internal/server/realip.go @@ -0,0 +1,118 @@ +package server + +import ( + "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"} + +// 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) + } + // 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 + } + 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. 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.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..a721eb98 --- /dev/null +++ b/internal/server/realip_test.go @@ -0,0 +1,146 @@ +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", "", + "::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", + "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", "::ffff:0.0.0.0/95"} { + _, 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 + }{ + { + 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", + }, + { + 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", + }, + { + 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", + }, + { + 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", + }, + { + 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", + }, + { + 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", + }, + { + 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", + }, + { + 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 { + 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 string + h := RealIPMiddleware(tp, tt.headers)(http.HandlerFunc(func(_ http.ResponseWriter, r *http.Request) { + gotAddr = r.RemoteAddr + })) + + 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) + }) + } +} diff --git a/internal/server/setting.go b/internal/server/setting.go index e18a1dbf..a87d4264 100644 --- a/internal/server/setting.go +++ b/internal/server/setting.go @@ -3,6 +3,7 @@ package server import ( "encoding/json" "fmt" + "log/slog" "os" "path/filepath" "slices" @@ -25,12 +26,18 @@ type Setting struct { Static string `json:"static" yaml:"static"` Tmp string `json:"tmp" yaml:"tmp"` Logger bool `json:"logger" yaml:"logger"` + LogLevel string `json:"logLevel" yaml:"logLevel"` Customize Customize `json:"customize" yaml:"customize"` Conversion Conversion `json:"conversion" yaml:"conversion"` Streaming Streaming `json:"streaming" yaml:"streaming"` 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 { @@ -114,6 +121,9 @@ func NewSetting() (setting Setting, err error) { viper.SetDefault("static", "") 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", "") @@ -162,6 +172,14 @@ func NewSetting() (setting Setting, err error) { return } + if _, err = setting.SlogLevel(); err != nil { + 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. @@ -206,6 +224,15 @@ func NewSetting() (setting Setting, err error) { return } +// SlogLevel parses LogLevel: debug, info, warn or error. +func (s Setting) SlogLevel() (slog.Level, error) { + var level slog.Level + if err := level.UnmarshalText([]byte(s.LogLevel)); err != nil { + return level, fmt.Errorf("logLevel %q is not valid, must be one of: debug, info, warn, error", s.LogLevel) + } + return level, nil +} + func validateAuthConfig(auth Auth) error { validModes := []string{"public", "password", "steam", "steamAllowlist"} if !slices.Contains(validModes, auth.Mode) { diff --git a/internal/server/setting_test.go b/internal/server/setting_test.go index 2a4fd92f..4a73fa1c 100644 --- a/internal/server/setting_test.go +++ b/internal/server/setting_test.go @@ -1,6 +1,7 @@ package server import ( + "log/slog" "os" "path/filepath" "testing" @@ -675,3 +676,48 @@ func TestNewSetting_AuthPasswordMode(t *testing.T) { assert.Equal(t, "password", setting.Auth.Mode) assert.Equal(t, "hunter2", setting.Auth.Password) } + +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) { + t.Helper() + viper.Reset() + t.Cleanup(viper.Reset) + viper.AddConfigPath(dir) + return NewSetting() + } + + 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 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) { + t.Setenv("OCAP_LOGLEVEL", "verbose") + _, 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 66b596c2..cb0c9800 100644 --- a/setting.json.example +++ b/setting.json.example @@ -11,6 +11,9 @@ "fonts": "assets/fonts", "maps": "maps", "logger": false, + "logLevel": "info", + "trustedProxies": [], + "remoteIPHeaders": ["X-Forwarded-For", "X-Real-IP"], "customize": { "disableKillCount": false, "enabled": false,