diff --git a/internal/api/handlers/management/auth_files_provider_oauth.go b/internal/api/handlers/management/auth_files_provider_oauth.go index a6e746cd8f..0d05798166 100644 --- a/internal/api/handlers/management/auth_files_provider_oauth.go +++ b/internal/api/handlers/management/auth_files_provider_oauth.go @@ -111,7 +111,7 @@ func (h *Handler) RequestAnthropicToken(c *gin.Context) { } // Generate random state parameter - state, err := misc.GenerateRandomState() + state, err := claude.GenerateState() if err != nil { log.Errorf("Failed to generate state parameter: %v", err) c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to generate state parameter"}) diff --git a/internal/api/handlers/management/oauth_claude_authorize_test.go b/internal/api/handlers/management/oauth_claude_authorize_test.go new file mode 100644 index 0000000000..8f4bd2c61d --- /dev/null +++ b/internal/api/handlers/management/oauth_claude_authorize_test.go @@ -0,0 +1,142 @@ +package management + +import ( + "bytes" + "errors" + "net/http" + "net/http/httptest" + "net/url" + "os" + "path/filepath" + "strings" + "testing" + + "github.com/MoeForge/moego/base64" + "github.com/MoeForge/moego/ojson" + "github.com/gin-gonic/gin" + "github.com/router-for-me/CLIProxyAPI/v8/internal/auth/claude" + "github.com/router-for-me/CLIProxyAPI/v8/internal/config" +) + +type claudeAuthorizationProbe struct { + *claude.ClaudeAuth + authURL string + state string +} + +func (p *claudeAuthorizationProbe) GenerateAuthURL(state string, pkceCodes *claude.PKCECodes) (string, string, error) { + authURL, returnedState, errGenerate := p.ClaudeAuth.GenerateAuthURL(state, pkceCodes) + if errGenerate != nil { + return "", "", errGenerate + } + p.authURL, p.state = authURL, returnedState + // Stop before starting a background callback waiter that could outlive this test. + return "", "", errors.New("authorization URL inspected") +} + +func TestClaudeOAuthV8CallbackPreservesURLSafeState(t *testing.T) { + gin.SetMode(gin.TestMode) + for _, form := range []string{"json", "redirect_url", "query"} { + t.Run(form, func(t *testing.T) { + authDir := t.TempDir() + handler := NewHandlerWithoutConfigFilePath(&config.Config{AuthDir: authDir}, nil) + router := gin.New() + router.POST("/v8/management/oauth/callback", handler.PostOAuthCallbackV8) + router.GET("/v8/management/oauth/callback", handler.GetOAuthCallbackV8) + state := strings.Repeat("Ab9-_", 8) + "AbA" + RegisterOAuthSession(state, "anthropic") + defer CancelOAuthSession(state) + + callbackRequest := func(callbackState string) *http.Request { + values := map[string]string{"provider": "claude", "code": "callback-code", "state": callbackState} + query := url.Values{} + for key, value := range values { + query.Set(key, value) + } + if form == "query" { + return httptest.NewRequest(http.MethodGet, "/v8/management/oauth/callback?"+query.Encode(), nil) + } + if form == "redirect_url" { + values = map[string]string{"redirect_url": "http://localhost:54545/callback?" + query.Encode()} + } + doc := ojson.NewDocString(`{}`) + for key, value := range values { + if errSet := doc.Set(key, value); errSet != nil { + t.Fatalf("set callback field %s: %v", key, errSet) + } + } + request := httptest.NewRequest(http.MethodPost, "/v8/management/oauth/callback", bytes.NewReader(doc.Bytes())) + request.Header.Set("Content-Type", "application/json") + return request + } + + wrongState := httptest.NewRecorder() + router.ServeHTTP(wrongState, callbackRequest(strings.ToLower(state))) + if wrongState.Code != http.StatusNotFound { + t.Fatalf("wrong-state callback status = %d, want 404: %s", wrongState.Code, wrongState.Body.String()) + } + entries, errReadDir := os.ReadDir(authDir) + if errReadDir != nil || len(entries) != 0 { + t.Fatalf("wrong-state callback wrote a file: entries = %v, error = %v", entries, errReadDir) + } + + response := httptest.NewRecorder() + router.ServeHTTP(response, callbackRequest(state)) + if response.Code != http.StatusOK { + t.Fatalf("callback status = %d, want 200: %s", response.Code, response.Body.String()) + } + payload, errRead := os.ReadFile(filepath.Join(authDir, ".oauth-anthropic-"+state+".oauth")) + if errRead != nil { + t.Fatalf("read callback file: %v", errRead) + } + if got := ojson.GetBytesNoCopy(payload, "state").String(); got != state { + t.Fatalf("callback file state = %q, want %q", got, state) + } + if got := ojson.GetBytesNoCopy(payload, "code").String(); got != "callback-code" { + t.Fatalf("callback file code = %q, want callback-code", got) + } + }) + } +} + +func TestStartOAuthV8ClaudeUsesNativeAuthorizationParameters(t *testing.T) { + gin.SetMode(gin.TestMode) + probe := &claudeAuthorizationProbe{ClaudeAuth: &claude.ClaudeAuth{}} + originalFactory := newClaudeOAuthService + newClaudeOAuthService = func(*config.Config, string) claudeOAuthService { return probe } + defer func() { newClaudeOAuthService = originalFactory }() + + handler := NewHandlerWithoutConfigFilePath(&config.Config{AuthDir: t.TempDir()}, nil) + router := gin.New() + router.POST("/v8/management/oauth/auth-url", handler.StartOAuthV8) + + request := httptest.NewRequest(http.MethodPost, "/v8/management/oauth/auth-url", strings.NewReader(`{"provider":"claude"}`)) + request.Header.Set("Content-Type", "application/json") + response := httptest.NewRecorder() + router.ServeHTTP(response, request) + if response.Code != http.StatusInternalServerError { + t.Fatalf("authorization probe status = %d, want 500: %s", response.Code, response.Body.String()) + } + state := probe.state + if len(state) != 43 { + t.Errorf("state length = %d, want 43", len(state)) + } + decoded, errDecode := base64.RawURLEncoding.DecodeString(state) + if errDecode != nil || len(decoded) != 32 { + t.Errorf("state must encode 32 random bytes as unpadded base64url: decoded length = %d, error = %v", len(decoded), errDecode) + } + if errValidate := ValidateOAuthState(state); errValidate != nil { + t.Errorf("generated state cannot be used by the callback handler: %v", errValidate) + } + parsed, errParse := url.Parse(probe.authURL) + if errParse != nil { + t.Fatalf("parse authorization URL: %v", errParse) + } + if got := parsed.Query().Get("state"); got != state { + t.Error("authorization URL did not preserve the generated state") + } + const wantScope = "org:create_api_key user:profile user:inference user:sessions:claude_code user:mcp_servers user:file_upload" + if got := parsed.Query().Get("scope"); got != wantScope { + t.Errorf("authorization scope = %q, want %q", got, wantScope) + } +} diff --git a/internal/auth/claude/anthropic_auth.go b/internal/auth/claude/anthropic_auth.go index b3b2618fd3..c6dd901e0f 100644 --- a/internal/auth/claude/anthropic_auth.go +++ b/internal/auth/claude/anthropic_auth.go @@ -34,6 +34,10 @@ const ( RedirectURI = "http://localhost:54545/callback" ClaudeOAuthScope = "user:profile user:inference user:sessions:claude_code user:mcp_servers user:file_upload" + // Native Claude Code includes the Console scope when authorizing a new login. + // Keep the established token refresh scope unchanged. + claudeOAuthAuthorizeScope = "org:create_api_key " + ClaudeOAuthScope + claudeRefreshMinBackoff = 5 * time.Second claudeRefreshMaxBackoff = 5 * time.Minute claudeRefreshTimeout = 30 * time.Second @@ -330,7 +334,7 @@ func (o *ClaudeAuth) GenerateAuthURL(state string, pkceCodes *PKCECodes) (string "client_id": {ClientID}, "response_type": {"code"}, "redirect_uri": {RedirectURI}, - "scope": {ClaudeOAuthScope}, + "scope": {claudeOAuthAuthorizeScope}, "code_challenge": {pkceCodes.CodeChallenge}, "code_challenge_method": {"S256"}, "state": {state}, diff --git a/internal/auth/claude/anthropic_auth_test.go b/internal/auth/claude/anthropic_auth_test.go index aaa8e2ddd7..90def0d818 100644 --- a/internal/auth/claude/anthropic_auth_test.go +++ b/internal/auth/claude/anthropic_auth_test.go @@ -129,6 +129,7 @@ func TestExchangeCodeForTokensUsesNative220ControlPlaneShape(t *testing.T) { var order []string headers := make(map[string]http.Header) var tokenBody []byte + state := strings.Repeat("Ab9-_", 8) + "AbA" auth := &ClaudeAuth{ httpClient: &http.Client{ @@ -168,7 +169,7 @@ func TestExchangeCodeForTokensUsesNative220ControlPlaneShape(t *testing.T) { }, } - bundle, errExchange := auth.ExchangeCodeForTokens(t.Context(), "auth-code", "state-value", &PKCECodes{CodeVerifier: "verifier"}) + bundle, errExchange := auth.ExchangeCodeForTokens(t.Context(), "auth-code", state, &PKCECodes{CodeVerifier: "verifier"}) if errExchange != nil { t.Fatalf("ExchangeCodeForTokens() error = %v", errExchange) } @@ -184,7 +185,7 @@ func TestExchangeCodeForTokensUsesNative220ControlPlaneShape(t *testing.T) { } // Key order mirrors the captured native exchange body. - wantBody := `{"grant_type":"authorization_code","code":"auth-code","redirect_uri":"` + RedirectURI + `","client_id":"` + ClientID + `","code_verifier":"verifier","state":"state-value"}` + wantBody := `{"grant_type":"authorization_code","code":"auth-code","redirect_uri":"` + RedirectURI + `","client_id":"` + ClientID + `","code_verifier":"verifier","state":"` + state + `"}` if got := string(tokenBody); got != wantBody { t.Fatalf("exchange body = %q, want %q", got, wantBody) } @@ -499,7 +500,7 @@ func TestRefreshTokensUsesNative220ControlPlaneShape(t *testing.T) { if errRead != nil { t.Fatal(errRead) } - wantBody := `{"client_id":"` + ClientID + `","grant_type":"refresh_token","refresh_token":"` + refreshToken + `","scope":"` + ClaudeOAuthScope + `"}` + wantBody := `{"client_id":"` + ClientID + `","grant_type":"refresh_token","refresh_token":"` + refreshToken + `","scope":"user:profile user:inference user:sessions:claude_code user:mcp_servers user:file_upload"}` if got := string(body); got != wantBody { t.Fatalf("refresh body = %q, want %q", got, wantBody) } diff --git a/internal/auth/claude/oauth_authorize_test.go b/internal/auth/claude/oauth_authorize_test.go new file mode 100644 index 0000000000..7f213d40b8 --- /dev/null +++ b/internal/auth/claude/oauth_authorize_test.go @@ -0,0 +1,50 @@ +package claude + +import ( + "net/url" + "strings" + "testing" + + "github.com/MoeForge/moego/base64" +) + +func TestGenerateStateMatchesNativeClaudeCode(t *testing.T) { + seen := make(map[string]struct{}) + for range 4 { + state, errGenerate := GenerateState() + if errGenerate != nil { + t.Fatalf("GenerateState() error = %v", errGenerate) + } + if len(state) != 43 { + t.Fatalf("state length = %d, want 43", len(state)) + } + decoded, errDecode := base64.RawURLEncoding.DecodeString(state) + if errDecode != nil || len(decoded) != 32 { + t.Fatalf("state must encode 32 random bytes as unpadded base64url: decoded length = %d, error = %v", len(decoded), errDecode) + } + if _, duplicate := seen[state]; duplicate { + t.Fatal("GenerateState() reused a state") + } + seen[state] = struct{}{} + } +} + +func TestGenerateAuthURLUsesNativeClaudeCodeScopes(t *testing.T) { + state := strings.Repeat("Ab9-_", 8) + "AbA" + auth := &ClaudeAuth{} + authURL, returnedState, errGenerate := auth.GenerateAuthURL(state, &PKCECodes{CodeChallenge: "challenge"}) + if errGenerate != nil { + t.Fatalf("GenerateAuthURL() error = %v", errGenerate) + } + parsed, errParse := url.Parse(authURL) + if errParse != nil { + t.Fatalf("parse authorization URL: %v", errParse) + } + const wantScope = "org:create_api_key user:profile user:inference user:sessions:claude_code user:mcp_servers user:file_upload" + if got := parsed.Query().Get("scope"); got != wantScope { + t.Errorf("authorization scope = %q, want %q", got, wantScope) + } + if returnedState != state || parsed.Query().Get("state") != state { + t.Error("authorization URL did not preserve the supplied state") + } +} diff --git a/internal/auth/claude/pkce.go b/internal/auth/claude/pkce.go index e8b11f9a9c..5c71aa22a9 100644 --- a/internal/auth/claude/pkce.go +++ b/internal/auth/claude/pkce.go @@ -11,6 +11,15 @@ import ( "github.com/MoeForge/moego/base64" ) +// GenerateState returns a 43-character OAuth state matching native Claude Code. +func GenerateState() (string, error) { + stateBytes := make([]byte, 32) + if _, err := rand.Read(stateBytes); err != nil { + return "", fmt.Errorf("failed to generate Claude OAuth state: %w", err) + } + return base64.RawURLEncoding.EncodeToString(stateBytes), nil +} + // GeneratePKCECodes generates a PKCE code verifier and challenge pair // following RFC 7636 specifications for OAuth 2.0 PKCE extension. // This provides additional security for the OAuth flow by ensuring that diff --git a/sdk/auth/claude.go b/sdk/auth/claude.go index 346a65bc05..6204b1624f 100644 --- a/sdk/auth/claude.go +++ b/sdk/auth/claude.go @@ -56,7 +56,7 @@ func (a *ClaudeAuthenticator) Login(ctx context.Context, cfg *config.Config, opt return nil, fmt.Errorf("claude pkce generation failed: %w", err) } - state, err := misc.GenerateRandomState() + state, err := claude.GenerateState() if err != nil { return nil, fmt.Errorf("claude state generation failed: %w", err) }