fix(claude): align OAuth authorization state and scopes

Use a Claude-specific 256-bit base64url state for CLI and management logins. Include the native Console scope only during authorization while preserving existing token refresh scopes. Cover callback state preservation and case-sensitive session checks. Refs #7316.
This commit is contained in:
Dylan
2026-11-07 12:05:08 +08:00
parent 482efbf5a7
commit ea0b471291
7 changed files with 212 additions and 6 deletions

View File

@@ -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"})

View File

@@ -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)
}
}

View File

@@ -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},

View File

@@ -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)
}

View File

@@ -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")
}
}

View File

@@ -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

View File

@@ -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)
}