From cedb38d1cf8c0d9c4bcfe6c9b7e3ffa3c469187a Mon Sep 17 00:00:00 2001 From: Finesssee <90105158+Finesssee@users.noreply.github.com> Date: Mon, 18 May 2026 19:10:42 +0700 Subject: [PATCH] Harden management and OAuth surfaces --- docker-compose.yml | 8 +- .../api/handlers/management/auth_files.go | 2 +- internal/api/modules/amp/routes.go | 2 +- internal/api/modules/amp/routes_test.go | 74 +++++++++++++++++++ internal/api/server.go | 10 ++- internal/api/server_test.go | 28 +++++++ internal/auth/claude/oauth_server.go | 4 +- internal/auth/codex/oauth_server.go | 4 +- internal/auth/iflow/oauth_server.go | 4 +- internal/logging/request_logger.go | 12 ++- internal/logging/request_logger_home_test.go | 7 +- 11 files changed, 139 insertions(+), 16 deletions(-) diff --git a/docker-compose.yml b/docker-compose.yml index 2fde4fc6..11f1a440 100644 --- a/docker-compose.yml +++ b/docker-compose.yml @@ -17,10 +17,10 @@ services: ports: - "8317:8317" - "8085:8085" - - "1455:1455" - - "54545:54545" - - "51121:51121" - - "11451:11451" + - "127.0.0.1:1455:1455" + - "127.0.0.1:54545:54545" + - "127.0.0.1:51121:51121" + - "127.0.0.1:11451:11451" volumes: - ${CLI_PROXY_CONFIG_PATH:-./config.yaml}:/ProxyPilot/config.yaml - ${CLI_PROXY_AUTH_PATH:-./auths}:/root/.cli-proxy-api diff --git a/internal/api/handlers/management/auth_files.go b/internal/api/handlers/management/auth_files.go index d19d4b61..c9c3b93a 100644 --- a/internal/api/handlers/management/auth_files.go +++ b/internal/api/handlers/management/auth_files.go @@ -142,7 +142,7 @@ func startCallbackForwarder(port int, provider, targetBase string) (*callbackFor stopForwarderInstance(port, prev) } - addr := fmt.Sprintf("0.0.0.0:%d", port) + addr := fmt.Sprintf("127.0.0.1:%d", port) ln, err := net.Listen("tcp", addr) if err != nil { return nil, fmt.Errorf("failed to listen on %s: %w", addr, err) diff --git a/internal/api/modules/amp/routes.go b/internal/api/modules/amp/routes.go index 84023d15..9e5318b6 100644 --- a/internal/api/modules/amp/routes.go +++ b/internal/api/modules/amp/routes.go @@ -158,7 +158,7 @@ func (m *AmpModule) registerManagementRoutes(engine *gin.Engine, baseHandler *ha var authWithBypass gin.HandlerFunc if auth != nil { ampAPI.Use(auth) - authWithBypass = wrapManagementAuth(auth, "/threads", "/auth", "/docs", "/settings") + authWithBypass = wrapManagementAuth(auth, "/auth") } // Inject client API key into request context for per-client upstream routing diff --git a/internal/api/modules/amp/routes_test.go b/internal/api/modules/amp/routes_test.go index a500f815..774981f9 100644 --- a/internal/api/modules/amp/routes_test.go +++ b/internal/api/modules/amp/routes_test.go @@ -86,6 +86,80 @@ func TestRegisterManagementRoutes(t *testing.T) { } } +func TestRootManagementRoutesRequireAuthExceptAuthFlow(t *testing.T) { + gin.SetMode(gin.TestMode) + r := gin.New() + + m := &AmpModule{ + restrictToLocalhost: false, + } + + mockProxy := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + w.WriteHeader(http.StatusOK) + w.Write([]byte("proxied")) + })) + defer mockProxy.Close() + + proxy, err := createReverseProxy(mockProxy.URL, NewStaticSecretSource("")) + if err != nil { + t.Fatalf("create proxy: %v", err) + } + m.setProxy(proxy) + + authMiddleware := func(c *gin.Context) { + if c.GetHeader("Authorization") != "Bearer good-key" { + c.AbortWithStatus(http.StatusUnauthorized) + return + } + c.Set("userApiKey", "good-key") + c.Next() + } + + m.registerManagementRoutes(r, &handlers.BaseAPIHandler{}, authMiddleware) + srv := httptest.NewServer(r) + defer srv.Close() + + for _, path := range []string{"/threads", "/threads/abc", "/settings", "/settings/profile", "/docs"} { + t.Run(path+" without key", func(t *testing.T) { + resp, err := http.Get(srv.URL + path) + if err != nil { + t.Fatalf("request failed: %v", err) + } + defer resp.Body.Close() + if resp.StatusCode != http.StatusUnauthorized { + t.Fatalf("status = %d, want %d", resp.StatusCode, http.StatusUnauthorized) + } + }) + } + + t.Run("auth flow bypasses key", func(t *testing.T) { + resp, err := http.Get(srv.URL + "/auth/callback") + if err != nil { + t.Fatalf("request failed: %v", err) + } + defer resp.Body.Close() + if resp.StatusCode != http.StatusOK { + t.Fatalf("status = %d, want %d", resp.StatusCode, http.StatusOK) + } + }) + + t.Run("threads accepts valid key", func(t *testing.T) { + req, err := http.NewRequest(http.MethodGet, srv.URL+"/threads", nil) + if err != nil { + t.Fatalf("build request: %v", err) + } + req.Header.Set("Authorization", "Bearer good-key") + resp, err := http.DefaultClient.Do(req) + if err != nil { + t.Fatalf("request failed: %v", err) + } + defer resp.Body.Close() + if resp.StatusCode != http.StatusOK { + t.Fatalf("status = %d, want %d", resp.StatusCode, http.StatusOK) + } + }) +} + func TestRegisterProviderAliases_AllProvidersRegistered(t *testing.T) { gin.SetMode(gin.TestMode) r := gin.New() diff --git a/internal/api/server.go b/internal/api/server.go index 9926ef5f..e7cb56a4 100644 --- a/internal/api/server.go +++ b/internal/api/server.go @@ -1184,9 +1184,17 @@ func (s *Server) Stop(ctx context.Context) error { // - gin.HandlerFunc: The CORS middleware handler func corsMiddleware() gin.HandlerFunc { return func(c *gin.Context) { + if strings.HasPrefix(c.Request.URL.Path, "/v0/management") { + if c.Request.Method == http.MethodOptions { + c.AbortWithStatus(http.StatusForbidden) + return + } + c.Next() + return + } c.Header("Access-Control-Allow-Origin", "*") c.Header("Access-Control-Allow-Methods", "GET, POST, PUT, PATCH, DELETE, OPTIONS") - c.Header("Access-Control-Allow-Headers", "*") + c.Header("Access-Control-Allow-Headers", "Authorization, Content-Type, X-API-Key, X-Management-Key") if c.Request.Method == "OPTIONS" { c.AbortWithStatus(http.StatusNoContent) diff --git a/internal/api/server_test.go b/internal/api/server_test.go index e107702a..ebf6e670 100644 --- a/internal/api/server_test.go +++ b/internal/api/server_test.go @@ -147,6 +147,34 @@ func TestManagementUsageRequiresManagementAuthAndPopsArray(t *testing.T) { } } +func TestManagementRoutesDoNotEmitWildcardCORS(t *testing.T) { + t.Setenv("MANAGEMENT_PASSWORD", "test-management-key") + + server := newTestServer(t) + + req := httptest.NewRequest(http.MethodGet, "/v0/management/config", nil) + req.Header.Set("Origin", "https://evil.example") + req.Header.Set("Authorization", "Bearer test-management-key") + rr := httptest.NewRecorder() + server.engine.ServeHTTP(rr, req) + + if got := rr.Header().Get("Access-Control-Allow-Origin"); got != "" { + t.Fatalf("Access-Control-Allow-Origin = %q, want empty", got) + } + + preflight := httptest.NewRequest(http.MethodOptions, "/v0/management/config", nil) + preflight.Header.Set("Origin", "https://evil.example") + preflight.Header.Set("Access-Control-Request-Method", http.MethodPut) + preflightRR := httptest.NewRecorder() + server.engine.ServeHTTP(preflightRR, preflight) + if preflightRR.Code != http.StatusForbidden { + t.Fatalf("preflight status = %d, want %d", preflightRR.Code, http.StatusForbidden) + } + if got := preflightRR.Header().Get("Access-Control-Allow-Origin"); got != "" { + t.Fatalf("preflight Access-Control-Allow-Origin = %q, want empty", got) + } +} + func TestHomeEnabledHidesManagementEndpointsAndControlPanel(t *testing.T) { t.Setenv("MANAGEMENT_PASSWORD", "test-management-key") diff --git a/internal/auth/claude/oauth_server.go b/internal/auth/claude/oauth_server.go index 49b04794..ff6eafb5 100644 --- a/internal/auth/claude/oauth_server.go +++ b/internal/auth/claude/oauth_server.go @@ -87,7 +87,7 @@ func (s *OAuthServer) Start() error { mux.HandleFunc("/success", s.handleSuccess) s.server = &http.Server{ - Addr: fmt.Sprintf(":%d", s.port), + Addr: fmt.Sprintf("127.0.0.1:%d", s.port), Handler: mux, ReadTimeout: 10 * time.Second, WriteTimeout: 10 * time.Second, @@ -309,7 +309,7 @@ func (s *OAuthServer) sendResult(result *OAuthResult) { // Returns: // - bool: True if the port is available, false otherwise func (s *OAuthServer) isPortAvailable() bool { - addr := fmt.Sprintf(":%d", s.port) + addr := fmt.Sprintf("127.0.0.1:%d", s.port) listener, err := net.Listen("tcp", addr) if err != nil { return false diff --git a/internal/auth/codex/oauth_server.go b/internal/auth/codex/oauth_server.go index 58b5394e..7e74c7bb 100644 --- a/internal/auth/codex/oauth_server.go +++ b/internal/auth/codex/oauth_server.go @@ -84,7 +84,7 @@ func (s *OAuthServer) Start() error { mux.HandleFunc("/success", s.handleSuccess) s.server = &http.Server{ - Addr: fmt.Sprintf(":%d", s.port), + Addr: fmt.Sprintf("127.0.0.1:%d", s.port), Handler: mux, ReadTimeout: 10 * time.Second, WriteTimeout: 10 * time.Second, @@ -306,7 +306,7 @@ func (s *OAuthServer) sendResult(result *OAuthResult) { // Returns: // - bool: True if the port is available, false otherwise func (s *OAuthServer) isPortAvailable() bool { - addr := fmt.Sprintf(":%d", s.port) + addr := fmt.Sprintf("127.0.0.1:%d", s.port) listener, err := net.Listen("tcp", addr) if err != nil { return false diff --git a/internal/auth/iflow/oauth_server.go b/internal/auth/iflow/oauth_server.go index 2a8b7b9f..b34e6ec5 100644 --- a/internal/auth/iflow/oauth_server.go +++ b/internal/auth/iflow/oauth_server.go @@ -55,7 +55,7 @@ func (s *OAuthServer) Start() error { mux.HandleFunc("/oauth2callback", s.handleCallback) s.server = &http.Server{ - Addr: fmt.Sprintf(":%d", s.port), + Addr: fmt.Sprintf("127.0.0.1:%d", s.port), Handler: mux, ReadTimeout: 10 * time.Second, WriteTimeout: 10 * time.Second, @@ -133,7 +133,7 @@ func (s *OAuthServer) sendResult(res *OAuthResult) { } func (s *OAuthServer) isPortAvailable() bool { - addr := fmt.Sprintf(":%d", s.port) + addr := fmt.Sprintf("127.0.0.1:%d", s.port) listener, err := net.Listen("tcp", addr) if err != nil { return false diff --git a/internal/logging/request_logger.go b/internal/logging/request_logger.go index 44b2c952..0fc965dc 100644 --- a/internal/logging/request_logger.go +++ b/internal/logging/request_logger.go @@ -192,6 +192,16 @@ func cloneHeaders(headers map[string][]string) map[string][]string { return out } +func cloneMaskedHeaders(headers map[string][]string) map[string][]string { + out := cloneHeaders(headers) + for key, values := range out { + for i, value := range values { + values[i] = util.MaskSensitiveHeaderValue(key, value) + } + } + return out +} + func (l *FileRequestLogger) forwardRequestLogToHome(ctx context.Context, headers map[string][]string, logText string) error { if l == nil || !l.homeEnabled { return nil @@ -201,7 +211,7 @@ func (l *FileRequestLogger) forwardRequestLogToHome(ctx context.Context, headers return nil } payload := homeRequestLogPayload{ - Headers: cloneHeaders(headers), + Headers: cloneMaskedHeaders(headers), RequestLog: logText, } raw, errMarshal := json.Marshal(&payload) diff --git a/internal/logging/request_logger_home_test.go b/internal/logging/request_logger_home_test.go index f8cdf1e4..3cc58830 100644 --- a/internal/logging/request_logger_home_test.go +++ b/internal/logging/request_logger_home_test.go @@ -85,8 +85,11 @@ func TestFileRequestLogger_HomeEnabled_ForwardsWhenRequestLogEnabled(t *testing. if got.Headers == nil || got.Headers["Content-Type"][0] != "application/json" { t.Fatalf("headers.content-type = %+v, want application/json", got.Headers["Content-Type"]) } - if got.Headers == nil || got.Headers["Authorization"][0] != "Bearer secret" { - t.Fatalf("headers.authorization = %+v, want Bearer secret", got.Headers["Authorization"]) + if got.Headers == nil || got.Headers["Authorization"][0] == "Bearer secret" { + t.Fatalf("headers.authorization = %+v, want redacted value", got.Headers["Authorization"]) + } + if got.Headers["Authorization"][0] == "" || got.Headers["Authorization"][0] == "Bearer " { + t.Fatalf("headers.authorization = %+v, want non-empty redacted value", got.Headers["Authorization"]) } if got.RequestLog == "" { t.Fatalf("request_log empty, want non-empty")