diff --git a/apps/api-go/constant/context_key.go b/apps/api-go/constant/context_key.go index f4cc815a6..c981a0e04 100644 --- a/apps/api-go/constant/context_key.go +++ b/apps/api-go/constant/context_key.go @@ -57,6 +57,10 @@ const ( ContextKeyUpstreamCapabilityMismatch ContextKey = "upstream_capability_mismatch" ContextKeyUpstreamUnsupportedParameter ContextKey = "upstream_unsupported_parameter" + // Latched after a decoded asynchronous submission supplies a task ID. This + // prevents resubmission within this relay request; it is not billing state. + ContextKeyUpstreamAsyncTaskAccepted ContextKey = "upstream_async_task_accepted" + ContextKeyAutoGroup ContextKey = "auto_group" ContextKeyAutoGroupIndex ContextKey = "auto_group_index" ContextKeyAutoGroupRetryIndex ContextKey = "auto_group_retry_index" diff --git a/apps/api-go/controller/drawing_billing_parity_test.go b/apps/api-go/controller/drawing_billing_parity_test.go index d81ea3d6a..7bc4f43fd 100644 --- a/apps/api-go/controller/drawing_billing_parity_test.go +++ b/apps/api-go/controller/drawing_billing_parity_test.go @@ -36,6 +36,11 @@ type drawingParityFixture struct { // This uses only the existing isolated SQL unit-test fixture and a loopback // mock provider. It is not a production/strict-PostgreSQL acceptance rehearsal. func newDrawingParityFixture(t *testing.T, quota int, upstreamStatus int, upstreamResponse ...json.RawMessage) *drawingParityFixture { + return newDrawingParityFixtureWithProviderURL(t, quota, upstreamStatus, "", upstreamResponse...) +} + +// A supplied provider URL allows transport-only tests without a listening server. +func newDrawingParityFixtureWithProviderURL(t *testing.T, quota int, upstreamStatus int, providerURL string, upstreamResponse ...json.RawMessage) *drawingParityFixture { t.Helper() setupAssistantCurrencyTest(t) previousDB, previousLogDB := model.DB, model.LOG_DB @@ -79,28 +84,31 @@ func newDrawingParityFixture(t *testing.T, quota int, upstreamStatus int, upstre RemainQuota: common.GetTrustQuota(), UnlimitedQuota: false, } require.NoError(t, db.Create(&fixture.token).Error) - upstream := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { - fixture.upstream.Add(1) - if r.URL.Path != "/v1/images/generations" { - http.Error(w, "unexpected mock-provider route", http.StatusNotFound) - return - } - w.Header().Set("Content-Type", "application/json") - w.WriteHeader(upstreamStatus) - if upstreamStatus != http.StatusOK { - _, _ = w.Write([]byte(`{"error":{"message":"mock provider rejected request","type":"invalid_request_error","code":"invalid_request"}}`)) - return - } - if len(upstreamResponse) != 0 { - _, _ = w.Write(upstreamResponse[0]) - return - } - _, _ = w.Write([]byte(`{"created":1,"data":[{"url":"https://example.test/parity-1.png"},{"url":"https://example.test/parity-2.png"}]}`)) - })) - t.Cleanup(upstream.Close) + if providerURL == "" { + upstream := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + fixture.upstream.Add(1) + if r.URL.Path != "/v1/images/generations" { + http.Error(w, "unexpected mock-provider route", http.StatusNotFound) + return + } + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(upstreamStatus) + if upstreamStatus != http.StatusOK { + _, _ = w.Write([]byte(`{"error":{"message":"mock provider rejected request","type":"invalid_request_error","code":"invalid_request"}}`)) + return + } + if len(upstreamResponse) != 0 { + _, _ = w.Write(upstreamResponse[0]) + return + } + _, _ = w.Write([]byte(`{"created":1,"data":[{"url":"https://example.test/parity-1.png"},{"url":"https://example.test/parity-2.png"}]}`)) + })) + t.Cleanup(upstream.Close) + providerURL = upstream.URL + } fixture.channel = model.Channel{ Type: constant.ChannelTypeOpenAI, Status: common.ChannelStatusEnabled, - Name: "mock drawing billing", Key: "mock-upstream-key", BaseURL: &upstream.URL, + Name: "mock drawing billing", Key: "mock-upstream-key", BaseURL: &providerURL, Models: drawingParityModel, Group: "image-2", } require.NoError(t, db.Create(&fixture.channel).Error) diff --git a/apps/api-go/controller/drawing_mcp_oauth_grant_test.go b/apps/api-go/controller/drawing_mcp_oauth_grant_test.go new file mode 100644 index 000000000..ba2f731b4 --- /dev/null +++ b/apps/api-go/controller/drawing_mcp_oauth_grant_test.go @@ -0,0 +1,210 @@ +package controller + +import ( + "context" + "crypto/sha256" + "encoding/base64" + "encoding/json" + "net/http" + "net/http/httptest" + "net/url" + "strconv" + "strings" + "testing" + + "github.com/LIghtJUNction/api.lmm.best/common" + "github.com/LIghtJUNction/api.lmm.best/model" + "github.com/LIghtJUNction/api.lmm.best/oauthserver" + "github.com/LIghtJUNction/api.lmm.best/service" + "github.com/modelcontextprotocol/go-sdk/auth" + "github.com/modelcontextprotocol/go-sdk/mcp" + "github.com/stretchr/testify/require" +) + +func drawingOAuthCredentials(t *testing.T, integration *service.OAuthIntegration, userID int, groups ...string) *oauthserver.TokenResponse { + t.Helper() + ctx := context.Background() + verifier := strings.Repeat("v", 43) + challenge := sha256.Sum256([]byte(verifier)) + binding := strings.Repeat("b", 43) + scopes := []string{service.OAuthMCPDrawingScope} + for _, group := range groups { + scopes = append(scopes, service.OAuthGroupScope(group)) + } + query := url.Values{ + "response_type": {"code"}, "client_id": {service.OAuthPiClientID}, + "redirect_uri": {service.OAuthNativeRedirect}, "resource": {integration.Resource}, + "scope": {strings.Join(scopes, " ")}, "state": {strings.Repeat("s", 32)}, + "code_challenge": {base64.RawURLEncoding.EncodeToString(challenge[:])}, "code_challenge_method": {"S256"}, + } + pending, err := integration.Core.BeginAuthorization(ctx, query.Encode(), binding) + require.NoError(t, err) + consent, err := integration.Core.TrustedPrepareConsent(ctx, pending.Transaction, binding, int64(userID)) + require.NoError(t, err) + approved, err := integration.Core.TrustedApprove(ctx, pending.Transaction, binding, consent.Secret) + require.NoError(t, err) + redirect, err := url.Parse(approved.RedirectURI) + require.NoError(t, err) + credentials, err := integration.Core.Exchange(ctx, url.Values{ + "grant_type": {"authorization_code"}, "client_id": {service.OAuthPiClientID}, + "redirect_uri": {service.OAuthNativeRedirect}, "resource": {integration.Resource}, + "code": {redirect.Query().Get("code")}, "code_verifier": {verifier}, + }.Encode(), oauthserver.SenderBinding{}) + require.NoError(t, err) + return credentials +} + +func TestDrawingMCPOAuthGrantBoundsEndToEnd(t *testing.T) { + fixture := newDrawingParityFixture(t, common.GetTrustQuota(), http.StatusOK) + db := fixture.db + require.NoError(t, db.AutoMigrate(&model.OpenSourceBountyMCPConfirmation{}, &model.OpenSourceBountyMCPOperation{})) + require.NoError(t, model.MigrateOAuthBilling(db)) + setAssistantKeyOption(t, db, "UserUsableGroups", `{"default":"Chat","image-2":"Drawing","image-alt":"Other drawing"}`) + setAssistantKeyOption(t, db, "GroupRatio", `{"default":1,"image-2":1,"image-alt":1}`) + alternative := fixture.channel + alternative.Id = 0 + alternative.Name, alternative.Group = "other local drawing group", "image-alt" + require.NoError(t, db.Create(&alternative).Error) + require.NoError(t, alternative.AddAbilities(nil)) + model.InvalidatePricingCache() + + require.Nil(t, service.CurrentOAuthIntegration()) + integration, err := service.ConfigureOAuthIntegration(db, service.OAuthServerConfig{ + Enabled: true, Issuer: "https://drawing-oauth.example.test", Groups: []string{"default", "image-2", "image-alt"}, + }) + require.NoError(t, err) + t.Cleanup(func() { _, _ = service.ConfigureOAuthIntegration(nil, service.OAuthServerConfig{}) }) + toolMarketBuiltinDrawingRelay.Lock() + previousRelay := toolMarketBuiltinDrawingRelay.handler + toolMarketBuiltinDrawingRelay.Unlock() + t.Cleanup(func() { SetToolMarketBuiltinDrawingRelay(previousRelay) }) + server := httptest.NewServer(NewDrawingMCPHandler()) + t.Cleanup(server.Close) + connect := func(credentials *oauthserver.TokenResponse) *mcp.ClientSession { + client := mcp.NewClient(&mcp.Implementation{Name: "drawing-oauth-grant-test", Version: "1"}, &mcp.ClientOptions{ + MultiRoundTrip: &mcp.MultiRoundTripOptions{Disabled: true}, + }) + session, err := client.Connect(context.Background(), &mcp.StreamableClientTransport{ + Endpoint: server.URL, HTTPClient: &http.Client{Transport: drawingMCPBearerTransport{token: credentials.AccessToken}}, DisableStandaloneSSE: true, + }, nil) + require.NoError(t, err) + t.Cleanup(func() { _ = session.Close() }) + return session + } + limited := connect(drawingOAuthCredentials(t, integration, fixture.user.Id, "default", "image-alt")) + capabilities, err := limited.CallTool(context.Background(), &mcp.CallToolParams{Name: "drawing.list_capabilities", Arguments: map[string]any{}}) + require.NoError(t, err) + require.False(t, capabilities.IsError) + encoded, err := json.Marshal(capabilities.StructuredContent) + require.NoError(t, err) + var catalog struct { + Data struct { + Groups []drawingMCPGroup `json:"groups"` + } `json:"data"` + } + require.NoError(t, json.Unmarshal(encoded, &catalog)) + var names []string + for _, group := range catalog.Data.Groups { + names = append(names, group.Name) + } + + // Every denied spelling must stop before confirmation persistence, key + // creation/resolution, provider execution, or quota consumption. + for _, group := range []string{"image-2", " image-2 ", "IMAGE-ALT", "auto", service.OAuthGroupID("image-alt"), service.OAuthGroupScope("image-alt")} { + result, err := limited.CallTool(context.Background(), &mcp.CallToolParams{Name: "drawing.generate", Arguments: map[string]any{ + "prompt": "local authorization fixture", "group": group, "model": drawingParityModel, + }}) + require.NoError(t, err) + require.True(t, result.IsError, "group %q", group) + require.Empty(t, result.InputRequests) + } + require.ElementsMatch(t, []string{"default", "image-alt"}, names) + var confirmations, keys int64 + require.NoError(t, db.Model(&model.OpenSourceBountyMCPConfirmation{}).Count(&confirmations).Error) + require.Zero(t, confirmations) + require.NoError(t, db.Model(&model.Token{}).Count(&keys).Error) + require.EqualValues(t, 1, keys) + require.Zero(t, fixture.upstream.Load()) + + for _, group := range []string{"", " image-alt "} { + result, err := limited.CallTool(context.Background(), &mcp.CallToolParams{Name: "drawing.generate", Arguments: map[string]any{ + "prompt": "local authorized alternative", "group": group, "model": drawingParityModel, + }}) + require.NoError(t, err) + require.False(t, result.IsError) + require.True(t, result.NeedsInput()) + confirmation, ok := result.InputRequests["confirmation"].(*mcp.ElicitParams) + require.True(t, ok) + require.Contains(t, confirmation.Message, `group "image-alt"`) + } + require.Zero(t, fixture.upstream.Load()) + + // Ordinary image-2 grants retain their default, explicit confirmation and + // real key-backed local relay billing. + credentials := drawingOAuthCredentials(t, integration, fixture.user.Id, "default", "image-2") + allowed := connect(credentials) + arguments := map[string]any{"prompt": "local authorized drawing", "model": drawingParityModel} + pending, err := allowed.CallTool(context.Background(), &mcp.CallToolParams{Name: "drawing.generate", Arguments: arguments}) + require.NoError(t, err) + require.False(t, pending.IsError) + require.True(t, pending.NeedsInput()) + confirmation, ok := pending.InputRequests["confirmation"].(*mcp.ElicitParams) + require.True(t, ok) + require.Contains(t, confirmation.Message, `group "image-2"`) + completed, err := allowed.CallTool(context.Background(), &mcp.CallToolParams{ + Name: "drawing.generate", Arguments: arguments, RequestState: pending.RequestState, + InputResponses: mcp.InputResponseMap{"confirmation": &mcp.ElicitResult{Action: "accept", Content: map[string]any{"confirmed": true}}}, + }) + require.NoError(t, err) + require.False(t, completed.IsError) + require.EqualValues(t, 1, fixture.upstream.Load()) + var user model.User + require.NoError(t, db.First(&user, fixture.user.Id).Error) + require.Less(t, user.Quota, fixture.user.Quota) + // The handler still revalidates the bearer on every call. + require.NoError(t, integration.Core.Revoke(context.Background(), url.Values{"client_id": {service.OAuthPiClientID}, "token": {credentials.AccessToken}}.Encode())) + _, err = allowed.CallTool(context.Background(), &mcp.CallToolParams{Name: "drawing.generate", Arguments: arguments}) + require.Error(t, err) + require.EqualValues(t, 1, fixture.upstream.Load()) +} + +func TestDrawingMCPOAuthGrantMetadataFailsClosed(t *testing.T) { + fixture := newDrawingParityFixture(t, common.GetTrustQuota(), http.StatusOK) + require.NoError(t, fixture.db.AutoMigrate(&model.OpenSourceBountyMCPConfirmation{}, &model.OpenSourceBountyMCPOperation{})) + relay := http.HandlerFunc(func(http.ResponseWriter, *http.Request) { t.Fatal("denied grant reached relay") }) + for name, extra := range map[string]map[string]any{ + "missing": {"oauth": true}, + "empty": {"oauth": true, "granted_groups": []string{}}, + "null": {"oauth": true, "granted_groups": nil}, + "string": {"oauth": true, "granted_groups": "image-2"}, + "untyped array": {"oauth": true, "granted_groups": []any{"image-2"}}, + "empty member": {"oauth": true, "granted_groups": []string{"image-2", ""}}, + "whitespace member": {"oauth": true, "granted_groups": []string{" image-2 "}}, + "control member": {"oauth": true, "granted_groups": []string{"image-2", "bad\x00group"}}, + "oversized member": {"oauth": true, "granted_groups": []string{strings.Repeat("x", 65)}}, + "auto member": {"oauth": true, "granted_groups": []string{"auto"}}, + "malformed marker": {"oauth": "true", "granted_groups": []string{"image-2"}}, + } { + t.Run(name, func(t *testing.T) { + for _, tool := range []string{"drawing.generate", "drawing.list_capabilities"} { + args := map[string]any{} + if tool == "drawing.generate" { + args["prompt"], args["group"] = "local metadata fixture", "image-2" + } + result, err := callBuiltinToolMarketServer(context.Background(), newDrawingMCPServer(relay), &auth.TokenInfo{UserID: strconv.Itoa(fixture.user.Id), Extra: extra}, &mcp.CallToolParams{Name: tool, Arguments: args}) + require.NoError(t, err) + require.True(t, result.IsError) + require.Empty(t, result.InputRequests) + } + }) + } + result, err := callBuiltinToolMarketServer(context.Background(), newDrawingMCPServer(relay), &auth.TokenInfo{UserID: strconv.Itoa(fixture.user.Id), Extra: map[string]any{ + "oauth": true, "granted_groups": []string{"default"}, + }}, &mcp.CallToolParams{Name: "drawing.generate", Arguments: map[string]any{"prompt": "chat-only grant must not default to drawing"}}) + require.NoError(t, err) + require.True(t, result.IsError) + var count int64 + require.NoError(t, fixture.db.Model(&model.OpenSourceBountyMCPConfirmation{}).Count(&count).Error) + require.Zero(t, count) + require.Zero(t, fixture.upstream.Load()) +} diff --git a/apps/api-go/controller/drawing_mcp_server.go b/apps/api-go/controller/drawing_mcp_server.go index c4a3bdd66..17640606d 100644 --- a/apps/api-go/controller/drawing_mcp_server.go +++ b/apps/api-go/controller/drawing_mcp_server.go @@ -113,6 +113,70 @@ func drawingMCPGroups(userGroup string) []drawingMCPGroup { return result } +// Only the bearer verifier supplies OAuth grant metadata. A missing or malformed +// group snapshot must not turn an OAuth credential into account-wide access. +// Personal API-key and exact marketplace-tool grants keep their own policies. +func drawingMCPGrantedGroups(request *mcp.CallToolRequest) ([]string, error) { + if request == nil || request.Extra == nil || request.Extra.TokenInfo == nil { + return nil, nil + } + extra := request.Extra.TokenInfo.Extra + rawOAuth, exists := extra["oauth"] + if !exists { + return nil, nil + } + oauth, ok := rawOAuth.(bool) + if !ok { + return nil, errors.New("drawing MCP OAuth grant metadata is invalid") + } + if !oauth { + return nil, nil + } + groups, ok := extra["granted_groups"].([]string) + if !ok || len(groups) == 0 { + return nil, errors.New("drawing MCP OAuth grant has no authorized routing groups") + } + for _, group := range groups { + // Reuse the issuer's canonical group grammar without normalizing the + // trusted grant into a different group or silently skipping bad members. + if _, err := service.OAuthGroupFromID(service.OAuthGroupID(group)); err != nil { + return nil, errors.New("drawing MCP OAuth grant metadata is invalid") + } + } + return groups, nil +} + +func drawingMCPGroupForGrant(userGroup, requested string, granted []string) (string, error) { + if granted == nil { + return requested, nil + } + requested = strings.TrimSpace(requested) + if requested != "" { + if !slices.Contains(granted, requested) { + return "", errors.New("the selected routing group is not authorized by this OAuth grant") + } + return requested, nil + } + // Prefer the ordinary drawing default only when it is both granted and + // image-capable. Other granted groups can be chat-only; do not select those. + var fallback string + for _, group := range drawingMCPGroups(userGroup) { + if !slices.Contains(granted, group.Name) || len(group.Models) == 0 { + continue + } + if group.Name == model.DrawingTokenGroup { + return group.Name, nil + } + if fallback == "" { + fallback = group.Name + } + } + if fallback == "" { + return "", errors.New("this OAuth grant has no available image routing group") + } + return fallback, nil +} + func drawingMCPResolveInput(user *model.UserBase, input drawingMCPGenerateInput) (drawingMCPGenerateInput, error) { input.Prompt = strings.TrimSpace(input.Prompt) if input.Prompt == "" || len([]rune(input.Prompt)) > drawingMCPMaxPromptRunes { @@ -220,11 +284,19 @@ func registerDrawingMCPTools(server *mcp.Server, relay http.Handler) { if err != nil { return nil, drawingMCPOutput{}, err } + granted, err := drawingMCPGrantedGroups(request) + if err != nil { + return nil, drawingMCPOutput{}, err + } + groups := drawingMCPGroups(user.Group) + if granted != nil { + groups = slices.DeleteFunc(groups, func(group drawingMCPGroup) bool { return !slices.Contains(granted, group.Name) }) + } return nil, drawingMCPOutput{ Message: "Drawing capabilities loaded.", Data: map[string]any{ "enabled": true, - "groups": drawingMCPGroups(user.Group), + "groups": groups, "max_images": drawingMCPMaxImages, "max_prompt_len": drawingMCPMaxPromptRunes, "endpoint": "/mcp/drawing", @@ -245,6 +317,14 @@ func registerDrawingMCPTools(server *mcp.Server, relay http.Handler) { if err != nil { return nil, drawingMCPOutput{}, err } + granted, err := drawingMCPGrantedGroups(request) + if err != nil { + return nil, drawingMCPOutput{}, err + } + input.Group, err = drawingMCPGroupForGrant(user.Group, input.Group, granted) + if err != nil { + return nil, drawingMCPOutput{}, err + } apiKeyID, err := drawingMCPAPIKeyID(request) if err != nil { return nil, drawingMCPOutput{}, err @@ -555,7 +635,7 @@ func NewDrawingMCPHandler(sharedAdmission ...gin.HandlerFunc) http.Handler { if err != nil { return nil, fmt.Errorf("%w: invalid OAuth MCP grant", auth.ErrInvalidToken) } - return &auth.TokenInfo{UserID: strconv.FormatInt(int64(user.Id), 10), Scopes: []string{service.OAuthMCPDrawingScope}, Extra: map[string]any{"protocol_version": openSourceBountyMCPProtocolVersion, "oauth": true, "scope_count": len(grant.Scopes)}}, nil + return &auth.TokenInfo{UserID: strconv.FormatInt(int64(user.Id), 10), Scopes: []string{service.OAuthMCPDrawingScope}, Extra: map[string]any{"protocol_version": openSourceBountyMCPProtocolVersion, "oauth": true, "scope_count": len(grant.Scopes), "granted_groups": integration.GrantedGroups(user, grant)}}, nil } identity, err := model.VerifyDrawingMCPToken(token) if err != nil { diff --git a/apps/api-go/controller/ip_access_routing.go b/apps/api-go/controller/ip_access_routing.go index bb454ce57..7dcfbc743 100644 --- a/apps/api-go/controller/ip_access_routing.go +++ b/apps/api-go/controller/ip_access_routing.go @@ -23,6 +23,17 @@ import ( "github.com/gin-gonic/gin" ) +const ( + ipPolicyBypassSourceFailures = 10 + ipPolicyBypassGlobalFailures = 256 + ipPolicyBypassWindowSeconds = 60 +) + +// Keep optional, unauthenticated bypass work bounded even when credentials or +// source addresses rotate. Only canonical client IPs and a constant global key +// are retained; authorization decisions and credentials are never cached here. +var ipPolicyBypassLimiter = &common.InMemoryRateLimiter{} + func ipAccessRoutingError(c *gin.Context, status int, code string, message string) { c.Header(accessPolicyResultHeader, accessPolicyDenied) c.AbortWithStatusJSON(status, gin.H{ @@ -54,7 +65,7 @@ func loopbackPeer(remoteAddr string) bool { // relayTokenKeyFromAuthorizationHeader mirrors the credential extraction used // by the relay token middlewares (Bearer/"sk-" prefix, group suffix split). // Duplicated here in miniature rather than exported across packages because -// this internal policy check must stay a read-only, side-effect-free lookup. +// this internal policy check must not run relay authentication side effects. func relayTokenKeyFromAuthorizationHeader(header string) string { key := strings.TrimSpace(header) if key == "" { @@ -71,15 +82,37 @@ func relayTokenKeyFromAuthorizationHeader(header string) string { // carries a valid API key belonging to an enabled, L1+ trust-level user who // has explicitly opted in to bypassing the IP/region access policy. Any // failure (missing/invalid key, insufficient trust, opt-in disabled, or a -// lookup error) must fall through to the normal policy evaluation below +// lookup error, or exhausted lookup budget) must preserve the policy rejection // without ever revealing which specific check failed — that concealment is // the existing job of authenticateRelayToken once the request reaches the // Go application layer. -func keyBypassesIPPolicy(c *gin.Context) bool { +func keyBypassesIPPolicy(c *gin.Context) (bypassed bool) { key := relayTokenKeyFromAuthorizationHeader(c.GetHeader("Authorization")) if key == "" { return false } + clientIP, err := netip.ParseAddr(strings.TrimSpace(c.GetHeader("X-Original-Client-IP"))) + if err != nil { + return false + } + // Reserve before lookup, not Check followed by Request: concurrent misses + // must already occupy capacity. Take the global reservation first so source + // churn cannot evict an exhausted global budget. In-flight work stays pinned + // across expiry; all unsuccessful bypasses consume the failure budget. + completeGlobal, allowed := ipPolicyBypassLimiter.Reserve("global", ipPolicyBypassGlobalFailures, ipPolicyBypassWindowSeconds) + if !allowed { + return false + } + completeSource, allowed := ipPolicyBypassLimiter.Reserve("source:"+clientIP.Unmap().String(), ipPolicyBypassSourceFailures, ipPolicyBypassWindowSeconds) + if !allowed { + completeGlobal(false) + return false + } + defer func() { + completeSource(!bypassed) + completeGlobal(!bypassed) + }() + token, err := model.ValidateUserToken(key) if err != nil { return false @@ -104,11 +137,6 @@ func CheckIPAccessRoutingPolicy(c *gin.Context) { return } - if keyBypassesIPPolicy(c) { - c.Status(http.StatusNoContent) - return - } - originalIP := strings.TrimSpace(c.GetHeader("X-Original-Client-IP")) edgeCountry := strings.ToUpper(strings.TrimSpace(c.GetHeader("X-LMM-Edge-Country"))) if edgeCountry == "" && strings.TrimSpace(c.GetHeader("X-LMM-CN-Source")) == "1" { @@ -144,11 +172,25 @@ func CheckIPAccessRoutingPolicy(c *gin.Context) { DSCPSet: dscpRaw != "" && dscpErr == nil, }) if err != nil { + // Missing optional edge attributes (for example unavailable GeoIP) can + // make a rule undecidable. Preserve the opt-in key escape hatch for + // these requests, with the same bounded lookup as a definite rejection. + // Malformed country metadata and missing/invalid client IPs fail closed; + // keyBypassesIPPolicy validates the latter before reserving any work. + countryValid := edgeCountry == "" || (len(edgeCountry) == 2 && edgeCountry[0] >= 'A' && edgeCountry[0] <= 'Z' && edgeCountry[1] >= 'A' && edgeCountry[1] <= 'Z') + if countryValid && keyBypassesIPPolicy(c) { + c.Status(http.StatusNoContent) + return + } common.SysError("IP access routing evaluation failed: " + err.Error()) ipAccessRoutingError(c, http.StatusForbidden, "POLICY_UNAVAILABLE", "access policy unavailable") return } if action == setting.IPAccessRouteReject { + if keyBypassesIPPolicy(c) { + c.Status(http.StatusNoContent) + return + } common.SysLog(fmt.Sprintf("IP access routing rejected client_ip=%s country=%s rule_line=%d", originalIP, edgeCountry, lineNumber)) ipAccessRoutingError(c, http.StatusForbidden, "IP_ACCESS_ROUTE_REJECTED", "request rejected by IP access routing") return diff --git a/apps/api-go/controller/ip_policy_lookup_bounds_test.go b/apps/api-go/controller/ip_policy_lookup_bounds_test.go new file mode 100644 index 000000000..991a96153 --- /dev/null +++ b/apps/api-go/controller/ip_policy_lookup_bounds_test.go @@ -0,0 +1,301 @@ +package controller + +import ( + "fmt" + "net/http" + "net/http/httptest" + "sync/atomic" + "testing" + "time" + + "github.com/LIghtJUNction/api.lmm.best/common" + "github.com/LIghtJUNction/api.lmm.best/model" + "github.com/LIghtJUNction/api.lmm.best/setting" + "github.com/alicebob/miniredis/v2" + "github.com/gin-gonic/gin" + "github.com/go-redis/redis/v8" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + "gorm.io/gorm" +) + +func newIPPolicyLookupTestRequest(path, peer, clientIP, country, authorization string) *gin.Context { + recorder := httptest.NewRecorder() + c, _ := gin.CreateTestContext(recorder) + c.Request = httptest.NewRequest(http.MethodGet, path, nil) + c.Request.RemoteAddr = peer + c.Request.Header.Set("X-Original-Client-IP", clientIP) + c.Request.Header.Set("X-LMM-Edge-Country", country) + c.Request.Header.Set("Authorization", authorization) + return c +} + +func setIPPolicyLookupTestRules(t *testing.T, rules string) { + t.Helper() + previous := setting.GetIPAccessRoutingRules() + require.NoError(t, setting.UpdateIPAccessRoutingRules(rules)) + t.Cleanup(func() { require.NoError(t, setting.UpdateIPAccessRoutingRules(previous)) }) +} + +func TestIPPolicySkipsUnnecessaryKeyLookups(t *testing.T) { + gin.SetMode(gin.TestMode) + setupKeyBypassIPPolicyTest(t) + setIPPolicyLookupTestRules(t, "dip(203.0.113.8) -> direct\ndip(geoip:cn) -> reject\nfallback: direct") + + queries := 0 + require.NoError(t, model.DB.Callback().Query().Before("gorm:query").Register("count_policy_queries", func(*gorm.DB) { queries++ })) + for _, path := range []string{"/internal/access-ip-policy", "/api/internal/access-ip-policy"} { + for _, test := range []struct { + name, peer, ip, country string + status int + }{ + {"ordered direct", "127.0.0.1:42000", "203.0.113.8", "CN", http.StatusNoContent}, + {"fallback direct", "[::1]:42000", "198.51.100.8", "US", http.StatusNoContent}, + {"untrusted peer", "198.51.100.8:42000", "203.0.113.8", "CN", http.StatusForbidden}, + {"invalid client IP", "127.0.0.1:42000", "invalid", "CN", http.StatusForbidden}, + {"invalid country", "127.0.0.1:42000", "198.51.100.8", "invalid", http.StatusForbidden}, + } { + t.Run(path+"/"+test.name, func(t *testing.T) { + before := queries + c := newIPPolicyLookupTestRequest(path, test.peer, test.ip, test.country, "Bearer sk-unknownfixturekey-group") + CheckIPAccessRoutingPolicy(c) + assert.Equal(t, test.status, c.Writer.Status()) + assert.Equal(t, before, queries, "direct, invalid-metadata and non-loopback requests must not query token storage") + }) + } + } +} + +func countIPPolicyTokenQueries(t *testing.T, beforeQuery func()) *atomic.Int64 { + t.Helper() + queries := &atomic.Int64{} + require.NoError(t, model.DB.Callback().Query().Before("gorm:query").Register("count_token_policy_queries", func(db *gorm.DB) { + if db.Statement.Table == "tokens" { + queries.Add(1) + if beforeQuery != nil { + beforeQuery() + } + } + })) + return queries +} + +func TestIPPolicyBoundsRotatingInvalidKeysAcrossAliases(t *testing.T) { + gin.SetMode(gin.TestMode) + setupKeyBypassIPPolicyTest(t) + setIPPolicyLookupTestRules(t, "fallback: reject") + queries := countIPPolicyTokenQueries(t, nil) + paths := []string{"/internal/access-ip-policy", "/api/internal/access-ip-policy"} + clientIPs := []string{"203.0.113.8", "::ffff:203.0.113.8"} + prefixes := []string{"", "Bearer ", "bearer sk-"} + for i := range ipPolicyBypassSourceFailures + 12 { + c := newIPPolicyLookupTestRequest(paths[i%len(paths)], "127.0.0.1:42000", clientIPs[i%len(clientIPs)], "CN", prefixes[i%len(prefixes)]+fmt.Sprintf("unknown%d-group", i)) + // These client-supplied forwarding headers must not partition the budget. + c.Request.Header.Set("X-Forwarded-For", fmt.Sprintf("198.51.100.%d", i+1)) + c.Request.Header.Set("X-Real-IP", fmt.Sprintf("192.0.2.%d", i+1)) + CheckIPAccessRoutingPolicy(c) + assert.Equal(t, http.StatusForbidden, c.Writer.Status()) + assert.Equal(t, accessPolicyDenied, c.Writer.Header().Get(accessPolicyResultHeader)) + } + assert.EqualValues(t, ipPolicyBypassSourceFailures, queries.Load()) + + c := newIPPolicyLookupTestRequest(paths[0], "127.0.0.1:42000", "203.0.113.9", "CN", "Bearer sk-anotherfixture") + CheckIPAccessRoutingPolicy(c) + assert.EqualValues(t, ipPolicyBypassSourceFailures+1, queries.Load(), "another source retains its own budget") + + setIPPolicyLookupTestRules(t, "fallback: direct") + c = newIPPolicyLookupTestRequest(paths[0], "127.0.0.1:42000", "203.0.113.8", "CN", "Bearer sk-anotherfixture") + CheckIPAccessRoutingPolicy(c) + assert.Equal(t, http.StatusNoContent, c.Writer.Status(), "exhaustion must not reject policy-allowed traffic") + assert.EqualValues(t, ipPolicyBypassSourceFailures+1, queries.Load()) +} + +func TestIPPolicyBoundsConcurrentInvalidKeyLookups(t *testing.T) { + gin.SetMode(gin.TestMode) + setupKeyBypassIPPolicyTest(t) + setIPPolicyLookupTestRules(t, "fallback: reject") + sqlDB, err := model.DB.DB() + require.NoError(t, err) + sqlDB.SetMaxOpenConns(1) + + release := make(chan struct{}) + queries := countIPPolicyTokenQueries(t, func() { <-release }) + const requests = 48 + finished := make(chan int, requests) + for i := range requests { + go func() { + c := newIPPolicyLookupTestRequest("/internal/access-ip-policy", "127.0.0.1:42000", "203.0.113.8", "CN", fmt.Sprintf("Bearer sk-concurrent%d", i)) + CheckIPAccessRoutingPolicy(c) + finished <- c.Writer.Status() + }() + } + + // The admitted lookups remain blocked in the query callback; all other + // requests must finish without waiting for DB work or consuming new slots. + timer := time.NewTimer(5 * time.Second) + defer timer.Stop() + completed := 0 +waitForDenied: + for completed < requests-ipPolicyBypassSourceFailures { + select { + case status := <-finished: + assert.Equal(t, http.StatusForbidden, status) + completed++ + case <-timer.C: + t.Error("concurrent misses exceeded the lookup budget") + break waitForDenied + } + } + assert.LessOrEqual(t, queries.Load(), int64(ipPolicyBypassSourceFailures)) + close(release) + for completed < requests { + assert.Equal(t, http.StatusForbidden, <-finished) + completed++ + } + assert.EqualValues(t, ipPolicyBypassSourceFailures, queries.Load()) +} + +func TestIPPolicyBoundsDistinctSourceLookups(t *testing.T) { + gin.SetMode(gin.TestMode) + setupKeyBypassIPPolicyTest(t) + setIPPolicyLookupTestRules(t, "fallback: reject") + queries := countIPPolicyTokenQueries(t, nil) + for i := range ipPolicyBypassGlobalFailures + 32 { + c := newIPPolicyLookupTestRequest("/internal/access-ip-policy", "127.0.0.1:42000", fmt.Sprintf("2001:db8::%x", i+1), "CN", fmt.Sprintf("Bearer sk-distinct%d", i)) + assert.False(t, keyBypassesIPPolicy(c)) + } + assert.EqualValues(t, ipPolicyBypassGlobalFailures, queries.Load()) +} + +func TestIPPolicySuccessfulBypassIsFreshAndDoesNotConsumeFailureBudget(t *testing.T) { + gin.SetMode(gin.TestMode) + setupKeyBypassIPPolicyTest(t) + setIPPolicyLookupTestRules(t, "fallback: reject") + user := createBypassTestUser(t, 1, true) + createBypassTestToken(t, user.Id, "freshbypassfixture") + queries := countIPPolicyTokenQueries(t, nil) + for i := range ipPolicyBypassGlobalFailures + 4 { + path := "/internal/access-ip-policy" + if i%2 == 0 { + path = "/api/internal/access-ip-policy" + } + c := newIPPolicyLookupTestRequest(path, "127.0.0.1:42000", "203.0.113.8", "CN", "bearer sk-freshbypassfixture-mygroup") + CheckIPAccessRoutingPolicy(c) + assert.Equal(t, http.StatusNoContent, c.Writer.Status()) + assert.Empty(t, c.Writer.Header().Get(accessPolicyResultHeader)) + } + assert.EqualValues(t, ipPolicyBypassGlobalFailures+4, queries.Load(), "a successful bypass must not cache the credential or decision") + + require.NoError(t, model.DB.Model(&model.User{}).Where("id = ?", user.Id).Update("setting", `{"allow_key_bypass_ip_policy":false}`).Error) + c := newIPPolicyLookupTestRequest("/internal/access-ip-policy", "127.0.0.1:42000", "203.0.113.8", "CN", "Bearer sk-freshbypassfixture") + CheckIPAccessRoutingPolicy(c) + assert.Equal(t, http.StatusForbidden, c.Writer.Status(), "revoking opt-in takes effect on the next lookup") +} + +func TestIPPolicyBypassPreservesTokenValidityAndQuota(t *testing.T) { + gin.SetMode(gin.TestMode) + setupKeyBypassIPPolicyTest(t) + setIPPolicyLookupTestRules(t, "fallback: reject") + user := createBypassTestUser(t, 1, true) + for i, test := range []struct { + name string + update map[string]any + status int + }{ + {"valid finite quota", map[string]any{"unlimited_quota": false, "remain_quota": 10}, http.StatusNoContent}, + {"disabled token", map[string]any{"status": common.TokenStatusDisabled}, http.StatusForbidden}, + {"expired token", map[string]any{"expired_time": common.GetTimestamp() - 1}, http.StatusForbidden}, + {"exhausted quota", map[string]any{"unlimited_quota": false, "remain_quota": 0}, http.StatusForbidden}, + {"oauth managed token", map[string]any{"oauth_managed": true}, http.StatusForbidden}, + {"assistant runtime token", map[string]any{"creation_source": model.TokenCreationSourceAssistantRuntime}, http.StatusForbidden}, + } { + t.Run(test.name, func(t *testing.T) { + key := fmt.Sprintf("validityfixture%d", i) + createBypassTestToken(t, user.Id, key) + require.NoError(t, model.DB.Model(&model.Token{}).Where("key = ?", key).Updates(test.update).Error) + c := newIPPolicyLookupTestRequest("/internal/access-ip-policy", "127.0.0.1:42000", "203.0.113.8", "CN", "Bearer sk-"+key+"-mygroup") + CheckIPAccessRoutingPolicy(c) + assert.Equal(t, test.status, c.Writer.Status()) + }) + } +} + +func TestIPPolicyExhaustedSourceDoesNotSpendGlobalBudget(t *testing.T) { + gin.SetMode(gin.TestMode) + setupKeyBypassIPPolicyTest(t) + queries := countIPPolicyTokenQueries(t, nil) + for i := range ipPolicyBypassGlobalFailures + 4 { + c := newIPPolicyLookupTestRequest("/internal/access-ip-policy", "127.0.0.1:42000", "203.0.113.8", "CN", fmt.Sprintf("Bearer sk-spendfixture%d", i)) + assert.False(t, keyBypassesIPPolicy(c)) + } + assert.EqualValues(t, ipPolicyBypassSourceFailures, queries.Load()) + c := newIPPolicyLookupTestRequest("/internal/access-ip-policy", "127.0.0.1:42000", "203.0.113.9", "CN", "Bearer sk-freshsourcefixture") + assert.False(t, keyBypassesIPPolicy(c)) + assert.EqualValues(t, ipPolicyBypassSourceFailures+1, queries.Load(), "denied admission must release its global reservation") +} + +func TestIPPolicyLookupErrorsConsumeFailureBudget(t *testing.T) { + gin.SetMode(gin.TestMode) + setupKeyBypassIPPolicyTest(t) + queries := countIPPolicyTokenQueries(t, nil) + require.NoError(t, model.DB.Callback().Query().Before("gorm:query").Register("policy_database_error", func(db *gorm.DB) { + db.AddError(fmt.Errorf("local fixture database unavailable")) + })) + for i := range ipPolicyBypassSourceFailures + 4 { + c := newIPPolicyLookupTestRequest("/internal/access-ip-policy", "127.0.0.1:42000", "203.0.113.8", "CN", fmt.Sprintf("Bearer sk-errorfixture%d", i)) + assert.False(t, keyBypassesIPPolicy(c)) + } + assert.EqualValues(t, ipPolicyBypassSourceFailures, queries.Load()) +} + +func TestIPPolicyBoundsRedisMissesBeforeDatabaseFallback(t *testing.T) { + gin.SetMode(gin.TestMode) + setupKeyBypassIPPolicyTest(t) + cache := miniredis.RunT(t) + client := redis.NewClient(&redis.Options{Addr: cache.Addr()}) + previousClient := common.RDB + common.RDB = client + common.RedisEnabled = true + t.Cleanup(func() { + common.RDB = previousClient + _ = client.Close() + }) + queries := countIPPolicyTokenQueries(t, nil) + for i := range ipPolicyBypassSourceFailures + 4 { + c := newIPPolicyLookupTestRequest("/internal/access-ip-policy", "127.0.0.1:42000", "203.0.113.8", "CN", fmt.Sprintf("Bearer sk-redisfixture%d", i)) + assert.False(t, keyBypassesIPPolicy(c)) + } + assert.EqualValues(t, ipPolicyBypassSourceFailures, queries.Load()) + assert.Empty(t, cache.Keys(), "failed credentials are not retained in Redis") +} + +func TestIPPolicyUnavailableGeoIPPreservesBoundedKeyBypass(t *testing.T) { + gin.SetMode(gin.TestMode) + setupKeyBypassIPPolicyTest(t) + setIPPolicyLookupTestRules(t, setting.DefaultIPAccessRoutingRules) + user := createBypassTestUser(t, 1, true) + createBypassTestToken(t, user.Id, "unavailablegeoipfixture") + queries := countIPPolicyTokenQueries(t, nil) + for _, path := range []string{"/internal/access-ip-policy", "/api/internal/access-ip-policy"} { + c := newIPPolicyLookupTestRequest(path, "127.0.0.1:42000", "203.0.113.8", "", "Bearer sk-unavailablegeoipfixture-group") + CheckIPAccessRoutingPolicy(c) + assert.Equal(t, http.StatusNoContent, c.Writer.Status()) + assert.Empty(t, c.Writer.Header().Get(accessPolicyResultHeader)) + } + for i := range ipPolicyBypassSourceFailures + 4 { + c := newIPPolicyLookupTestRequest("/internal/access-ip-policy", "127.0.0.1:42000", "203.0.113.8", "", fmt.Sprintf("Bearer sk-unavailablegeoipunknown%d", i)) + CheckIPAccessRoutingPolicy(c) + assert.Equal(t, http.StatusForbidden, c.Writer.Status()) + assert.Equal(t, accessPolicyDenied, c.Writer.Header().Get(accessPolicyResultHeader)) + } + assert.EqualValues(t, 2+ipPolicyBypassSourceFailures, queries.Load(), "unavailable GeoIP must not restore unbounded lookups") + + for _, metadata := range []struct{ ip, country string }{ + {"", ""}, {"invalid", ""}, {"203.0.113.9", "invalid"}, + } { + c := newIPPolicyLookupTestRequest("/internal/access-ip-policy", "127.0.0.1:42000", metadata.ip, metadata.country, "Bearer sk-unavailablegeoipfixture") + CheckIPAccessRoutingPolicy(c) + assert.Equal(t, http.StatusForbidden, c.Writer.Status()) + } + assert.EqualValues(t, 2+ipPolicyBypassSourceFailures, queries.Load(), "invalid trusted metadata still fails closed before lookup") +} diff --git a/apps/api-go/controller/key_bypass_ip_policy_test.go b/apps/api-go/controller/key_bypass_ip_policy_test.go index a65ab1e76..3abc4ab94 100644 --- a/apps/api-go/controller/key_bypass_ip_policy_test.go +++ b/apps/api-go/controller/key_bypass_ip_policy_test.go @@ -68,6 +68,8 @@ func setupKeyBypassIPPolicyTest(t *testing.T) { t.Helper() previousDB := model.DB previousRedis := common.RedisEnabled + previousLimiter := ipPolicyBypassLimiter + ipPolicyBypassLimiter = &common.InMemoryRateLimiter{} db, err := gorm.Open(sqlite.Open(":memory:"), &gorm.Config{}) require.NoError(t, err) require.NoError(t, db.AutoMigrate(&model.User{}, &model.Token{})) @@ -76,6 +78,7 @@ func setupKeyBypassIPPolicyTest(t *testing.T) { t.Cleanup(func() { model.DB = previousDB common.RedisEnabled = previousRedis + ipPolicyBypassLimiter = previousLimiter }) } @@ -190,7 +193,7 @@ func TestCheckIPAccessRoutingPolicyKeyBypass(t *testing.T) { assert.Equal(t, http.StatusForbidden, c.Writer.Status()) }) - t.Run("L1+ user with bypass enabled and valid key skips policy evaluation", func(t *testing.T) { + t.Run("L1+ user with bypass enabled and valid key overrides rejection", func(t *testing.T) { user := createBypassTestUser(t, 1, true) createBypassTestToken(t, user.Id, "l1enabledkey") diff --git a/apps/api-go/controller/oauth_server.go b/apps/api-go/controller/oauth_server.go index 15f8c3f7f..73b701165 100644 --- a/apps/api-go/controller/oauth_server.go +++ b/apps/api-go/controller/oauth_server.go @@ -312,6 +312,21 @@ func (h *OAuthHTTP) failed(c *gin.Context, language, clientName string) { h.render(c, 400, oauthPageData{Language: language, Mode: "failed", ClientName: clientName}) } +func (h *OAuthHTTP) authorizationFailed(c *gin.Context, language, clientName string, err error) { + status := http.StatusBadRequest + data := oauthPageData{Language: language, Mode: "failed", ClientName: clientName} + var protocol *oauthserver.ProtocolError + if errors.As(err, &protocol) { + if protocol.Code == "invalid_client" { + data.Failure = protocol.Code + } + if protocol.Status == http.StatusServiceUnavailable { + status = http.StatusServiceUnavailable + } + } + h.render(c, status, data) +} + func (h *OAuthHTTP) showPreflight(c *gin.Context, raw, language string) { normalized, normalizeErr := h.Integration.MCPAuthorizationQuery(c.Request.Context(), raw) if normalizeErr != nil { @@ -331,12 +346,7 @@ func (h *OAuthHTTP) showPreflight(c *gin.Context, raw, language string) { } pending, err := h.Integration.Core.BeginAuthorization(c.Request.Context(), raw, binding) if err != nil { - data := oauthPageData{Language: language, Mode: "failed", ClientName: oauthRequestClientName(raw)} - var protocol *oauthserver.ProtocolError - if errors.As(err, &protocol) && protocol.Code == "invalid_client" { - data.Failure = protocol.Code - } - h.render(c, 400, data) + h.authorizationFailed(c, language, oauthRequestClientName(raw), err) return } if err := h.Integration.Core.SetBrowserCSRF(c.Request.Context(), pending.Transaction, binding, csrf); err != nil { @@ -384,7 +394,7 @@ func (h *OAuthHTTP) Continue(c *gin.Context) { } pending, err := h.Integration.Core.BeginAuthorization(c.Request.Context(), query, binding) if err != nil { - h.failed(c, flow.Language, flow.ClientName) + h.authorizationFailed(c, flow.Language, flow.ClientName, err) return } consent, err := h.Integration.Core.TrustedPrepareConsent(c.Request.Context(), pending.Transaction, binding, identity.UserID) diff --git a/apps/api-go/controller/relay_ali_accepted_task_test.go b/apps/api-go/controller/relay_ali_accepted_task_test.go new file mode 100644 index 000000000..eea0fa25a --- /dev/null +++ b/apps/api-go/controller/relay_ali_accepted_task_test.go @@ -0,0 +1,131 @@ +package controller + +import ( + "errors" + "io" + "net/http" + "strings" + "testing" + "testing/synctest" + "time" + + "github.com/LIghtJUNction/api.lmm.best/common" + "github.com/LIghtJUNction/api.lmm.best/constant" + "github.com/LIghtJUNction/api.lmm.best/model" + "github.com/LIghtJUNction/api.lmm.best/relaykit/dto" + "github.com/LIghtJUNction/api.lmm.best/service" + "github.com/stretchr/testify/require" +) + +type aliAcceptedTaskTransport func(*http.Request) (*http.Response, error) + +func (f aliAcceptedTaskTransport) RoundTrip(r *http.Request) (*http.Response, error) { return f(r) } +func aliAcceptedTaskResponse(status int, body string) *http.Response { + return &http.Response{StatusCode: status, Header: make(http.Header), Body: io.NopCloser(strings.NewReader(body))} +} +func newAliAcceptedTaskFixture(t *testing.T, transport aliAcceptedTaskTransport) *drawingParityFixture { + t.Helper() + fixture := newDrawingParityFixtureWithProviderURL(t, common.GetTrustQuota(), http.StatusOK, "https://provider.invalid") + fixture.channel.Type = constant.ChannelTypeAli + // The transport handles every request; no provider or image URL is fetched. + fixture.channel.StatusCodeMapping = common.GetPointer(`{"500":"502"}`) + require.NoError(t, fixture.db.Save(&fixture.channel).Error) + client, err := service.GetHttpClientWithProxySettings("", dto.ChannelSettings{}) + require.NoError(t, err) + previousTransport, previousTimeout := client.Transport, client.Timeout + previousRetries := common.RetryTimes + client.Transport, client.Timeout = transport, 0 + common.RetryTimes = 2 + t.Cleanup(func() { + client.Transport, client.Timeout = previousTransport, previousTimeout + common.RetryTimes = previousRetries + }) + return fixture +} + +func TestAliAcceptedTaskStopsControllerSubmissionRetry(t *testing.T) { + for _, tc := range []struct { + name string + initial string + poll string + pollError bool + wantPolls int + wantTime time.Duration + wantStatus int + }{ + {"poll_exhaustion_with_status_mapping", `{"output":{"task_id":"fixture-task"}}`, "", true, 20, 195 * time.Second, http.StatusBadGateway}, + // A provider channel-prefixed error code must not override accepted work. + {"terminal_channel_code", `{"output":{"task_id":"fixture-task"}}`, `{"output":{"task_status":"FAILED","code":"channel:fixture","message":"fixture failure"}}`, false, 1, 5 * time.Second, http.StatusOK}, + {"accepted_id_with_message", `{"output":{"task_id":"fixture-task"},"message":"fixture message"}`, "", false, 0, 0, http.StatusBadGateway}, + } { + t.Run(tc.name, func(t *testing.T) { + synctest.Test(t, func(t *testing.T) { + posts, polls := 0, 0 + fixture := newAliAcceptedTaskFixture(t, func(r *http.Request) (*http.Response, error) { + switch r.Method { + case http.MethodPost: + require.Equal(t, "/api/v1/services/aigc/text2image/image-synthesis", r.URL.Path) + posts++ + return aliAcceptedTaskResponse(http.StatusOK, tc.initial), nil + case http.MethodGet: + require.Equal(t, "/api/v1/tasks/fixture-task", r.URL.Path) + polls++ + if tc.pollError { + return nil, errors.New("fixture poll transport failure") + } + return aliAcceptedTaskResponse(http.StatusOK, tc.poll), nil + default: + t.Fatalf("unexpected method %s", r.Method) + return nil, errors.New("unexpected fixture request") + } + }) + started := time.Now() + status, body := fixture.request(t, "api") + require.Equal(t, tc.wantStatus, status, body) + require.Equal(t, 1, posts, "recognized accepted work must never be submitted again") + require.Equal(t, tc.wantPolls, polls) + require.Equal(t, tc.wantTime, time.Since(started)) + // This patch changes retries only; existing failed-request refunds remain. + require.Eventually(t, func() bool { + var user model.User + var token model.Token + return fixture.db.First(&user, fixture.user.Id).Error == nil && + fixture.db.First(&token, fixture.token.Id).Error == nil && + user.Quota == fixture.user.Quota && token.RemainQuota == fixture.token.RemainQuota + }, 3*time.Second, time.Millisecond) + }) + }) + } +} + +func TestAliPreAcceptanceFailureStillRetriesControllerSubmission(t *testing.T) { + synctest.Test(t, func(t *testing.T) { + posts, polls := 0, 0 + fixture := newAliAcceptedTaskFixture(t, func(r *http.Request) (*http.Response, error) { + if r.Method == http.MethodPost { + posts++ + if posts == 1 { + return aliAcceptedTaskResponse(http.StatusOK, `{"code":"TransientFailure","message":"fixture rejection"}`), nil + } + return aliAcceptedTaskResponse(http.StatusOK, `{"output":{"task_id":"fixture-task"}}`), nil + } + require.Equal(t, http.MethodGet, r.Method) + polls++ + return aliAcceptedTaskResponse(http.StatusOK, `{"output":{"task_status":"SUCCEEDED","results":[{"url":"https://example.invalid/one.png"},{"url":"https://example.invalid/two.png"}]},"usage":{"image_count":2}}`), nil + }) + status, body := fixture.request(t, "api") + require.Equal(t, http.StatusOK, status, body) + require.Contains(t, body, "https://example.invalid/one.png") + require.Equal(t, 2, posts, "pre-acceptance rejection must remain retryable") + require.Equal(t, 1, polls) + var user model.User + var token model.Token + require.NoError(t, fixture.db.First(&user, fixture.user.Id).Error) + require.NoError(t, fixture.db.First(&token, fixture.token.Id).Error) + charge := fixture.user.Quota - user.Quota + require.Positive(t, charge, "successful accepted work must still be charged") + require.Equal(t, charge, fixture.token.RemainQuota-token.RemainQuota) + require.Equal(t, charge, user.UsedQuota) + require.Equal(t, charge, token.UsedQuota) + }) +} diff --git a/apps/api-go/controller/signal_game.go b/apps/api-go/controller/signal_game.go index d7e6f7848..a5bbe1bda 100644 --- a/apps/api-go/controller/signal_game.go +++ b/apps/api-go/controller/signal_game.go @@ -81,6 +81,10 @@ func FinishSignalGameAttempt(c *gin.Context) { signalError(c, 404, "Challenge not found") return } + if err := row.CheckFinishTime(time.Now().UnixMilli()); err != nil { + signalError(c, 409, "Challenge is expired, changed, or still counting down") + return + } if _, err = signalgames.Replay(row.Seed, row.Size, input.Actions, false); err != nil { signalError(c, 400, "Challenge replay rejected") return diff --git a/apps/api-go/controller/signal_game_test.go b/apps/api-go/controller/signal_game_test.go index 7db006181..71d23a1e4 100644 --- a/apps/api-go/controller/signal_game_test.go +++ b/apps/api-go/controller/signal_game_test.go @@ -64,6 +64,9 @@ func TestSignalGameGuestCompletionThenAuthenticatedClaim(t *testing.T) { require.NoError(t, db.Model(&model.SignalGameAttempt{}).Where("token_hash = ?", signalHash(token)).Update("started_at", time.Now().UnixMilli()-500).Error) require.Equal(t, 400, call("POST", "/finish", map[string]any{"token": token, "actions": []int{-1}}, false).Code) require.Equal(t, 200, call("POST", "/finish", map[string]any{"token": token, "actions": actions}, false).Code) + // Completed results stay idempotent even after the unfinished-attempt TTL. + require.NoError(t, db.Model(&model.SignalGameAttempt{}).Where("token_hash = ?", signalHash(token)).Update("started_at", time.Now().Add(-48*time.Hour).UnixMilli()).Error) + require.Equal(t, 200, call("POST", "/finish", map[string]any{"token": token, "actions": actions}, false).Code) submit := map[string]any{"mode": "challenge", "rules_version": 2, "token": token, "publish": true, "email": "private@example.test", "note": "Testing", "user_id": 999, "moves": 0, "elapsed_ms": 0, "model_id": "forged-model"} require.Equal(t, 401, call("POST", "/records", submit, false).Code) submit["expected_user_id"] = 999 @@ -88,3 +91,34 @@ func TestSignalGameGuestCompletionThenAuthenticatedClaim(t *testing.T) { require.False(t, strings.Contains(ranking.Body.String(), token)) require.NotContains(t, ranking.Body.String(), "private@example.test") } + +func TestSignalGameUnavailableAttemptRejectsBeforeReplay(t *testing.T) { + db := setupManageUserTestDB(t) + require.NoError(t, db.AutoMigrate(&model.SignalGameAttempt{})) + router := gin.New() + router.POST("/finish", FinishSignalGameAttempt) + for _, tc := range []struct { + name string + started int64 + }{ + {"countdown", time.Now().Add(time.Minute).UnixMilli()}, + {"expired", time.Now().Add(-25 * time.Hour).UnixMilli()}, + } { + t.Run(tc.name, func(t *testing.T) { + token := tc.name + strings.Repeat("a", 43-len(tc.name)) + row := model.SignalGameAttempt{TokenHash: signalHash(token), Seed: 42, Size: 64, StartedAt: tc.started} + require.NoError(t, db.Create(&row).Error) + // Replay would reject this forbidden hint with 400. A lifecycle 409 + // establishes that replay was not reached for an unavailable attempt. + raw, err := json.Marshal(map[string]any{"token": token, "actions": []int{-1}}) + require.NoError(t, err) + request := httptest.NewRequest("POST", "/finish", bytes.NewReader(raw)) + request.Header.Set("Content-Type", "application/json") + response := httptest.NewRecorder() + router.ServeHTTP(response, request) + require.Equal(t, 409, response.Code) + require.NoError(t, db.First(&row, row.Id).Error) + require.Zero(t, row.FinishedAt) + }) + } +} diff --git a/apps/api-go/middleware/auth.go b/apps/api-go/middleware/auth.go index 45c48397d..91796dc51 100644 --- a/apps/api-go/middleware/auth.go +++ b/apps/api-go/middleware/auth.go @@ -593,9 +593,7 @@ func TokenAuthReadOnly() func(c *gin.Context) { c.Abort() return } - if strings.HasPrefix(key, "Bearer ") || strings.HasPrefix(key, "bearer ") { - key = strings.TrimSpace(key[7:]) - } + key = stripRelayBearerScheme(key) key = strings.TrimPrefix(key, "sk-") parts := strings.Split(key, "-") key = parts[0] @@ -783,21 +781,25 @@ func prepareRelayTokenCredential(c *gin.Context) { } func relayTokenCredential(c *gin.Context) (string, []string) { - key := c.Request.Header.Get("Authorization") - if strings.HasPrefix(key, "Bearer ") || strings.HasPrefix(key, "bearer ") { - key = strings.TrimSpace(key[7:]) - } + key := stripRelayBearerScheme(c.Request.Header.Get("Authorization")) if key == "" || key == "midjourney-proxy" { - key = c.Request.Header.Get("mj-api-secret") - if strings.HasPrefix(key, "Bearer ") || strings.HasPrefix(key, "bearer ") { - key = strings.TrimSpace(key[7:]) - } + key = stripRelayBearerScheme(c.Request.Header.Get("mj-api-secret")) } key = strings.TrimPrefix(key, "sk-") parts := strings.Split(key, "-") return parts[0], parts } +// Authentication scheme names are case-insensitive. Keep legacy raw keys and +// their whitespace unchanged when there is no space-delimited Bearer scheme. +func stripRelayBearerScheme(key string) string { + const prefix = "Bearer " + if len(key) >= len(prefix) && strings.EqualFold(key[:len(prefix)], prefix) { + return strings.TrimSpace(key[len(prefix):]) + } + return key +} + func writeRelayTokenAuthFailure(c *gin.Context, failure *relayTokenAuthFailure) { if failure.conceal { abortRelayAsNotFound(c) diff --git a/apps/api-go/middleware/auth_bearer_test.go b/apps/api-go/middleware/auth_bearer_test.go new file mode 100644 index 000000000..132406804 --- /dev/null +++ b/apps/api-go/middleware/auth_bearer_test.go @@ -0,0 +1,82 @@ +package middleware + +import ( + "net/http" + "net/http/httptest" + "testing" + + "github.com/LIghtJUNction/api.lmm.best/common" + "github.com/LIghtJUNction/api.lmm.best/model" + "github.com/gin-gonic/gin" + "github.com/stretchr/testify/require" +) + +func TestRelayBearerSchemePreservesCredentialSemantics(t *testing.T) { + tests := []struct { + name, header, fallback, wantKey string + wantParts []string + }{ + {"canonical", "Bearer sk-AbC123-42", "", "AbC123", []string{"AbC123", "42"}}, + {"lowercase", "bearer sk-AbC123-42", "", "AbC123", []string{"AbC123", "42"}}, + {"uppercase", "BEARER sk-AbC123-42", "", "AbC123", []string{"AbC123", "42"}}, + {"mixed-case", "bEaReR sk-AbC123-42", "", "AbC123", []string{"AbC123", "42"}}, + {"bearer-whitespace", "bEaReR AbC123 \t", "", "AbC123", []string{"AbC123"}}, + {"raw-key", "AbC123", "", "AbC123", []string{"AbC123"}}, + {"raw-prefixed-key", "sk-AbC123-42", "", "AbC123", []string{"AbC123", "42"}}, + {"raw-whitespace-preserved", " AbC123 ", "", " AbC123 ", []string{" AbC123 "}}, + {"other-scheme-unchanged", "Basic AbC123", "", "Basic AbC123", []string{"Basic AbC123"}}, + {"tab-delimiter-unchanged", "Bearer\tAbC123", "", "Bearer\tAbC123", []string{"Bearer\tAbC123"}}, + {"no-delimiter-unchanged", "BearerAbC123", "", "BearerAbC123", []string{"BearerAbC123"}}, + {"fallback-mixed-case", "", "bEaReR sk-AbC123-42", "AbC123", []string{"AbC123", "42"}}, + {"sentinel-fallback", "midjourney-proxy", "bEaReR AbC123", "AbC123", []string{"AbC123"}}, + {"header-precedence", "bEaReR AbC123", "Bearer Other", "AbC123", []string{"AbC123"}}, + } + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + c, _ := gin.CreateTestContext(httptest.NewRecorder()) + c.Request = httptest.NewRequest(http.MethodGet, "/v1/models", nil) + c.Request.Header.Set("Authorization", tc.header) + c.Request.Header.Set("mj-api-secret", tc.fallback) + key, parts := relayTokenCredential(c) + require.Equal(t, tc.wantKey, key) + require.Equal(t, tc.wantParts, parts) + require.Equal(t, tc.header, c.GetHeader("Authorization"), "parsing must not rewrite the credential") + }) + } +} + +func TestTokenAuthReadOnlyBearerSchemeAndDenials(t *testing.T) { + setupDashboardAuthMiddlewareTest(t) + sqlDB, err := model.DB.DB() + require.NoError(t, err) + t.Cleanup(func() { require.NoError(t, sqlDB.Close()) }) + require.NoError(t, model.DB.AutoMigrate(&model.Token{})) + user := createMiddlewarePATUser(t, "readonly-bearer", "readonly-dashboard-pat") + token := model.Token{UserId: user.Id, Key: "ReadOnlyCaseKey", Status: common.TokenStatusEnabled, ExpiredTime: -1} + require.NoError(t, model.DB.Create(&token).Error) + engine := gin.New() + engine.GET("/read-only", TokenAuthReadOnly(), func(c *gin.Context) { + require.Equal(t, user.Id, c.GetInt("id")) + require.Equal(t, token.Id, c.GetInt("token_id")) + c.Status(http.StatusNoContent) + }) + request := func(header string) *httptest.ResponseRecorder { + req := httptest.NewRequest(http.MethodGet, "/read-only", nil) + req.Header.Set("Authorization", header) + response := httptest.NewRecorder() + engine.ServeHTTP(response, req) + return response + } + for _, prefix := range []string{"Bearer ", "bearer ", "BEARER ", "bEaReR ", ""} { + t.Run(prefix, func(t *testing.T) { + require.Equal(t, http.StatusNoContent, request(prefix+token.Key).Code) + }) + } + require.Equal(t, http.StatusUnauthorized, request("bEaReR readonlycasekey").Code, "key bytes remain case-sensitive") + require.Equal(t, http.StatusUnauthorized, request("bEaReR unknownkey").Code) + require.NoError(t, model.DB.Model(&model.Token{}).Where("id = ?", token.Id).Update("status", common.TokenStatusDisabled).Error) + require.Equal(t, http.StatusUnauthorized, request("bEaReR "+token.Key).Code) + require.NoError(t, model.DB.Model(&model.Token{}).Where("id = ?", token.Id).Update("status", common.TokenStatusEnabled).Error) + require.NoError(t, model.DB.Model(&model.User{}).Where("id = ?", user.Id).Update("status", common.UserStatusDisabled).Error) + require.Equal(t, http.StatusForbidden, request("bEaReR "+token.Key).Code) +} diff --git a/apps/api-go/middleware/distributor.go b/apps/api-go/middleware/distributor.go index c5ad5bc16..0f4226012 100644 --- a/apps/api-go/middleware/distributor.go +++ b/apps/api-go/middleware/distributor.go @@ -9,6 +9,7 @@ import ( "strconv" "strings" "time" + "unsafe" "github.com/LIghtJUNction/api.lmm.best/common" "github.com/LIghtJUNction/api.lmm.best/constant" @@ -264,12 +265,27 @@ func getModelFromJSONBody(c *gin.Context) (*ModelRequest, error) { return nil, errors.New("invalid JSON request body") } - modelPath := "model" + modelField := "model" if c.Request.URL.Path == "/v1/live/sessions" { - modelPath = "session.model" + modelField = "session" } - values := gjson.GetManyBytes(requestBody, modelPath, "group") - model, err := getJSONStringValue(values[0], modelPath) + // The stored bytes are immutable throughout this local scan. Avoid another + // full-body allocation (including for disk-backed requests); no JSON view + // escapes, and getJSONStringValue decodes owned strings before returning. + rawJSON := unsafe.String(unsafe.SliceData(requestBody), len(requestBody)) + values, err := getUniqueJSONRoutingFields(gjson.Parse(rawJSON), modelField, "group") + if err != nil { + return nil, err + } + modelValue := values[0] + if modelField == "session" && modelValue.Exists() && modelValue.Type != gjson.Null { + sessionValues, err := getUniqueJSONRoutingFields(modelValue, "model") + if err != nil { + return nil, err + } + modelValue = sessionValues[0] + } + model, err := getJSONStringValue(modelValue, "model") if err != nil { return nil, err } @@ -289,6 +305,36 @@ func getModelFromJSONBody(c *gin.Context) (*ModelRequest, error) { }, nil } +// Inspect only the routing envelope, leaving provider payloads and their number +// precision untouched. gjson selects the first matching member, whereas the +// reusable JSON DTO decoder accepts the last member and case-folded aliases. +// Reject those ambiguous envelopes before authorization or channel selection. +func getUniqueJSONRoutingFields(object gjson.Result, fields ...string) ([]gjson.Result, error) { + if !object.IsObject() { + return nil, errors.New("expected JSON object") + } + values := make([]gjson.Result, len(fields)) + seen := make([]bool, len(fields)) + var fieldErr error + object.ForEach(func(key, value gjson.Result) bool { + name := key.String() // Decode escaped names before detecting aliases. + for i, field := range fields { + if !strings.EqualFold(name, field) { + continue + } + if name != field || seen[i] { + fieldErr = fmt.Errorf("ambiguous routing field %s", field) + return false + } + seen[i] = true + values[i] = value + break + } + return true + }) + return values, fieldErr +} + func getJSONStringValue(result gjson.Result, field string) (string, error) { if !result.Exists() || result.Type == gjson.Null { return "", nil @@ -296,7 +342,13 @@ func getJSONStringValue(result gjson.Result, field string) (string, error) { if result.Type != gjson.String { return "", fmt.Errorf("field %s must be a string", field) } - return result.String(), nil + // Match the reusable DTO decoder's string handling, including malformed + // Unicode replacement, without decoding unknown provider fields. + var value string + if err := common.UnmarshalJsonStr(result.Raw, &value); err != nil { + return "", err + } + return value, nil } func getModelRequest(c *gin.Context) (*ModelRequest, bool, error) { @@ -440,7 +492,12 @@ func getModelRequest(c *gin.Context) (*ModelRequest, bool, error) { relayMode = relayconstant.RelayModeAudioTranslation } else if strings.HasPrefix(c.Request.URL.Path, "/v1/audio/transcriptions") { // 先尝试从请求读取 - if req, err := getModelFromRequest(c); err == nil && req.Model != "" { + req, err := getModelFromRequest(c) + if err != nil && strings.HasPrefix(c.Request.Header.Get("Content-Type"), "application/json") { + // JSON envelope errors must not fall back to a different model. + return nil, false, err + } + if err == nil && req.Model != "" { modelRequest.Model = req.Model } modelRequest.Model = common.GetStringIfEmpty(modelRequest.Model, "whisper-1") diff --git a/apps/api-go/middleware/distributor_json_routing_test.go b/apps/api-go/middleware/distributor_json_routing_test.go new file mode 100644 index 000000000..c2eef6fc1 --- /dev/null +++ b/apps/api-go/middleware/distributor_json_routing_test.go @@ -0,0 +1,175 @@ +package middleware + +import ( + "io" + "net/http" + "net/http/httptest" + "strings" + "testing" + + "github.com/LIghtJUNction/api.lmm.best/common" + "github.com/LIghtJUNction/api.lmm.best/constant" + "github.com/LIghtJUNction/api.lmm.best/i18n" + "github.com/LIghtJUNction/api.lmm.best/relaykit/dto" + "github.com/gin-gonic/gin" + "github.com/stretchr/testify/require" +) + +func routingJSONContext(t *testing.T, path, raw string) *gin.Context { + t.Helper() + require.NoError(t, i18n.Init()) + c, _ := gin.CreateTestContext(httptest.NewRecorder()) + c.Request = httptest.NewRequest(http.MethodPost, path, strings.NewReader(raw)) + c.Request.Header.Set("Content-Type", "application/json; charset=utf-8") + t.Cleanup(func() { common.CleanupBodyStorage(c) }) + return c +} + +func TestJSONRoutingRejectsAmbiguousEnvelope(t *testing.T) { + tests := []struct{ name, raw string }{ + {"duplicate-model", `{"model":"a","model":"b"}`}, + {"identical-model", `{"model":"a","model":"a"}`}, + {"null-first-model", `{"model":null,"model":"a"}`}, + {"null-last-model", `{"model":"a","model":null}`}, + {"escaped-model", `{"model":"a","mo\u0064el":"b"}`}, + {"model-case-alias", `{"model":"a","Model":"b"}`}, + {"single-model-case-alias", `{"MODEL":"a"}`}, + {"escaped-model-case-alias", `{"\u004dodel":"a"}`}, + {"duplicate-group", `{"model":"a","group":"one","group":"two"}`}, + {"identical-group", `{"model":"a","group":"one","group":"one"}`}, + {"null-group", `{"model":"a","group":null,"group":"one"}`}, + {"escaped-group", `{"model":"a","group":"one","gro\u0075p":"two"}`}, + {"single-group-case-alias", `{"model":"a","GROUP":"one"}`}, + {"non-string-model", `{"model":123}`}, + {"non-string-group", `{"model":"a","group":[]}`}, + {"root-array", `[{"model":"a"}]`}, + {"root-null", `null`}, + {"trailing-object", `{"model":"a"}{}`}, + } + for _, path := range []string{"/v1/chat/completions", "/pg/chat/completions", "/pg/images/generations", "/v1/audio/transcriptions"} { + t.Run(path, func(t *testing.T) { + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + _, _, err := getModelRequest(routingJSONContext(t, path, tc.raw)) + require.Error(t, err) + }) + } + }) + } +} + +func TestJSONRoutingPreservesBodyAndDecoderContinuity(t *testing.T) { + tests := []struct{ name, raw string }{ + {"ordinary", ` {"model":"a","group":"one"} `}, + {"escaped-fields", `{"mo\u0064el":"a","gro\u0075p":"one"}`}, + {"escaped-values", `{"model":"\u0061","group":"o\u006ee"}`}, + {"null-fields", `{"model":null,"group":null}`}, + {"missing-fields", `{}`}, + {"unknown-duplicates", `{"model":"a","group":"one","future":1,"future":2}`}, + {"nested-fields", `{"model":"a","group":"one","metadata":{"model":"b","Model":"c","group":"two"}}`}, + {"provider-numbers", `{"model":"a","group":"one","future":{"large":1e400,"exact":9007199254740993}}`}, + {"unicode", `{"model":"模型-\ud83d\ude00","group":"分组"}`}, + {"unpaired-surrogate", `{"model":"a\ud800","group":"one\udfff"}`}, + {"invalid-utf8", "{\"model\":\"a\xff\",\"group\":\"one\xfe\"}"}, + } + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + c := routingJSONContext(t, "/pg/chat/completions", tc.raw) + ingress, err := getModelFromRequest(c) + require.NoError(t, err) + body, err := io.ReadAll(c.Request.Body) + require.NoError(t, err) + require.Equal(t, tc.raw, string(body)) + var decoded dto.PlayGroundRequest + require.NoError(t, common.UnmarshalBodyReusable(c, &decoded)) + require.Equal(t, decoded.Model, ingress.Model) + require.Equal(t, decoded.Group, ingress.Group) + body, err = io.ReadAll(c.Request.Body) + require.NoError(t, err) + require.Equal(t, tc.raw, string(body)) + }) + } +} + +func TestJSONRoutingValidatesLiveSessionEnvelope(t *testing.T) { + for _, raw := range []string{ + `{"session":{"model":"live"},"session":{"model":"other"}}`, + `{"session":null,"session":{"model":"live"}}`, + `{"session":{"model":"live"},"se\u0073sion":{"model":"other"}}`, + `{"Session":{"model":"live"}}`, + `{"\u017fession":{"model":"live"}}`, + `{"session":[]}`, + `{"session":{"model":"live","model":"other"}}`, + `{"session":{"model":"live","Model":"other"}}`, + `{"session":{"model":"live","mo\u0064el":"other"}}`, + `{"session":{"MODEL":"live"}}`, + } { + _, _, err := getModelRequest(routingJSONContext(t, "/v1/live/sessions", raw)) + require.Error(t, err, raw) + } + for _, raw := range []string{ + `{"session":{"model":"live"}}`, + `{"model":"ignored","session":{"model":"live"}}`, + `{"se\u0073sion":{"mo\u0064el":"live"}}`, + } { + request, _, err := getModelRequest(routingJSONContext(t, "/v1/live/sessions", raw)) + require.NoError(t, err) + require.Equal(t, "live", request.Model) + } +} + +func TestJSONRoutingChecksDiskBackedBodies(t *testing.T) { + previous := common.GetDiskCacheConfig() + common.SetDiskCacheConfig(common.DiskCacheConfig{Enabled: true, ThresholdMB: 1, MaxSizeMB: 16, Path: t.TempDir()}) + t.Cleanup(func() { common.SetDiskCacheConfig(previous) }) + for _, suffix := range []string{"", `,"Model":"other"`} { + raw := `{"model":"a","group":"one","future":"` + strings.Repeat("x", (1<<20)+1) + `"` + suffix + `}` + c := routingJSONContext(t, "/pg/chat/completions", raw) + storage, err := common.GetBodyStorage(c) + require.NoError(t, err) + require.True(t, storage.IsDisk()) + ingress, err := getModelFromRequest(c) + if suffix != "" { + require.Error(t, err) + continue + } + require.NoError(t, err) + var decoded dto.PlayGroundRequest + require.NoError(t, common.UnmarshalBodyReusable(c, &decoded)) + require.Equal(t, decoded.Model, ingress.Model) + require.Equal(t, decoded.Group, ingress.Group) + body, err := io.ReadAll(c.Request.Body) + require.NoError(t, err) + require.Equal(t, raw, string(body)) + } +} + +func TestJSONRoutingReturnsOwnedStrings(t *testing.T) { + c := routingJSONContext(t, "/pg/chat/completions", `{"model":"owned-model","group":"owned-group"}`) + ingress, err := getModelFromRequest(c) + require.NoError(t, err) + storage, err := common.GetBodyStorage(c) + require.NoError(t, err) + require.False(t, storage.IsDisk()) + body, err := storage.Bytes() + require.NoError(t, err) + // Mutate only after parsing to ensure no read-only body view escaped into + // the returned authorization fields. + for i := range body { + body[i] = 'x' + } + require.Equal(t, "owned-model", ingress.Model) + require.Equal(t, "owned-group", ingress.Group) +} + +func TestJSONRoutingRejectsBeforeModelAuthorization(t *testing.T) { + for _, path := range []string{"/v1/chat/completions", "/v1/audio/transcriptions"} { + c := routingJSONContext(t, path, `{"model":"a","model":"b"}`) + // An empty model allowlist would return 403 if routing ambiguities were + // allowed to reach authorization. No database or upstream is involved. + common.SetContextKey(c, constant.ContextKeyTokenModelLimitEnabled, true) + Distribute()(c) + require.True(t, c.IsAborted()) + require.Equal(t, http.StatusBadRequest, c.Writer.Status()) + } +} diff --git a/apps/api-go/middleware/rt17_request_ambiguity_test.go b/apps/api-go/middleware/rt17_request_ambiguity_test.go index 0f3e82b43..ccd5bc8c2 100644 --- a/apps/api-go/middleware/rt17_request_ambiguity_test.go +++ b/apps/api-go/middleware/rt17_request_ambiguity_test.go @@ -7,6 +7,7 @@ import ( "testing" "github.com/LIghtJUNction/api.lmm.best/common" + "github.com/LIghtJUNction/api.lmm.best/i18n" "github.com/LIghtJUNction/api.lmm.best/relaykit/dto" "github.com/gin-gonic/gin" ) @@ -16,6 +17,9 @@ import ( // A rejection is allowed for ambiguous input. If accepted, the stages must // agree. Do not reverse this invariant to preserve a first-key/last-key split. func TestRT17ModelParserContinuity(t *testing.T) { + if err := i18n.Init(); err != nil { + t.Fatal(err) + } tests := []struct { name, fields string mustAccept bool @@ -77,6 +81,9 @@ func TestRT17ModelParserContinuity(t *testing.T) { } func TestRT17PlaygroundGroupParserContinuity(t *testing.T) { + if err := i18n.Init(); err != nil { + t.Fatal(err) + } tests := []struct { name, fields string mustAccept bool diff --git a/apps/api-go/model/discount_code.go b/apps/api-go/model/discount_code.go index 30c1ff511..9a1636ff6 100644 --- a/apps/api-go/model/discount_code.go +++ b/apps/api-go/model/discount_code.go @@ -197,10 +197,8 @@ func ValidateDiscountCodeForUserDecimal(value string, amount decimal.Decimal, no return nil, ErrDiscountCodeNotFound } if row.MaxUses > 0 { - var activeReservations int64 - if err := DB.Model(&DiscountCodeReservation{}). - Where("discount_code_id = ? AND status = ? AND expires_time > ?", row.Id, DiscountCodeReservationStatusReserved, now). - Count(&activeReservations).Error; err != nil { + activeReservations, err := countDiscountCodeCapacityHolds(DB, row.Id) + if err != nil { return nil, err } if row.UsedCount+activeReservations >= row.MaxUses { diff --git a/apps/api-go/model/discount_code_reservation.go b/apps/api-go/model/discount_code_reservation.go index 02adb9e65..049013b39 100644 --- a/apps/api-go/model/discount_code_reservation.go +++ b/apps/api-go/model/discount_code_reservation.go @@ -20,8 +20,9 @@ const ( ) // DiscountCodeReservation atomically prevents two unpaid orders from both -// claiming the last limited-use coupon slot. A later signed payment is always credited even -// when its reservation expired or was released; provider settlement must never +// claiming the last limited-use coupon slot. ExpiresTime is not permission to +// reuse a slot while its order can still settle. A later signed payment is always +// credited, including legacy released reservations; provider settlement must never // fail because coupon capacity changed after checkout. type DiscountCodeReservation struct { Id int `json:"id"` @@ -85,6 +86,52 @@ func validateDiscountCodeReservationTerms(code *DiscountCode, topUp *TopUp, now return nil } +// payableDiscountCodeTopUps mirrors CompleteExternalTopUp's unsettled states. +// A local Waffo checkout timeout is recoverable by a later signed payment, so +// neither that state nor the reservation TTL proves that a coupon slot is free. +func payableDiscountCodeTopUps(tx *gorm.DB) *gorm.DB { + return tx.Model(&TopUp{}).Select("trade_no"). + Where("status = ? OR (status = ? AND payment_provider = ? AND failure_reason_code = ?)", + common.TopUpStatusPending, common.TopUpStatusFailed, PaymentProviderWaffoPancake, string(PaymentOrderFailureCheckoutTimeout)) +} + +// closedDiscountCodeTopUps proves that an existing order cannot settle under +// the current lifecycle. Older callers persist terminal states with TopUp.Update +// without releasing the reservation, so both counting and release use this rule. +func closedDiscountCodeTopUps(tx *gorm.DB) *gorm.DB { + return tx.Model(&TopUp{}).Select("trade_no"). + Where("trade_no IS NOT NULL"). + Where("status = ? OR (status = ? AND (COALESCE(payment_provider, '') <> ? OR failure_reason_code <> ?))", + common.TopUpStatusExpired, common.TopUpStatusFailed, PaymentProviderWaffoPancake, string(PaymentOrderFailureCheckoutTimeout)) +} + +// countDiscountCodeCapacityHolds is shared by preview and atomic reservation. +// Reserved rows remain held unless an existing order is definitively closed; +// missing or unknown orders fail closed. Older released rows +// also retain capacity whenever their persisted order can still accept payment. +// Consumed rows are already represented by DiscountCode.UsedCount. Legacy +// payable orders without a reservation row are also outstanding liabilities. +func countDiscountCodeCapacityHolds(tx *gorm.DB, discountCodeID int) (int64, error) { + var count int64 + err := tx.Model(&DiscountCodeReservation{}). + Where("discount_code_id = ?", discountCodeID). + Where("(status = ? AND top_up_trade_no NOT IN (?)) OR (status = ? AND top_up_trade_no IN (?))", + DiscountCodeReservationStatusReserved, closedDiscountCodeTopUps(tx), + DiscountCodeReservationStatusReleased, payableDiscountCodeTopUps(tx)). + Count(&count).Error + if err != nil { + return 0, err + } + var unreservedOrders int64 + reservations := tx.Model(&DiscountCodeReservation{}).Select("1"). + Where("top_up_trade_no = top_ups.trade_no") + err = payableDiscountCodeTopUps(tx). + Where("discount_code_id = ?", discountCodeID). + Where("NOT EXISTS (?)", reservations). + Count(&unreservedOrders).Error + return count + unreservedOrders, err +} + func reserveDiscountCodeUsageTx(tx *gorm.DB, topUp *TopUp) error { if topUp == nil || topUp.DiscountCodeId <= 0 { return nil @@ -114,10 +161,8 @@ func reserveDiscountCodeUsageTx(tx *gorm.DB, topUp *TopUp) error { } if code.MaxUses > 0 { - var activeReservations int64 - if err := tx.Model(&DiscountCodeReservation{}). - Where("discount_code_id = ? AND status = ? AND expires_time > ?", code.Id, DiscountCodeReservationStatusReserved, now). - Count(&activeReservations).Error; err != nil { + activeReservations, err := countDiscountCodeCapacityHolds(tx, code.Id) + if err != nil { return err } if code.UsedCount+activeReservations >= code.MaxUses { @@ -191,8 +236,11 @@ func releaseDiscountCodeReservationTx(tx *gorm.DB, tradeNo string) error { if tradeNo == "" { return nil } + // Only existing failed/expired states that settlement rejects can release a + // hold. Keep pending, unknown, missing, and recoverable timeout orders held. + closedOrders := closedDiscountCodeTopUps(tx).Where("trade_no = ?", tradeNo) return tx.Model(&DiscountCodeReservation{}). - Where("top_up_trade_no = ? AND status = ?", tradeNo, DiscountCodeReservationStatusReserved). + Where("top_up_trade_no = ? AND status = ? AND top_up_trade_no IN (?)", tradeNo, DiscountCodeReservationStatusReserved, closedOrders). Updates(map[string]any{ "status": DiscountCodeReservationStatusReleased, "updated_time": common.GetTimestamp(), diff --git a/apps/api-go/model/discount_code_reservation_test.go b/apps/api-go/model/discount_code_reservation_test.go index 34d987c4f..3a6d92e1e 100644 --- a/apps/api-go/model/discount_code_reservation_test.go +++ b/apps/api-go/model/discount_code_reservation_test.go @@ -1,88 +1,247 @@ package model import ( - "fmt" + "context" "testing" "github.com/LIghtJUNction/api.lmm.best/common" "github.com/stretchr/testify/require" + "gorm.io/gorm" ) -func TestLimitedDiscountReservationPreventsOversubscriptionWithoutBlockingPaidOrders(t *testing.T) { +func limitedDiscountReservationFixture(t *testing.T) (*gorm.DB, DiscountCode) { + t.Helper() db := setupExternalTopUpSettlementDB(t, 1) require.NoError(t, db.AutoMigrate(&DiscountCode{}, &DiscountCodeReservation{})) previousRedisEnabled := common.RedisEnabled common.RedisEnabled = false t.Cleanup(func() { common.RedisEnabled = previousRedisEnabled }) - code := DiscountCode{ - Code: "LAST-DISCOUNT-SLOT", - Status: DiscountCodeStatusEnabled, - DiscountPercent: 50, - MaxUses: 1, + Code: "LAST-DISCOUNT-SLOT", Status: DiscountCodeStatusEnabled, + DiscountPercent: 50, MaxUses: 1, } require.NoError(t, db.Create(&code).Error) + return db, code +} - newPending := func(suffix string) (*User, *TopUp) { - user := &User{Username: "discount-" + suffix, AffCode: "aff-" + suffix, Status: common.UserStatusEnabled, Group: "default"} - require.NoError(t, db.Create(user).Error) - topUp := &TopUp{ - UserId: user.Id, - Amount: 10, - CreditedQuota: 1_000, - ExpectedAmountMicros: 5_000_000, - Money: 5, - TradeNo: "discount-reservation-" + suffix, - PaymentMethod: PaymentMethodWaffoPancake, - PaymentProvider: PaymentProviderWaffoPancake, - SettlementCurrency: "USD", - DiscountCodeId: code.Id, - DiscountPercent: code.DiscountPercent, - CreateTime: common.GetTimestamp(), - Status: common.TopUpStatusPending, - } - return user, topUp +func pendingDiscountReservationFixture(t *testing.T, db *gorm.DB, code DiscountCode, suffix, provider string) (*User, *TopUp) { + t.Helper() + user := &User{Username: "discount-" + suffix, AffCode: "aff-" + suffix, Status: common.UserStatusEnabled, Group: "default"} + require.NoError(t, db.Create(user).Error) + return user, &TopUp{ + UserId: user.Id, Amount: 10, CreditedQuota: 1_000, + ExpectedAmountMicros: 5_000_000, Money: 5, + TradeNo: "discount-reservation-" + suffix, + PaymentMethod: provider, PaymentProvider: provider, SettlementCurrency: "USD", + DiscountCodeId: code.Id, DiscountPercent: code.DiscountPercent, + CreateTime: common.GetTimestamp(), Status: common.TopUpStatusPending, + } +} + +func discountReservationSettlement(topUp *TopUp) ExternalTopUpSettlement { + return ExternalTopUpSettlement{ + TradeNo: topUp.TradeNo, PaymentProvider: topUp.PaymentProvider, PaymentMethod: topUp.PaymentMethod, + SettledAmountMicros: topUp.ExpectedAmountMicros, SettlementCurrency: topUp.SettlementCurrency, + ProviderEventId: "EVT-" + topUp.TradeNo, ProviderTransactionId: "PAY-" + topUp.TradeNo, + } +} + +func requireDiscountReservationCreditOnce(t *testing.T, db *gorm.DB, code DiscountCode, user *User, topUp *TopUp) { + t.Helper() + for i := 0; i < 2; i++ { + _, err := CompleteExternalTopUp(discountReservationSettlement(topUp)) + require.NoError(t, err) } + var reloaded User + require.NoError(t, db.First(&reloaded, user.Id).Error) + require.EqualValues(t, 1_000, reloaded.Quota) + require.NoError(t, db.First(&code, code.Id).Error) + require.EqualValues(t, 1, code.UsedCount) + var consumedReservations int64 + require.NoError(t, db.Model(&DiscountCodeReservation{}). + Where("discount_code_id = ? AND status = ?", code.Id, DiscountCodeReservationStatusConsumed). + Count(&consumedReservations).Error) + require.EqualValues(t, 1, consumedReservations) +} - firstUser, first := newPending("first") +func requireDiscountReservationCapacityBlocked(t *testing.T, db *gorm.DB, code DiscountCode, topUp *TopUp) { + t.Helper() + _, err := ValidateDiscountCodeForUser(code.Code, 10, common.GetTimestamp(), topUp.UserId) + require.ErrorIs(t, err, ErrDiscountCodeExhausted, "preview must match atomic reservation") + require.ErrorIs(t, topUp.Insert(), ErrDiscountCodeExhausted) + var orders, reservations int64 + require.NoError(t, db.Model(&TopUp{}).Where("trade_no = ?", topUp.TradeNo).Count(&orders).Error) + require.NoError(t, db.Model(&DiscountCodeReservation{}).Where("top_up_trade_no = ?", topUp.TradeNo).Count(&reservations).Error) + require.Zero(t, orders) + require.Zero(t, reservations) +} + +func TestLimitedDiscountReservationExpiryKeepsPayableOrderCapacity(t *testing.T) { + db, code := limitedDiscountReservationFixture(t) + firstUser, first := pendingDiscountReservationFixture(t, db, code, "first", PaymentProviderWaffoPancake) require.NoError(t, first.Insert()) - _, blocked := newPending("blocked") - require.ErrorIs(t, blocked.Insert(), ErrDiscountCodeExhausted) + _, blocked := pendingDiscountReservationFixture(t, db, code, "blocked", PaymentProviderWaffoPancake) + requireDiscountReservationCapacityBlocked(t, db, code, blocked) - // Expiry permits another checkout, but does not invalidate a provider - // payment that may already be in flight for the first order. + // The old bug admitted another payable order after only this timestamp + // changed. Expiry is now advisory; settlement eligibility owns capacity. require.NoError(t, db.Model(&DiscountCodeReservation{}). Where("top_up_trade_no = ?", first.TradeNo). Update("expires_time", common.GetTimestamp()-1).Error) - secondUser, second := newPending("second") - require.NoError(t, second.Insert()) + requireDiscountReservationCapacityBlocked(t, db, code, blocked) + requireDiscountReservationCreditOnce(t, db, code, firstUser, first) + requireDiscountReservationCapacityBlocked(t, db, code, blocked) +} - settle := func(topUp *TopUp, index int) { - _, err := CompleteExternalTopUp(ExternalTopUpSettlement{ - TradeNo: topUp.TradeNo, - PaymentProvider: PaymentProviderWaffoPancake, - PaymentMethod: topUp.PaymentMethod, - SettledAmountMicros: topUp.ExpectedAmountMicros, - SettlementCurrency: topUp.SettlementCurrency, - ProviderEventId: fmt.Sprintf("EVT-discount-%d", index), - ProviderTransactionId: fmt.Sprintf("PAY-discount-%d", index), +func TestLimitedDiscountReservationWaffoTimeoutKeepsLatePaymentCapacity(t *testing.T) { + for _, legacyReleased := range []bool{false, true} { + name := "retained" + if legacyReleased { + name = "legacy_released" + } + t.Run(name, func(t *testing.T) { + db, code := limitedDiscountReservationFixture(t) + user, first := pendingDiscountReservationFixture(t, db, code, "first", PaymentProviderWaffoPancake) + require.NoError(t, first.Insert()) + failed, err := FailExpiredWaffoPancakeTopUp(context.Background(), first.Id, first.CreateTime, common.GetTimestamp()) + require.NoError(t, err) + require.True(t, failed) + var reservation DiscountCodeReservation + require.NoError(t, db.Where("top_up_trade_no = ?", first.TradeNo).First(&reservation).Error) + require.Equal(t, DiscountCodeReservationStatusReserved, reservation.Status) + if legacyReleased { + // Old versions released this recoverable state. No migration or + // current timestamp must make its outstanding liability invisible. + require.NoError(t, db.Model(&reservation).Update("status", DiscountCodeReservationStatusReleased).Error) + } + require.NoError(t, db.Model(&reservation).Update("expires_time", common.GetTimestamp()-1).Error) + _, blocked := pendingDiscountReservationFixture(t, db, code, "blocked", PaymentProviderWaffoPancake) + requireDiscountReservationCapacityBlocked(t, db, code, blocked) + requireDiscountReservationCreditOnce(t, db, code, user, first) }) - require.NoError(t, err) } - settle(second, 2) - settle(first, 1) +} + +func TestLimitedDiscountReservationDefinitiveCloseReusesCapacity(t *testing.T) { + for _, tc := range []struct { + name, provider string + close func(*TopUp) error + }{ + {"stripe_expired", PaymentProviderStripe, func(o *TopUp) error { + return UpdatePendingTopUpStatus(o.TradeNo, o.PaymentProvider, common.TopUpStatusExpired) + }}, + {"waffo_failed", PaymentProviderWaffo, func(o *TopUp) error { + return UpdatePendingTopUpStatus(o.TradeNo, o.PaymentProvider, common.TopUpStatusFailed) + }}, + {"company_billing_failure", PaymentProviderWaffoPancake, func(o *TopUp) error { + return FailPendingTopUpForCheckout(o.TradeNo, o.PaymentProvider, PaymentOrderFailureCompanyBillingRules) + }}, + } { + t.Run(tc.name, func(t *testing.T) { + db, code := limitedDiscountReservationFixture(t) + firstUser, first := pendingDiscountReservationFixture(t, db, code, "first", tc.provider) + require.NoError(t, first.Insert()) + require.NoError(t, tc.close(first)) + var reservation DiscountCodeReservation + require.NoError(t, db.Where("top_up_trade_no = ?", first.TradeNo).First(&reservation).Error) + require.Equal(t, DiscountCodeReservationStatusReleased, reservation.Status) + _, err := CompleteExternalTopUp(discountReservationSettlement(first)) + require.ErrorIs(t, err, ErrTopUpStatusInvalid, "only existing non-settleable states free capacity") + var unchanged User + require.NoError(t, db.First(&unchanged, firstUser.Id).Error) + require.Zero(t, unchanged.Quota) - for _, user := range []*User{firstUser, secondUser} { - var reloaded User - require.NoError(t, db.First(&reloaded, user.Id).Error) - require.EqualValues(t, 1_000, reloaded.Quota) + secondUser, second := pendingDiscountReservationFixture(t, db, code, "second", tc.provider) + _, err = ValidateDiscountCodeForUser(code.Code, 10, common.GetTimestamp(), second.UserId) + require.NoError(t, err) + require.NoError(t, second.Insert()) + requireDiscountReservationCreditOnce(t, db, code, secondUser, second) + }) + } +} + +func TestLimitedDiscountReservationReleaseFailsClosedWithoutTerminalOrder(t *testing.T) { + for _, state := range []string{common.TopUpStatusPending, "unknown", "missing"} { + t.Run(state, func(t *testing.T) { + db, code := limitedDiscountReservationFixture(t) + _, first := pendingDiscountReservationFixture(t, db, code, "first", PaymentProviderWaffoPancake) + require.NoError(t, first.Insert()) + if state == "missing" { + require.NoError(t, db.Delete(first).Error) + } else { + require.NoError(t, db.Model(first).Update("status", state).Error) + } + require.NoError(t, db.Transaction(func(tx *gorm.DB) error { + return releaseDiscountCodeReservationTx(tx, first.TradeNo) + })) + var reservation DiscountCodeReservation + require.NoError(t, db.Where("top_up_trade_no = ?", first.TradeNo).First(&reservation).Error) + require.Equal(t, DiscountCodeReservationStatusReserved, reservation.Status) + _, blocked := pendingDiscountReservationFixture(t, db, code, "blocked", PaymentProviderWaffoPancake) + requireDiscountReservationCapacityBlocked(t, db, code, blocked) + }) + } +} + +func TestLimitedDiscountReservationLegacyPayableOrdersKeepCapacity(t *testing.T) { + for _, missingReservation := range []bool{false, true} { + name := "released_pending" + if missingReservation { + name = "missing_reservation" + } + t.Run(name, func(t *testing.T) { + db, code := limitedDiscountReservationFixture(t) + user, first := pendingDiscountReservationFixture(t, db, code, "first", PaymentProviderWaffoPancake) + if missingReservation { + // Legacy checkouts predate atomic reservation. Their existing + // signed payment remains valid and cannot fund a new coupon slot. + require.NoError(t, db.Create(first).Error) + } else { + require.NoError(t, first.Insert()) + require.NoError(t, db.Model(&DiscountCodeReservation{}). + Where("top_up_trade_no = ?", first.TradeNo). + Update("status", DiscountCodeReservationStatusReleased).Error) + } + _, blocked := pendingDiscountReservationFixture(t, db, code, "blocked", PaymentProviderWaffoPancake) + requireDiscountReservationCapacityBlocked(t, db, code, blocked) + requireDiscountReservationCreditOnce(t, db, code, user, first) + }) + } +} + +func TestLimitedDiscountReservationSavedTerminalOrdersReuseCapacity(t *testing.T) { + for _, tc := range []struct { + name, provider, status, reason string + wantHeld bool + }{ + {"stripe_async_payment_failed", PaymentProviderStripe, common.TopUpStatusFailed, "", false}, + {"waffo_checkout_failed", PaymentProviderWaffo, common.TopUpStatusFailed, "", false}, + {"historical_expired", PaymentProviderStripe, common.TopUpStatusExpired, "", false}, + {"waffo_recoverable_timeout", PaymentProviderWaffoPancake, common.TopUpStatusFailed, string(PaymentOrderFailureCheckoutTimeout), true}, + } { + t.Run(tc.name, func(t *testing.T) { + db, code := limitedDiscountReservationFixture(t) + firstUser, first := pendingDiscountReservationFixture(t, db, code, "first", tc.provider) + require.NoError(t, first.Insert()) + // Stripe async failure and Waffo SDK/business failure handlers use + // this Save path. It leaves the reservation's status untouched. + first.Status, first.FailureReasonCode = tc.status, tc.reason + require.NoError(t, first.Update()) + var reservation DiscountCodeReservation + require.NoError(t, db.Where("top_up_trade_no = ?", first.TradeNo).First(&reservation).Error) + require.Equal(t, DiscountCodeReservationStatusReserved, reservation.Status) + secondUser, second := pendingDiscountReservationFixture(t, db, code, "second", tc.provider) + if tc.wantHeld { + requireDiscountReservationCapacityBlocked(t, db, code, second) + requireDiscountReservationCreditOnce(t, db, code, firstUser, first) + return + } + _, err := CompleteExternalTopUp(discountReservationSettlement(first)) + require.ErrorIs(t, err, ErrTopUpStatusInvalid) + _, err = ValidateDiscountCodeForUser(code.Code, 10, common.GetTimestamp(), second.UserId) + require.NoError(t, err) + require.NoError(t, second.Insert()) + requireDiscountReservationCreditOnce(t, db, code, secondUser, second) + }) } - var consumed DiscountCode - require.NoError(t, db.First(&consumed, code.Id).Error) - require.EqualValues(t, 2, consumed.UsedCount) - var consumedReservations int64 - require.NoError(t, db.Model(&DiscountCodeReservation{}). - Where("discount_code_id = ? AND status = ?", code.Id, DiscountCodeReservationStatusConsumed). - Count(&consumedReservations).Error) - require.EqualValues(t, 2, consumedReservations) } diff --git a/apps/api-go/model/oauth_authorization_cleanup.go b/apps/api-go/model/oauth_authorization_cleanup.go new file mode 100644 index 000000000..5adf17ded --- /dev/null +++ b/apps/api-go/model/oauth_authorization_cleanup.go @@ -0,0 +1,25 @@ +package model + +import ( + "time" + + "gorm.io/gorm" +) + +const OAuthAuthorizationCleanupBatchSize = 256 + +// CleanupExpiredOAuthAuthorizations removes one bounded batch of expired +// browser transactions. An empty issuer is the master cleanup's all-issuer +// mode. It never touches token families, billing bindings or replay tombstones. +func CleanupExpiredOAuthAuthorizations(db *gorm.DB, issuer string, now time.Time) (int64, error) { + if db == nil { + return 0, gorm.ErrInvalidDB + } + candidates := db.Model(&OAuthServerAuthorization{}).Select("digest"). + Where("expires_at_ms <= ?", now.UnixMilli()).Order("expires_at_ms ASC").Limit(OAuthAuthorizationCleanupBatchSize) + if issuer != "" { + candidates = candidates.Where("issuer = ?", issuer) + } + result := db.Where("digest IN (?) AND expires_at_ms <= ?", candidates, now.UnixMilli()).Delete(&OAuthServerAuthorization{}) + return result.RowsAffected, result.Error +} diff --git a/apps/api-go/model/oauth_server.go b/apps/api-go/model/oauth_server.go index ead4c197e..bdf7d4ba2 100644 --- a/apps/api-go/model/oauth_server.go +++ b/apps/api-go/model/oauth_server.go @@ -7,7 +7,7 @@ import "gorm.io/gorm" // These tables deliberately have no relation to dashboard JWTs or API key tokens. type OAuthServerAuthorization struct { Digest string `gorm:"primaryKey;size:64"` - Issuer string `gorm:"not null;size:512"` + Issuer string `gorm:"not null;size:512;index:idx_oauth_authorization_issuer_expiry,priority:1"` ClientID string `gorm:"not null;size:128"` ClientName string `gorm:"not null;default:'';size:256"` RedirectURI string `gorm:"not null;size:1024"` @@ -19,7 +19,7 @@ type OAuthServerAuthorization struct { ConsentDigest string `gorm:"not null;size:64"` UserID int64 `gorm:"not null"` CreatedAtMs int64 `gorm:"not null"` - ExpiresAtMs int64 `gorm:"not null;index"` + ExpiresAtMs int64 `gorm:"not null;index;index:idx_oauth_authorization_issuer_expiry,priority:2"` ConsumedAtMs int64 `gorm:"not null"` LockVersion int64 `gorm:"not null"` BrowserCSRFHash string `gorm:"not null;default:'';size:64"` diff --git a/apps/api-go/model/signal_game.go b/apps/api-go/model/signal_game.go index 86c0606d0..e20c3531a 100644 --- a/apps/api-go/model/signal_game.go +++ b/apps/api-go/model/signal_game.go @@ -77,6 +77,22 @@ func FindSignalGameAttempt(hash string) (SignalGameAttempt, error) { err := DB.Where("token_hash = ?", hash).Take(&row).Error return row, err } + +// CheckFinishTime rejects unavailable unfinished attempts before replay work. +// Finished attempts keep their existing idempotent retry behavior regardless of age. +func (attempt SignalGameAttempt) CheckFinishTime(now int64) error { + if attempt.FinishedAt != 0 { + return nil + } + if now < attempt.StartedAt { + return ErrSignalGameCountdown + } + if now-attempt.StartedAt > 24*60*60*1000 { + return ErrSignalGameExpired + } + return nil +} + func FinishSignalGameAttempt(hash, actions string, moves int, now int64) (SignalGameAttempt, error) { var result SignalGameAttempt err := DB.Transaction(func(tx *gorm.DB) error { @@ -89,11 +105,8 @@ func FinishSignalGameAttempt(hash, actions string, moves int, now int64) (Signal } return nil } - if now < result.StartedAt { - return ErrSignalGameCountdown - } - if now-result.StartedAt > 24*60*60*1000 { - return ErrSignalGameExpired + if err := result.CheckFinishTime(now); err != nil { + return err } result.FinishedAt = now result.ElapsedMs = now - result.StartedAt diff --git a/apps/api-go/model/signal_game_test.go b/apps/api-go/model/signal_game_test.go index 58698fd44..f36adb643 100644 --- a/apps/api-go/model/signal_game_test.go +++ b/apps/api-go/model/signal_game_test.go @@ -22,6 +22,9 @@ func TestSignalGameClaimAndLeaderboardPrivacy(t *testing.T) { retry, err := FinishSignalGameAttempt(attempt.TokenHash, "[1]", 1, 8000) require.NoError(t, err) require.Equal(t, done.ElapsedMs, retry.ElapsedMs) + retry, err = FinishSignalGameAttempt(attempt.TokenHash, "[1]", 1, 4000+48*60*60*1000) + require.NoError(t, err) + require.Equal(t, done.FinishedAt, retry.FinishedAt) _, err = FinishSignalGameAttempt(attempt.TokenHash, "[2]", 1, 9000) require.ErrorIs(t, err, ErrSignalGameConflict) row := SignalGameRecord{UserId: 1, AttemptId: &attempt.Id, Mode: "challenge", Day: attempt.Day, Size: 5, Moves: 10, ElapsedMs: 1000, Actor: "ai", ModelId: attempt.ModelId, Harness: attempt.Harness, AgentName: attempt.AgentName, ParticipantKey: "agent-key", Email: "private@example.test", Note: "public note", Actions: "[1]", Digest: "result-one", CreatedAt: 5000} @@ -58,3 +61,13 @@ func TestSignalGameClaimAndLeaderboardPrivacy(t *testing.T) { require.Len(t, ranks, 1) require.Equal(t, 9, ranks[0].Moves) } + +func TestSignalGameAttemptFinishTimeBoundaries(t *testing.T) { + attempt := SignalGameAttempt{StartedAt: 4000} + require.ErrorIs(t, attempt.CheckFinishTime(3999), ErrSignalGameCountdown) + require.NoError(t, attempt.CheckFinishTime(4000)) + require.NoError(t, attempt.CheckFinishTime(4000+24*60*60*1000)) + require.ErrorIs(t, attempt.CheckFinishTime(4001+24*60*60*1000), ErrSignalGameExpired) + attempt.FinishedAt = 5000 + require.NoError(t, attempt.CheckFinishTime(4000+48*60*60*1000)) +} diff --git a/apps/api-go/model/waffo_pancake_topup_expiry_test.go b/apps/api-go/model/waffo_pancake_topup_expiry_test.go index c612052e9..d526fa5e9 100644 --- a/apps/api-go/model/waffo_pancake_topup_expiry_test.go +++ b/apps/api-go/model/waffo_pancake_topup_expiry_test.go @@ -23,7 +23,7 @@ func TestWaffoPancakePaymentCheckedAtMigratesExistingTopUps(t *testing.T) { require.Zero(t, order.PaymentCheckedAt) } -func TestFailExpiredWaffoPancakeTopUpPreservesSettlementAndReleasesReservation(t *testing.T) { +func TestFailExpiredWaffoPancakeTopUpPreservesSettlementAndReservation(t *testing.T) { db := setupExternalTopUpSettlementDB(t, 1) require.NoError(t, db.AutoMigrate(&DiscountCodeReservation{})) const cutoff int64 = 1_800_000_000 @@ -56,7 +56,7 @@ func TestFailExpiredWaffoPancakeTopUpPreservesSettlementAndReleasesReservation(t require.Equal(t, cutoff+5, stored.CompleteTime) var reservation DiscountCodeReservation require.NoError(t, db.Where("top_up_trade_no = ?", orders[0].TradeNo).First(&reservation).Error) - require.Equal(t, DiscountCodeReservationStatusReleased, reservation.Status) + require.Equal(t, DiscountCodeReservationStatusReserved, reservation.Status) for _, order := range orders[1:] { failed, err = FailExpiredWaffoPancakeTopUp(context.Background(), order.Id, cutoff, cutoff+5) diff --git a/apps/api-go/oauthserver/README.md b/apps/api-go/oauthserver/README.md index c5a35b949..490fd9bdb 100644 --- a/apps/api-go/oauthserver/README.md +++ b/apps/api-go/oauthserver/README.md @@ -105,7 +105,9 @@ code TTL 固定 120 秒,单次使用。access TTL 固定 10 分钟,接近 fa - 每次 access 检查都联表读取 token/family,并检查当前 Policy;不缓存“仍有效”。撤销不能撤回在其提交前已经通过验证的在途操作。 - 必须使用主写库,不使用 read replica、读写分离 resolver 或事后可能回滚的外层事务。数据库不可用时 fail closed。生产需要配置连接池、锁/语句超时和可靠时钟。 -没有自动清理任务。未来清理应先处理到期 pending,按 family 的绝对期限/撤销与审计保留策略整族删除;**不能只按 used refresh 自身 idle expiry 删除 tombstone**,否则仍存活的后代会失去重放检测。日志不得记录 query、表单、callback code、state 或令牌响应。 +浏览器 preflight 的一次性 CSRF 和 binding 仍保存在授权事务中,以支持跨进程继续登录;它不是无状态验证。每个 issuer 最多保留 4096 条授权事务,新建前在同一数据库事务内回收到期记录(每次最多 256 条)并检查容量。PostgreSQL 使用事务级 advisory lock,SQLite 先取得写锁;多个实例不能并发越过上限。容量已满或 admission 锁正忙时返回 HTTP 503,不会挤掉仍有效的确认页面。上限也会限制正常登录高峰,客户端应稍后重新发起登录;已有超额历史记录会分批缩减,新请求不会继续增加积压。 + +主节点的每小时认证清理也会删除到期授权事务(每轮最多 20 批、每批 256 条,15 秒截止)。该清理不删除 grant、code、access/refresh 或计费绑定;这些记录仍需按 family 绝对期限、重放检测及在途退款/审计保留策略单独处理。**不能只按 used refresh 自身 idle expiry 删除 tombstone**,否则仍存活的后代会失去重放检测。日志不得记录 query、表单、callback code、state 或令牌响应。 ## DPoP 与未满足事项 diff --git a/apps/api-go/oauthserver/authorization.go b/apps/api-go/oauthserver/authorization.go index 130d2b4dc..360776c8e 100644 --- a/apps/api-go/oauthserver/authorization.go +++ b/apps/api-go/oauthserver/authorization.go @@ -48,16 +48,41 @@ func (s *Server) BeginAuthorization(ctx context.Context, rawQuery, browserBindin if err != nil { return nil, storageError(err) } - now := s.now() - row := model.OAuthServerAuthorization{ - Digest: digest(handle), Issuer: s.issuer, ClientID: client.ID, ClientName: client.Name, RedirectURI: values.Get("redirect_uri"), - Resource: values.Get("resource"), Scope: strings.Join(scopes, " "), State: state, - CodeChallenge: values.Get("code_challenge"), BrowserDigest: browserDigest(browserBinding), - CreatedAtMs: now.UnixMilli(), ExpiresAtMs: now.Add(AuthorizationTTL).UnixMilli(), - BrowserCSRFHash: "", BrowserSessionID: "", BrowserSessionVersion: 0, BrowserAuthVersion: 0, - } - if err := s.db.WithContext(ctx).Create(&row).Error; err != nil { - return nil, storageError(err) + var row model.OAuthServerAuthorization + err = s.transact(ctx, func(tx *gorm.DB) (*ProtocolError, error) { + acquired, err := s.lockAuthorizationAdmission(tx) + if err != nil { + return nil, err + } + if !acquired { + return protocolError("temporarily_unavailable"), nil + } + // Sample time after taking the writer lock, including SQLite lock waits. + now := s.now() + if _, err := model.CleanupExpiredOAuthAuthorizations(tx, s.issuer, now); err != nil { + return nil, err + } + // The issuer index and LIMIT bound reads even for a pre-existing backlog. + candidates := tx.Model(&model.OAuthServerAuthorization{}).Select("digest").Where("issuer = ?", s.issuer).Limit(MaxAuthorizationRows) + var count int64 + if err := tx.Table("(?) AS authorization_capacity", candidates).Count(&count).Error; err != nil { + return nil, err + } + if count >= MaxAuthorizationRows { + // Commit expired-row reclamation even when admission is refused. + return protocolError("temporarily_unavailable"), nil + } + row = model.OAuthServerAuthorization{ + Digest: digest(handle), Issuer: s.issuer, ClientID: client.ID, ClientName: client.Name, RedirectURI: values.Get("redirect_uri"), + Resource: values.Get("resource"), Scope: strings.Join(scopes, " "), State: state, + CodeChallenge: values.Get("code_challenge"), BrowserDigest: browserDigest(browserBinding), + CreatedAtMs: now.UnixMilli(), ExpiresAtMs: now.Add(AuthorizationTTL).UnixMilli(), + BrowserCSRFHash: "", BrowserSessionID: "", BrowserSessionVersion: 0, BrowserAuthVersion: 0, + } + return nil, tx.Create(&row).Error + }) + if err != nil { + return nil, err } pending := s.pendingView(row, handle) return &pending, nil diff --git a/apps/api-go/oauthserver/authorization_storage.go b/apps/api-go/oauthserver/authorization_storage.go new file mode 100644 index 000000000..58ea0ce1b --- /dev/null +++ b/apps/api-go/oauthserver/authorization_storage.go @@ -0,0 +1,24 @@ +package oauthserver + +import "gorm.io/gorm" + +// MaxAuthorizationRows bounds persisted browser state per issuer, including +// abandoned and consumed rows awaiting expiry cleanup. At capacity, new login +// flows fail closed; existing live transactions are never evicted to make room. +const MaxAuthorizationRows = 4096 + +// Use a separate advisory-lock namespace from one-key application locks. +const authorizationAdmissionLockNamespace = 0x4c4d4f41 + +func (s *Server) lockAuthorizationAdmission(tx *gorm.DB) (bool, error) { + if tx.Dialector.Name() == "postgres" { + var acquired bool + err := tx.Raw("SELECT pg_catalog.pg_try_advisory_xact_lock(?, pg_catalog.hashtext(?))", authorizationAdmissionLockNamespace, s.issuer).Scan(&acquired).Error + return acquired, err + } + // New accepts only PostgreSQL and SQLite. A first write, even with no + // matching rows, takes SQLite's writer lock before cleanup/count/insert. + // Do not replace this with a process-local mutex or a deferred read. + err := tx.Exec("UPDATE oauth_server_authorizations SET lock_version = lock_version WHERE 1 = 0").Error + return err == nil, err +} diff --git a/apps/api-go/oauthserver/authorization_storage_test.go b/apps/api-go/oauthserver/authorization_storage_test.go new file mode 100644 index 000000000..abbb90c9d --- /dev/null +++ b/apps/api-go/oauthserver/authorization_storage_test.go @@ -0,0 +1,182 @@ +package oauthserver + +import ( + "context" + "fmt" + "sync" + "testing" + "time" + + "github.com/LIghtJUNction/api.lmm.best/model" + "github.com/stretchr/testify/require" + "gorm.io/gorm" +) + +func seedAuthorizationRows(t *testing.T, db *gorm.DB, issuer string, count int, expires time.Time) { + t.Helper() + rows := make([]model.OAuthServerAuthorization, count) + for i := range rows { + rows[i] = model.OAuthServerAuthorization{Digest: fmt.Sprintf("%s-row-%d", issuer, i), Issuer: issuer, ExpiresAtMs: expires.UnixMilli()} + } + require.NoError(t, db.CreateInBatches(rows, 100).Error) +} + +func TestAuthorizationStorageCapAcrossIndependentPools(t *testing.T) { + forDatabases(t, func(t *testing.T, db, other *gorm.DB) { + first, clock, _ := testServer(t, db) + second, _, _ := testServer(t, other) + require.True(t, db.Migrator().HasIndex(&model.OAuthServerAuthorization{}, "idx_oauth_authorization_issuer_expiry")) + seedAuthorizationRows(t, db, testIssuer, MaxAuthorizationRows-1, clock.now().Add(AuthorizationTTL)) + ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second) + defer cancel() + start := make(chan struct{}) + results := make(chan error, 8) + var workers sync.WaitGroup + for i := range 8 { + workers.Add(1) + s := []*Server{first, second}[i%2] + go func() { + defer workers.Done() + <-start + _, err := s.BeginAuthorization(ctx, authorizationValues().Encode(), testBrowser) + results <- err + }() + } + close(start) + workers.Wait() + close(results) + accepted := 0 + for err := range results { + if err == nil { + accepted++ + continue + } + expectProtocol(t, err, "temporarily_unavailable") + } + require.Equal(t, 1, accepted) + var count int64 + require.NoError(t, db.Model(&model.OAuthServerAuthorization{}).Where("issuer = ?", testIssuer).Count(&count).Error) + require.EqualValues(t, MaxAuthorizationRows, count) + for range 2 { + pending, err := second.BeginAuthorization(ctx, authorizationValues().Encode(), testBrowser) + require.Nil(t, pending) + expectProtocol(t, err, "temporarily_unavailable") + } + require.NoError(t, db.Model(&model.OAuthServerAuthorization{}).Where("issuer = ?", testIssuer).Count(&count).Error) + require.EqualValues(t, MaxAuthorizationRows, count) + // Capacity is per issuer, never a process-local or client-controlled key. + config := testConfig() + config.Issuer = "https://other.lmm.test" + otherIssuer, err := New(other, config, &testPolicy{}) + require.NoError(t, err) + otherIssuer.now = clock.now + _, err = otherIssuer.BeginAuthorization(ctx, authorizationValues().Encode(), testBrowser) + require.NoError(t, err) + }) +} + +func TestAuthorizationStorageExpiryRecoveryPreservesLiveCSRFAndTombstones(t *testing.T) { + forDatabases(t, func(t *testing.T, db, _ *gorm.DB) { + s, clock, _ := testServer(t, db) + seedAuthorizationRows(t, db, testIssuer, MaxAuthorizationRows+model.OAuthAuthorizationCleanupBatchSize+5, clock.now()) + _, err := s.BeginAuthorization(context.Background(), authorizationValues().Encode(), testBrowser) + expectProtocol(t, err, "temporarily_unavailable") + var count int64 + require.NoError(t, db.Model(&model.OAuthServerAuthorization{}).Count(&count).Error) + require.EqualValues(t, MaxAuthorizationRows+5, count, "bounded expiry cleanup must commit even when admission is refused") + pending, err := s.BeginAuthorization(context.Background(), authorizationValues().Encode(), testBrowser) + require.NoError(t, err) + csrf := "a-single-use-server-generated-csrf-32-bytes" + require.NoError(t, s.SetBrowserCSRF(context.Background(), pending.Transaction, testBrowser, csrf)) + seedAuthorizationRows(t, db, "https://other.lmm.test", 1, clock.now()) + require.NoError(t, db.Create(&model.OAuthServerGrant{ID: "retained-family", Issuer: testIssuer, AbsoluteExpiresAtMs: clock.now().Add(time.Hour).UnixMilli()}).Error) + require.NoError(t, db.Create(&model.OAuthServerCode{Digest: "retained-code", Issuer: testIssuer, FamilyID: "retained-family", UsedAtMs: 1, ExpiresAtMs: 1}).Error) + require.NoError(t, db.Create(&model.OAuthServerToken{Digest: "retained-refresh", Issuer: testIssuer, FamilyID: "retained-family", Kind: "refresh", UsedAtMs: 1, ExpiresAtMs: 1}).Error) + for range 20 { + deleted, err := model.CleanupExpiredOAuthAuthorizations(db, "", clock.now()) + require.NoError(t, err) + require.LessOrEqual(t, deleted, int64(model.OAuthAuthorizationCleanupBatchSize)) + if deleted < model.OAuthAuthorizationCleanupBatchSize { + break + } + } + require.NoError(t, db.Model(&model.OAuthServerAuthorization{}).Count(&count).Error) + require.EqualValues(t, 1, count) + for _, row := range []any{&model.OAuthServerGrant{}, &model.OAuthServerCode{}, &model.OAuthServerToken{}} { + require.NoError(t, db.Model(row).Count(&count).Error) + require.EqualValues(t, 1, count) + } + flow, err := s.ConsumeBrowserFlow(context.Background(), testBrowser, csrf) + require.NoError(t, err) + require.NotNil(t, flow) + _, err = s.ConsumeBrowserFlow(context.Background(), testBrowser, csrf) + expectProtocol(t, err, "invalid_request") + // Expiry is inclusive at the exact boundary, never before it. + clock.advance(AuthorizationTTL) + deleted, err := model.CleanupExpiredOAuthAuthorizations(db, testIssuer, clock.now()) + require.NoError(t, err) + require.EqualValues(t, 1, deleted) + }) +} + +func TestAuthorizationStorageRejectsInvalidAndCancelledRequestsWithoutWrites(t *testing.T) { + forDatabases(t, func(t *testing.T, db, _ *gorm.DB) { + s, clock, _ := testServer(t, db) + seedAuthorizationRows(t, db, testIssuer, 1, clock.now()) + _, err := s.BeginAuthorization(context.Background(), authorizationValues().Encode()+"&client_id=duplicate", testBrowser) + expectProtocol(t, err, "invalid_request") + ctx, cancel := context.WithCancel(context.Background()) + cancel() + _, err = s.BeginAuthorization(ctx, authorizationValues().Encode(), testBrowser) + require.Error(t, err) + var count int64 + require.NoError(t, db.Model(&model.OAuthServerAuthorization{}).Count(&count).Error) + require.EqualValues(t, 1, count) + }) +} + +func TestAuthorizationStorageSamplesTimeAfterAdmissionLock(t *testing.T) { + forDatabases(t, func(t *testing.T, db, other *gorm.DB) { + first, clock, _ := testServer(t, db) + second, _, _ := testServer(t, other) + holder := db.Begin() + require.NoError(t, holder.Error) + t.Cleanup(func() { _ = holder.Rollback().Error }) + acquired, err := first.lockAuthorizationAdmission(holder) + require.NoError(t, err) + require.True(t, acquired) + reads := make(chan struct{}, 1) + second.now = func() time.Time { reads <- struct{}{}; return clock.now() } + ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second) + defer cancel() + type result struct { + pending *PendingAuthorization + err error + } + results := make(chan result, 1) + go func() { + pending, err := second.BeginAuthorization(ctx, authorizationValues().Encode(), testBrowser) + results <- result{pending, err} + }() + if db.Dialector.Name() == "postgres" { + got := <-results + require.Nil(t, got.pending) + expectProtocol(t, got.err, "temporarily_unavailable") + } else { + select { + case <-reads: + t.Fatal("authorization time was sampled before the waiting writer acquired its lock") + case <-time.After(25 * time.Millisecond): + } + } + clock.advance(AuthorizationTTL) + require.NoError(t, holder.Rollback().Error) + if db.Dialector.Name() == "postgres" { + pending, err := second.BeginAuthorization(ctx, authorizationValues().Encode(), testBrowser) + results <- result{pending, err} + } + got := <-results + require.NoError(t, got.err) + require.Equal(t, clock.now().Add(AuthorizationTTL), got.pending.ExpiresAt) + }) +} diff --git a/apps/api-go/oauthserver/types.go b/apps/api-go/oauthserver/types.go index 5eb2e4709..841cc1098 100644 --- a/apps/api-go/oauthserver/types.go +++ b/apps/api-go/oauthserver/types.go @@ -169,6 +169,8 @@ func protocolError(code string) *ProtocolError { status, description = http.StatusUnauthorized, "The access token is invalid." case "server_error": status, description = http.StatusServiceUnavailable, "The authorization service is unavailable." + case "temporarily_unavailable": + status, description = http.StatusServiceUnavailable, "The authorization service is temporarily busy. Please try again later." } return &ProtocolError{Code: code, Description: description, Status: status} } diff --git a/apps/api-go/oidcprovider/provider.go b/apps/api-go/oidcprovider/provider.go index 79e6e04fd..a0f339c3a 100644 --- a/apps/api-go/oidcprovider/provider.go +++ b/apps/api-go/oidcprovider/provider.go @@ -239,9 +239,40 @@ func (p *Provider) transport(r *http.Request) bool { } return false } + +func (p *Provider) trustedProxy(ip net.IP) bool { + for _, network := range p.config.TrustedProxies { + if network != nil && network.Contains(ip) { + return true + } + } + return false +} + +func (p *Provider) rateLimitClientIP(r *http.Request) string { + peer, _, _ := net.SplitHostPort(r.RemoteAddr) + if !p.trustedProxy(net.ParseIP(peer)) || len(r.Header.Values("X-Forwarded-For")) != 1 { + return peer + } + // The packaged Nginx edge appends its client to X-Forwarded-For. Walk + // backwards through explicitly trusted proxies, stopping at the first + // untrusted address; any earlier entries are controlled by that client. + forwarded := r.Header.Get("X-Forwarded-For") + for { + comma := strings.LastIndexByte(forwarded, ',') + ip := net.ParseIP(strings.TrimSpace(forwarded[comma+1:])) + if ip == nil { + return peer + } + if comma < 0 || !p.trustedProxy(ip) { + return ip.String() + } + forwarded = forwarded[:comma] + } +} + func (p *Provider) allowed(r *http.Request) bool { - host, _, _ := net.SplitHostPort(r.RemoteAddr) - key := host + ":" + r.URL.Path + key := p.rateLimitClientIP(r) + ":" + r.URL.Path now := time.Now() p.mu.Lock() defer p.mu.Unlock() diff --git a/apps/api-go/oidcprovider/rate_limit_proxy_test.go b/apps/api-go/oidcprovider/rate_limit_proxy_test.go new file mode 100644 index 000000000..b37535c70 --- /dev/null +++ b/apps/api-go/oidcprovider/rate_limit_proxy_test.go @@ -0,0 +1,151 @@ +package oidcprovider + +import ( + "context" + "fmt" + "net" + "net/http" + "net/http/httptest" + "strings" + "testing" + "time" +) + +func rateLimitProxyProvider(t *testing.T) *Provider { + t.Helper() + p := &Provider{rates: map[string]bucket{}} + for _, cidr := range []string{"127.0.0.1/32", "::1/128", "10.0.0.0/8"} { + _, network, err := net.ParseCIDR(cidr) + if err != nil { + t.Fatal(err) + } + p.config.TrustedProxies = append(p.config.TrustedProxies, network) + } + return p +} + +func TestRateLimitProxyIdentity(t *testing.T) { + for _, tc := range []struct { + name, peer, want string + forwarded []string + }{ + {"single client", "127.0.0.1:1234", "198.51.100.7", []string{"198.51.100.7"}}, + {"nginx appended client", "127.0.0.1:1234", "198.51.100.7", []string{"203.0.113.8, 198.51.100.7"}}, + {"untrusted prefix is ignored", "127.0.0.1:1234", "198.51.100.7", []string{"invalid, 198.51.100.7"}}, + {"trusted proxy chain", "127.0.0.1:1234", "198.51.100.7", []string{"203.0.113.8, 198.51.100.7, 10.1.2.3"}}, + {"all trusted chain", "127.0.0.1:1234", "10.1.2.3", []string{"10.1.2.3, 10.4.5.6"}}, + {"ipv6 client", "[::1]:1234", "2001:db8::7", []string{" 2001:0db8:0:0::7 "}}, + {"mapped ipv4 client", "[::1]:1234", "198.51.100.7", []string{"::ffff:198.51.100.7"}}, + {"mapped trusted peer", "[::ffff:127.0.0.1]:1234", "198.51.100.7", []string{"198.51.100.7"}}, + {"untrusted peer", "198.51.100.7:1234", "198.51.100.7", []string{"203.0.113.8"}}, + {"untrusted ipv6 peer", "[2001:db8::7]:1234", "2001:db8::7", []string{"203.0.113.8"}}, + {"missing header", "127.0.0.1:1234", "127.0.0.1", nil}, + {"empty header", "127.0.0.1:1234", "127.0.0.1", []string{""}}, + {"invalid address", "127.0.0.1:1234", "127.0.0.1", []string{"not-an-ip"}}, + {"address with port", "127.0.0.1:1234", "127.0.0.1", []string{"198.51.100.7:1234"}}, + {"bracketed ipv6", "[::1]:1234", "::1", []string{"[2001:db8::7]"}}, + {"empty nearest hop", "127.0.0.1:1234", "127.0.0.1", []string{"198.51.100.7,"}}, + {"invalid trusted chain", "127.0.0.1:1234", "127.0.0.1", []string{"invalid, 10.1.2.3"}}, + {"duplicate headers", "127.0.0.1:1234", "127.0.0.1", []string{"198.51.100.7", "203.0.113.8"}}, + {"malformed peer", "not-a-peer", "", []string{"198.51.100.7"}}, + } { + t.Run(tc.name, func(t *testing.T) { + p := rateLimitProxyProvider(t) + r := httptest.NewRequest("GET", "https://api.lmm.best/api/oidc/jwks", nil) + r.RemoteAddr = tc.peer + r.Header["X-Forwarded-For"] = tc.forwarded + r.Header.Set("X-Real-IP", "192.0.2.99") + if !p.allowed(r) { + t.Fatal("first request rejected") + } + if len(p.rates) != 1 || p.rates[tc.want+":"+r.URL.Path].count != 1 { + t.Fatalf("unexpected rate bucket: %#v", p.rates) + } + }) + } +} + +func TestRateLimitProxyIsolationAcrossHandlers(t *testing.T) { + for _, tc := range []struct { + name, method, path string + status int + handler func(*Provider) http.Handler + }{ + {"protocol", "GET", "/oidc/.well-known/openid-configuration", http.StatusOK, (*Provider).Handler}, + {"browser", "GET", "/api/user/auth/oidc/grants", http.StatusOK, (*Provider).BrowserEntryHandler}, + {"attestation", "POST", "/api/oidc/attest", http.StatusUnauthorized, (*Provider).AttestationHandler}, + } { + t.Run(tc.name, func(t *testing.T) { + p := rateLimitProxyProvider(t) + p.config.BrowserIdentity = func(context.Context, *http.Request) (Identity, error) { + return Identity{}, ErrDenied + } + handler := tc.handler(p) + request := func(client string) *httptest.ResponseRecorder { + r := httptest.NewRequest(tc.method, "http://api.lmm.best"+tc.path, nil) + r.RemoteAddr = "127.0.0.1:1234" + r.Header.Set("X-Forwarded-Proto", "https") + r.Header.Set("X-Forwarded-For", "203.0.113.8, "+client) + w := httptest.NewRecorder() + handler.ServeHTTP(w, r) + return w + } + for i := 0; i < 120; i++ { + if w := request("198.51.100.7"); w.Code != tc.status { + t.Fatalf("request %d: got %d, want %d", i+1, w.Code, tc.status) + } + } + if w := request("198.51.100.7"); w.Code != http.StatusTooManyRequests || !strings.Contains(w.Body.String(), "rate_limited") { + t.Fatalf("limit not enforced: %d %s", w.Code, w.Body.String()) + } + if w := request("198.51.100.8"); w.Code != tc.status { + t.Fatalf("another client inherited the limit: %d", w.Code) + } + }) + } +} + +func TestRateLimitProxyCannotRotateUntrustedHeaders(t *testing.T) { + p := rateLimitProxyProvider(t) + r := httptest.NewRequest("GET", "https://api.lmm.best/api/oidc/jwks", nil) + r.RemoteAddr = "198.51.100.7:1234" + for i := 0; i < 121; i++ { + r.Header.Set("X-Forwarded-For", fmt.Sprintf("203.0.113.%d", i)) + r.Header.Set("X-Real-IP", fmt.Sprintf("192.0.2.%d", i)) + if got := p.allowed(r); got != (i < 120) { + t.Fatalf("request %d: allowed=%v", i+1, got) + } + } +} + +func TestRateLimitProxyPreservesPathWindowAndCapacity(t *testing.T) { + p := rateLimitProxyProvider(t) + r := httptest.NewRequest("GET", "https://api.lmm.best/api/oidc/jwks", nil) + r.RemoteAddr = "127.0.0.1:1234" + r.Header.Set("X-Forwarded-For", "198.51.100.7") + key := "198.51.100.7:" + r.URL.Path + p.rates[key] = bucket{start: time.Now(), count: 120} + if p.allowed(r) { + t.Fatal("active full window accepted") + } + r.URL.Path = "/api/oidc/token" + if !p.allowed(r) { + t.Fatal("different endpoint shared the limit") + } + r.URL.Path = "/api/oidc/jwks" + p.rates[key] = bucket{start: time.Now().Add(-time.Minute - time.Second), count: 120} + if !p.allowed(r) || p.rates[key].count != 1 { + t.Fatal("expired window did not restart") + } + p.rates = make(map[string]bucket, 4096) + for i := 0; i < 4096; i++ { + p.rates[fmt.Sprint(i)] = bucket{start: time.Now(), count: 1} + } + if p.allowed(r) || len(p.rates) != 4096 { + t.Fatal("live bucket capacity was not enforced") + } + p.rates["0"] = bucket{start: time.Now().Add(-time.Minute - time.Second), count: 1} + if !p.allowed(r) || len(p.rates) != 4096 || p.rates[key].count != 1 { + t.Fatal("expired bucket was not reclaimed") + } +} diff --git a/apps/api-go/relay/channel/ali/image.go b/apps/api-go/relay/channel/ali/image.go index adaf5ece3..6829b5ff7 100644 --- a/apps/api-go/relay/channel/ali/image.go +++ b/apps/api-go/relay/channel/ali/image.go @@ -11,6 +11,7 @@ import ( "time" "github.com/LIghtJUNction/api.lmm.best/common" + "github.com/LIghtJUNction/api.lmm.best/constant" "github.com/LIghtJUNction/api.lmm.best/logger" relaycommon "github.com/LIghtJUNction/api.lmm.best/relay/common" "github.com/LIghtJUNction/api.lmm.best/relaykit/dto" @@ -316,6 +317,11 @@ func aliImageHandler(a *Adaptor, c *gin.Context, resp *http.Response, info *rela if err != nil { return types.NewOpenAIError(err, types.ErrorCodeBadResponseBody, http.StatusInternalServerError), nil } + if !a.IsSyncImageModel && strings.TrimSpace(aliTaskResponse.Output.TaskId) != "" { + // Polling or result conversion can still fail after acceptance. Retrying + // the submission would create another provider job, not resume this one. + common.SetContextKey(c, constant.ContextKeyUpstreamAsyncTaskAccepted, true) + } if aliTaskResponse.Message != "" { logger.LogError(c, "ali_async_task_failed: "+aliTaskResponse.Message) diff --git a/apps/api-go/relay/channel/ali/image_acceptance_test.go b/apps/api-go/relay/channel/ali/image_acceptance_test.go new file mode 100644 index 000000000..971d22c85 --- /dev/null +++ b/apps/api-go/relay/channel/ali/image_acceptance_test.go @@ -0,0 +1,109 @@ +package ali + +import ( + "context" + "errors" + "fmt" + "io" + "net/http" + "strings" + "testing" + "testing/iotest" + "testing/synctest" + "time" + + "github.com/LIghtJUNction/api.lmm.best/common" + "github.com/LIghtJUNction/api.lmm.best/constant" + "github.com/LIghtJUNction/api.lmm.best/relaykit/dto" + "github.com/LIghtJUNction/api.lmm.best/relaykit/types" + "github.com/LIghtJUNction/api.lmm.best/service" + "github.com/stretchr/testify/require" +) + +func TestAliImageAcceptanceBoundary(t *testing.T) { + for _, tc := range []struct { + name string + body string + syncModel bool + readError bool + accepted bool + }{ + {"async_id_and_message", `{"output":{"task_id":"fixture-task"},"message":"fixture error"}`, false, false, true}, + {"async_nonblank_id", `{"output":{"task_id":" task "},"message":"fixture error"}`, false, false, true}, + {"async_blank_id", `{"output":{"task_id":" "},"message":"fixture error"}`, false, false, false}, + {"async_missing_id", `{"message":"fixture error"}`, false, false, false}, + {"malformed_body", `{"output":`, false, false, false}, + {"unreadable_body", "", false, true, false}, + {"sync_incidental_id", `{"output":{"task_id":"fixture-task"},"message":"fixture error"}`, true, false, false}, + } { + t.Run(tc.name, func(t *testing.T) { + c, info := pollTestContext(context.Background()) + var body io.Reader = strings.NewReader(tc.body) + if tc.readError { + body = iotest.ErrReader(errors.New("fixture body read failure")) + } + resp := &http.Response{StatusCode: http.StatusOK, Header: make(http.Header), Body: io.NopCloser(body)} + apiErr, usage := aliImageHandler(&Adaptor{IsSyncImageModel: tc.syncModel}, c, resp, info) + require.NotNil(t, apiErr) + require.Nil(t, usage) + require.Equal(t, tc.accepted, common.GetContextKeyBool(c, constant.ContextKeyUpstreamAsyncTaskAccepted)) + // Pre-acceptance parsing failures retain the existing error-code policy. + wantRetry := !tc.accepted && apiErr.GetErrorCode() != types.ErrorCodeBadResponseBody + require.Equal(t, wantRetry, service.ShouldRetryRelayError(c, apiErr, 1)) + }) + } +} + +func TestAliAcceptedImageTerminalErrorsCannotRetry(t *testing.T) { + client, err := service.GetHttpClientWithProxySettings("", dto.ChannelSettings{}) + require.NoError(t, err) + original, timeout := client.Transport, client.Timeout + t.Cleanup(func() { client.Transport, client.Timeout = original, timeout }) + client.Timeout = 0 + for _, status := range []string{"FAILED", "CANCELED", "UNKNOWN", ""} { + t.Run(status, func(t *testing.T) { + synctest.Test(t, func(t *testing.T) { + polls := 0 + client.Transport = pollTestTransport(func(r *http.Request) (*http.Response, error) { + polls++ + require.Equal(t, "/api/v1/tasks/fixture-task", r.URL.Path) + raw := fmt.Sprintf(`{"output":{"task_status":%q,"code":"channel:fixture","message":"fixture failure"}}`, status) + return &http.Response{StatusCode: http.StatusOK, Header: make(http.Header), Body: io.NopCloser(strings.NewReader(raw))}, nil + }) + c, info := pollTestContext(context.Background()) + resp := &http.Response{StatusCode: http.StatusOK, Header: make(http.Header), Body: io.NopCloser(strings.NewReader(`{"output":{"task_id":"fixture-task"}}`))} + started := time.Now() + apiErr, usage := aliImageHandler(&Adaptor{}, c, resp, info) + require.NotNil(t, apiErr) + require.Nil(t, usage) + require.Equal(t, 1, polls) + require.Equal(t, 5*time.Second, time.Since(started)) + require.True(t, common.GetContextKeyBool(c, constant.ContextKeyUpstreamAsyncTaskAccepted)) + require.False(t, service.ShouldRetryRelayError(c, apiErr, 2)) + }) + }) + } +} + +func TestAliAcceptedImageStillHonorsClientCancellation(t *testing.T) { + client, err := service.GetHttpClientWithProxySettings("", dto.ChannelSettings{}) + require.NoError(t, err) + original := client.Transport + t.Cleanup(func() { client.Transport = original }) + polls := 0 + client.Transport = pollTestTransport(func(*http.Request) (*http.Response, error) { + polls++ + return pollTestSuccess(), nil + }) + ctx, cancel := context.WithCancel(context.Background()) + cancel() + c, info := pollTestContext(ctx) + resp := &http.Response{StatusCode: http.StatusOK, Header: make(http.Header), Body: io.NopCloser(strings.NewReader(`{"output":{"task_id":"fixture-task"}}`))} + apiErr, usage := aliImageHandler(&Adaptor{}, c, resp, info) + require.NotNil(t, apiErr) + require.ErrorIs(t, apiErr, context.Canceled) + require.Nil(t, usage) + require.Zero(t, polls) + require.True(t, common.GetContextKeyBool(c, constant.ContextKeyUpstreamAsyncTaskAccepted)) + require.False(t, service.ShouldRetryRelayError(c, apiErr, 2)) +} diff --git a/apps/api-go/relaykit/dto/openai_responses_compaction_request.go b/apps/api-go/relaykit/dto/openai_responses_compaction_request.go index 9024287c3..5f843f0c2 100644 --- a/apps/api-go/relaykit/dto/openai_responses_compaction_request.go +++ b/apps/api-go/relaykit/dto/openai_responses_compaction_request.go @@ -47,16 +47,61 @@ func (r *OpenAIResponsesCompactionRequest) GetTokenCountMeta() *types.TokenCount // Only traverse protocol content containers. Tool arguments and unknown items // remain text, even when they happen to contain image-like JSON. func collectResponsesTokenInput(raw json.RawMessage, texts *[]string, files *[]*types.FileMeta) { - var text string - if json.Unmarshal(raw, &text) == nil { - *texts = append(*texts, text) + if !json.Valid(raw) { + *texts = append(*texts, normalizeRawJSONForTokenCount(raw)) return } - var items []json.RawMessage - if json.Unmarshal(raw, &items) == nil { - for _, item := range items { - collectResponsesTokenInput(item, texts, files) + // Most opaque/tool inputs need no container index at all. This typed probe + // is performed only once at the root, never recursively over subtrees. + start := responsesJSONStart(raw, 0) + if raw[start] != '[' { + var message struct { + Type, Role string + Content json.RawMessage + } + if raw[start] != '{' || json.Unmarshal(raw, &message) != nil || (message.Type != "" && message.Type != "message") || message.Role == "" || len(message.Content) == 0 { + collectResponsesTokenItem(raw, texts, files) + return + } + } + containers := indexResponsesJSONContainers(raw) + root := nextResponsesJSONValue(raw, start, 0, containers) + pending := []responsesJSONValue{root} + for len(pending) > 0 { + value := pending[len(pending)-1] + pending = pending[:len(pending)-1] + if raw[value.start] == '[' { + begin := len(pending) + position, next := responsesJSONStart(raw, value.start+1), value.container+1 + for raw[position] != ']' { + child := nextResponsesJSONValue(raw, position, next, containers) + pending = append(pending, child) + position, next = responsesJSONStart(raw, child.end), child.next + } + for left, right := begin, len(pending)-1; left < right; left, right = left+1, right-1 { + pending[left], pending[right] = pending[right], pending[left] + } + continue + } + if role, content, ok := responsesMessageContent(raw, containers, value); ok { + *texts = append(*texts, role) + pending = append(pending, content) + continue } + itemRaw := raw[value.start:value.end] + if value == root { + itemRaw = raw // Root fallback retains surrounding whitespace. + } + collectResponsesTokenItem(itemRaw, texts, files) + } +} + +// Terminal values are disjoint spans, so their original typed decoding does +// not reparse nested content and preserves field/type-error handling. +func collectResponsesTokenItem(raw json.RawMessage, texts *[]string, files *[]*types.FileMeta) { + var text string + if json.Unmarshal(raw, &text) == nil { + *texts = append(*texts, text) return } var item struct { @@ -109,12 +154,7 @@ func collectResponsesTokenInput(raw json.RawMessage, texts *[]string, files *[]* *files = append(*files, &types.FileMeta{FileType: types.FileTypeFile, Source: types.NewFileSourceFromData(data, "")}) return } - case "", "message": - if item.Role != "" && len(item.Content) > 0 { - *texts = append(*texts, item.Role) - collectResponsesTokenInput(item.Content, texts, files) - return - } + } } *texts = append(*texts, normalizeRawJSONForTokenCount(raw)) diff --git a/apps/api-go/relaykit/dto/responses_json_index.go b/apps/api-go/relaykit/dto/responses_json_index.go new file mode 100644 index 000000000..fb5280be4 --- /dev/null +++ b/apps/api-go/relaykit/dto/responses_json_index.go @@ -0,0 +1,173 @@ +package dto + +import ( + "bytes" + "encoding/json" +) + +// Only containers retain index entries: two ints each, with no copied JSON, +// scalar nodes or decoded field names. next skips all descendant containers. +type responsesJSONContainer struct{ end, next int } +type responsesJSONValue struct{ start, end, container, next int } + +// These span helpers are used only after json.Valid. They do not implement a +// second validity grammar: encoding/json owns syntax and its depth boundary. +func responsesJSONStringEnd(raw []byte, start int) int { + for i := start + 1; ; i++ { + if raw[i] == '\\' { + i++ + } else if raw[i] == '"' { + return i + 1 + } + } +} + +func responsesJSONStart(raw []byte, start int) int { + for start < len(raw) { + switch raw[start] { + case ' ', '\t', '\r', '\n', ',', ':': + start++ + default: + return start + } + } + return start +} + +func indexResponsesJSONContainers(raw []byte) []responsesJSONContainer { + // Two passes allocate exactly the required index. Only array elements and + // object content fields can be traversed by the protocol collector; opaque + // fields (tool output/arguments, metadata, URLs) need no descendant entries. + containers := make([]responsesJSONContainer, scanResponsesJSONContainers(raw, nil)) + scanResponsesJSONContainers(raw, containers) + return containers +} + +func scanResponsesJSONContainers(raw []byte, containers []responsesJSONContainer) int { + type frame struct { + index int + object bool + } + position := responsesJSONStart(raw, 0) + stack := []frame{{index: 0, object: raw[position] == '{'}} + next := 1 + position++ + for len(stack) > 0 { + position = responsesJSONStart(raw, position) + parent := stack[len(stack)-1] + if raw[position] == ']' || raw[position] == '}' { + if containers != nil { + containers[parent.index] = responsesJSONContainer{end: position + 1, next: next} + } + stack = stack[:len(stack)-1] + position++ + continue + } + if parent.object { + end := responsesJSONStringEnd(raw, position) + content := bytes.EqualFold(responsesJSONFieldName(raw, position, end), []byte("content")) + position = responsesJSONStart(raw, end) + if !content { + position = responsesJSONValueEnd(raw, position) + continue + } + } + if raw[position] == '[' || raw[position] == '{' { + stack = append(stack, frame{index: next, object: raw[position] == '{'}) + next++ + position++ + } else { + position = responsesJSONValueEnd(raw, position) + } + } + return next +} + +func responsesJSONValueEnd(raw []byte, start int) int { + if raw[start] == '"' { + return responsesJSONStringEnd(raw, start) + } + if raw[start] != '[' && raw[start] != '{' { + end := start + for end < len(raw) && !bytes.ContainsRune([]byte(" \t\r\n,]}"), rune(raw[end])) { + end++ + } + return end + } + depth := 1 + for i := start + 1; ; i++ { + switch raw[i] { + case '"': + i = responsesJSONStringEnd(raw, i) - 1 + case '[', '{': + depth++ + case ']', '}': + depth-- + if depth == 0 { + return i + 1 + } + } + } +} + +func responsesJSONFieldName(raw []byte, start, end int) []byte { + name := raw[start+1 : end-1] + if bytes.IndexByte(name, '\\') < 0 { + return name + } + var decoded string + _ = json.Unmarshal(raw[start:end], &decoded) + return []byte(decoded) +} + +func nextResponsesJSONValue(raw []byte, start, next int, containers []responsesJSONContainer) responsesJSONValue { + start = responsesJSONStart(raw, start) + value := responsesJSONValue{start: start, container: -1, next: next} + switch raw[start] { + case '[', '{': + value.container = next + value.end, value.next = containers[next].end, containers[next].next + default: + value.end = responsesJSONValueEnd(raw, start) + } + return value +} + +// Only typed string fields affect whether the old collector traverses a +// message. Decode them in source order, preserving duplicate-null and any +// type-error behavior. Raw content selects its last occurrence unchanged. +func responsesMessageContent(raw []byte, containers []responsesJSONContainer, value responsesJSONValue) (string, responsesJSONValue, bool) { + if raw[value.start] != '{' { + return "", responsesJSONValue{}, false + } + itemType, role, ignored := "", "", "" + content := responsesJSONValue{container: -1} + position, next := responsesJSONStart(raw, value.start+1), value.container+1 + for raw[position] != '}' { + nameEnd := responsesJSONStringEnd(raw, position) + name := responsesJSONFieldName(raw, position, nameEnd) + fieldStart := responsesJSONStart(raw, nameEnd) + field := responsesJSONValue{start: fieldStart, container: -1, next: next} + if bytes.EqualFold(name, []byte("content")) { + field = nextResponsesJSONValue(raw, fieldStart, next, containers) + } else { + field.end = responsesJSONValueEnd(raw, fieldStart) + } + var target *string + switch { + case bytes.EqualFold(name, []byte("type")): + target = &itemType + case bytes.EqualFold(name, []byte("role")): + target = &role + case bytes.EqualFold(name, []byte("content")): + content = field + case bytes.EqualFold(name, []byte("text")), bytes.EqualFold(name, []byte("file_data")), bytes.EqualFold(name, []byte("detail")): + target = &ignored + } + if target != nil && json.Unmarshal(raw[field.start:field.end], target) != nil { + return "", responsesJSONValue{}, false + } + position, next = responsesJSONStart(raw, field.end), field.next + } + return role, content, (itemType == "" || itemType == "message") && role != "" && content.end > 0 +} diff --git a/apps/api-go/relaykit/dto/responses_token_input_bounds_test.go b/apps/api-go/relaykit/dto/responses_token_input_bounds_test.go new file mode 100644 index 000000000..fc040cc50 --- /dev/null +++ b/apps/api-go/relaykit/dto/responses_token_input_bounds_test.go @@ -0,0 +1,279 @@ +package dto + +import ( + "encoding/json" + "fmt" + "math/rand" + "strings" + "testing" + + "github.com/LIghtJUNction/api.lmm.best/relaykit/types" + "github.com/stretchr/testify/require" +) + +// Frozen de2c439 collector, used only with bounded fixtures to check exact +// compatibility independently of the new index/walk implementation. +func referenceResponsesTokenInput(raw json.RawMessage, texts *[]string, files *[]*types.FileMeta) { + var text string + if json.Unmarshal(raw, &text) == nil { + *texts = append(*texts, text) + return + } + var items []json.RawMessage + if json.Unmarshal(raw, &items) == nil { + for _, item := range items { + referenceResponsesTokenInput(item, texts, files) + } + return + } + var item struct { + Type string `json:"type"` + Role string `json:"role"` + Content json.RawMessage `json:"content"` + Text string `json:"text"` + ImageURL json.RawMessage `json:"image_url"` + FileURL json.RawMessage `json:"file_url"` + FileData string `json:"file_data"` + Detail string `json:"detail"` + } + if json.Unmarshal(raw, &item) == nil { + switch item.Type { + case "reasoning": + // encrypted_content is an opaque replay payload. Tokenizing its + // ciphertext as ordinary text can turn a normal prompt into millions + // of estimated tokens. Visible summary/content text is countable. + var reasoning struct { + Summary []struct { + Text string `json:"text"` + } `json:"summary"` + Content []struct { + Text string `json:"text"` + } `json:"content"` + } + if json.Unmarshal(raw, &reasoning) == nil { + for _, part := range reasoning.Summary { + *texts = append(*texts, part.Text) + } + for _, part := range reasoning.Content { + *texts = append(*texts, part.Text) + } + } + return + case "input_text", "output_text": + *texts = append(*texts, item.Text) + return + case "input_image": + if imageURL := responsesMediaURL(item.ImageURL); imageURL != "" { + *files = append(*files, &types.FileMeta{FileType: types.FileTypeImage, Source: types.NewFileSourceFromData(imageURL, ""), Detail: item.Detail}) + return + } + case "input_file": + data := responsesMediaURL(item.FileURL) + if data == "" { + data = item.FileData + } + if data != "" { + *files = append(*files, &types.FileMeta{FileType: types.FileTypeFile, Source: types.NewFileSourceFromData(data, "")}) + return + } + case "", "message": + if item.Role != "" && len(item.Content) > 0 { + *texts = append(*texts, item.Role) + referenceResponsesTokenInput(item.Content, texts, files) + return + } + } + } + *texts = append(*texts, normalizeRawJSONForTokenCount(raw)) +} + +func compareResponsesTokenInput(t *testing.T, input string) { + t.Helper() + var oldTexts, newTexts []string + var oldFiles, newFiles []*types.FileMeta + referenceResponsesTokenInput(json.RawMessage(input), &oldTexts, &oldFiles) + collectResponsesTokenInput(json.RawMessage(input), &newTexts, &newFiles) + require.Equal(t, oldTexts, newTexts, "input: %s", input) + require.Equal(t, oldFiles, newFiles, "input: %s", input) + for _, meta := range []*types.TokenCountMeta{ + (&OpenAIResponsesRequest{Input: json.RawMessage(input)}).GetTokenCountMeta(), + (&OpenAIResponsesCompactionRequest{Input: json.RawMessage(input)}).GetTokenCountMeta(), + } { + require.Equal(t, strings.Join(oldTexts, "\n"), meta.CombineText) + require.Equal(t, len(oldFiles), len(meta.Files)) + for i := range oldFiles { + require.Equal(t, oldFiles[i], meta.Files[i]) + } + } +} + +func TestResponsesTokenInputCompatibility(t *testing.T) { + inputs := []string{ + `null`, ` null `, `false`, `123`, `1e1000`, `-0.00E-3`, `""`, `"\u4e2d\uD83D\uDE00"`, `"\\u4e2d"`, + `[]`, `[null,"",["one","two"]]`, ` { "unknown": 1e1000, "x": "\u4e2d" } `, + `{"type":"message","role":"user","content":[{"type":"input_text","text":"hello"}]}`, + `{"role":"user","content":null}`, `{"role":"user","content":0}`, `{"role":"user","content":[]}`, + `{"role":"user","content":"first","content":"last"}`, `{"role":"user","content":"first","CONTENT":null}`, + `{"TYPE":"message","ROLE":"user","CONTENT":"upper"}`, `{"type":"message","type":null,"role":"user","role":null,"content":"kept"}`, + `{"role":"user","content":"counted","text":17}`, `{"role":"user","content":"counted","file_data":{}}`, + `{"role":"user","content":"counted","detail":[],"detail":"low"}`, `{"type":17,"type":"message","role":"user","content":"kept raw"}`, + `{"role":"user","content":"counted","image_url":{"invalid":"shape"},"file_url":false}`, + `{"type":"input_text","text":"first","text":null}`, `{"type":"output_text","text":"\u4e2d","role":12}`, + `{"type":"input_image","image_url":{"url":"data:image/png;base64,Zml4dHVyZQ=="},"detail":"high"}`, + `{"type":"input_image","image_url":{"url":"first","URL":null}}`, `{"type":"input_image","image_url":{"url":3,"url":"last"}}`, + `{"type":"input_file","file_url":"https://fixture.invalid/file","file_data":"fallback"}`, `{"type":"input_file","file_data":"data:application/pdf;base64,Zml4dHVyZQ=="}`, + `{"type":"function_call_output","output":{"content":[{"type":"input_image","image_url":"not-media"}]}}`, + `{"type":"future","role":"user","content":[{"type":"input_image","image_url":"not-media"}]}`, + `{"type":"reasoning","encrypted_content":"ciphertext","summary":[{"text":"visible"}],"content":[{"text":"visible content"}]}`, + `{"type":"reasoning","summary":[{"text":"first"}],"summary":[null]}`, + `{"type":"reasoning","SUMMARY":[{"text":"first","text":null}],"content":null}`, + `{"type":"reasoning","\u017fummary":[{"text":"casefold summary"}]}`, + `{"type":"reasoning","summary":[{"text":"discarded"},false],"encrypted_content":"ciphertext"}`, + `{"type":"reasoning","content":"not an array","encrypted_content":"ciphertext"}`, + `{"type":"reasoning","text":[],"encrypted_content":"raw fallback"}`, + `{"role":"user","content":"\uD800"}`, `{"role":"user","content":"\uDE00"}`, + ``, ` `, `[`, `{"role":"user","content":["incomplete"}`, `{"x":"\u12G4"}`, `true false`, `[] trailing`, + "{\"role\":\"user\",\"content\":\"\xff\"}", + } + for i, input := range inputs { + t.Run(fmt.Sprintf("fixture_%d", i), func(t *testing.T) { compareResponsesTokenInput(t, input) }) + } +} + +func TestResponsesTokenInputDeterministicDifferential(t *testing.T) { + random := rand.New(rand.NewSource(755)) + leaves := []string{ + `null`, `true`, `1e1000`, `"literal \\u4e2d"`, `"\u4e2d"`, + `{"type":"input_text","text":"visible"}`, `{"type":"input_text","text":17}`, + `{"type":"input_image","image_url":"data:image/png;base64,Zml4dHVyZQ=="}`, + `{"type":"input_file","file_url":{"url":"https://fixture.invalid/file"}}`, + `{"type":"reasoning","encrypted_content":"cipher","summary":[{"text":"summary"}]}`, + `{"type":"function_call_output","output":"tool text"}`, `{"unknown": "raw \u4e2d", "unknown": null}`, + } + var generate func(int) string + generate = func(depth int) string { + if depth == 0 || random.Intn(3) == 0 { + return leaves[random.Intn(len(leaves))] + } + switch random.Intn(6) { + case 0: + return "[" + generate(depth-1) + "," + generate(depth-1) + "]" + case 1: + return `{"role":"user","content":` + generate(depth-1) + `}` + case 2: + return `{"type":"message","TYPE":null,"role":"user","content":` + generate(depth-1) + `,"CONTENT":` + generate(depth-1) + `}` + case 3: + return `{"ROLE":"user","content":` + generate(depth-1) + `,"detail":` + generate(depth-1) + `}` + case 4: + return ` {"type":"future","content":` + generate(depth-1) + `} ` + default: + return `{"type":"reasoning","summary":` + generate(depth-1) + `,"encrypted_content":"ciphertext"}` + } + } + for i := range 400 { + t.Run(fmt.Sprintf("case_%d", i), func(t *testing.T) { compareResponsesTokenInput(t, generate(4)) }) + } +} + +func TestResponsesTokenInputDeepContainersPreserveAllText(t *testing.T) { + for _, depth := range []int{128, 2048, 9999} { + t.Run(fmt.Sprintf("arrays_%d", depth), func(t *testing.T) { + input := strings.Repeat("[", depth) + `"deep text"` + strings.Repeat("]", depth) + for _, meta := range []*types.TokenCountMeta{ + (&OpenAIResponsesRequest{Input: json.RawMessage(input)}).GetTokenCountMeta(), + (&OpenAIResponsesCompactionRequest{Input: json.RawMessage(input)}).GetTokenCountMeta(), + } { + require.Equal(t, "deep text", meta.CombineText) + } + }) + } + const depth = 2048 + input := strings.Repeat(`{"role":"user","content":`, depth) + `"deep text"` + strings.Repeat("}", depth) + meta := (&OpenAIResponsesRequest{Input: json.RawMessage(input)}).GetTokenCountMeta() + require.Equal(t, strings.Repeat("user\n", depth)+"deep text", meta.CombineText) + tooDeep := strings.Repeat("[", 10001) + `"full fallback"` + strings.Repeat("]", 10001) + meta = (&OpenAIResponsesRequest{Input: json.RawMessage(tooDeep)}).GetTokenCountMeta() + require.Equal(t, tooDeep, meta.CombineText, "out-of-parser-bound input retains its full fallback instead of being truncated") +} + +func BenchmarkResponsesTokenInputNesting(b *testing.B) { + for _, shape := range []string{"array", "message"} { + for _, depth := range []int{128, 512, 2048} { + prefix, suffix := "[", "]" + if shape == "message" { + prefix, suffix = `{"role":"user","content":`, "}" + } + input := json.RawMessage(strings.Repeat(prefix, depth) + `"bounded local fixture"` + strings.Repeat(suffix, depth)) + for _, implementation := range []struct { + name string + collect func(json.RawMessage, *[]string, *[]*types.FileMeta) + }{{"indexed", collectResponsesTokenInput}, {"reference", referenceResponsesTokenInput}} { + b.Run(fmt.Sprintf("%s/%d/%s", shape, depth, implementation.name), func(b *testing.B) { + b.ReportAllocs() + b.SetBytes(int64(len(input))) + for b.Loop() { + var texts []string + var files []*types.FileMeta + implementation.collect(input, &texts, &files) + } + }) + } + } + } +} + +func BenchmarkResponsesTokenInputDense(b *testing.B) { + for _, count := range []int{1024, 16384} { + for _, shape := range []string{"array", "unknown", "tool"} { + input := "[" + strings.Repeat("0,", count-1) + "0]" + if shape != "array" { + input = "{" + strings.Repeat(`"x":0,`, count-1) + `"x":0}` + if shape == "tool" { + input = `{"type":"function_call_output","output":` + input + "}" + } + } + for _, implementation := range []struct { + name string + collect func(json.RawMessage, *[]string, *[]*types.FileMeta) + }{{"indexed", collectResponsesTokenInput}, {"reference", referenceResponsesTokenInput}} { + b.Run(fmt.Sprintf("%s/%d/%s", shape, count, implementation.name), func(b *testing.B) { + b.ReportAllocs() + b.SetBytes(int64(len(input))) + for b.Loop() { + var texts []string + var files []*types.FileMeta + implementation.collect(json.RawMessage(input), &texts, &files) + } + }) + } + } + } +} + +func BenchmarkResponsesTokenInputOpaqueContainers(b *testing.B) { + for _, count := range []int{1024, 16384} { + payload := "[" + strings.Repeat("[],", count-1) + "[]]" + for _, shape := range []string{"root", "input_array", "message_array"} { + input := `{"payload":` + payload + `,"type":"future"}` + if shape == "input_array" { + input = "[" + input + "]" + } else if shape == "message_array" { + input = `[{"role":"user","content":[` + input + "]}]" + } + for _, implementation := range []struct { + name string + collect func(json.RawMessage, *[]string, *[]*types.FileMeta) + }{{"indexed", collectResponsesTokenInput}, {"reference", referenceResponsesTokenInput}} { + b.Run(fmt.Sprintf("%s/%d/%s", shape, count, implementation.name), func(b *testing.B) { + b.ReportAllocs() + b.SetBytes(int64(len(input))) + for b.Loop() { + var texts []string + var files []*types.FileMeta + implementation.collect(json.RawMessage(input), &texts, &files) + } + }) + } + } + } +} diff --git a/apps/api-go/router/business_admin_isolation_test.go b/apps/api-go/router/business_admin_isolation_test.go index bcb7180d4..3da362bd3 100644 --- a/apps/api-go/router/business_admin_isolation_test.go +++ b/apps/api-go/router/business_admin_isolation_test.go @@ -225,14 +225,22 @@ func TestBI10RealAdminGatesIgnoreForgedRoleHeaders(t *testing.T) { func TestBI10RealRoutesRejectRotatedPAT(t *testing.T) { fixture := bi10HTTP(t) actor := fixture.actors["a"] - bi10OwnExport(t, fixture, actor, actor.pat) + // AccessToken points to actor.pat, so GORM updates to actor.user can also + // mutate the fixture credential. Preserve the actual pre-rotation value. + originalPAT := actor.pat + bi10OwnExport(t, fixture, actor, originalPAT) before := bi10Row(t, fixture.db, actor.key.Id) // This is a stored revocation fixture, not a claim that the account's PAT // rotation controller has been tested. That controller needs separate tests. - require.NoError(t, fixture.db.Model(&actor.user).Update("access_token", "bi10-replacement-pat").Error) - response := fixture.request(http.MethodDelete, fmt.Sprintf("/api/token/%d", actor.key.Id), actor.pat, "") + const replacementPAT = "bi10-replacement-pat" + updated := fixture.db.Model(&actor.user).Update("access_token", replacementPAT) + require.NoError(t, updated.Error) + require.EqualValues(t, 1, updated.RowsAffected) + response := fixture.request(http.MethodDelete, fmt.Sprintf("/api/token/%d", actor.key.Id), originalPAT, "") bi10Denied(t, response) require.Equal(t, before, bi10Row(t, fixture.db, actor.key.Id)) + bi10OwnExport(t, fixture, actor, replacementPAT) + require.Equal(t, before, bi10Row(t, fixture.db, actor.key.Id)) } func TestBI10RealRoutesRejectExpiredStoredSession(t *testing.T) { diff --git a/apps/api-go/router/oauth_authorization_storage_test.go b/apps/api-go/router/oauth_authorization_storage_test.go new file mode 100644 index 000000000..45db43afc --- /dev/null +++ b/apps/api-go/router/oauth_authorization_storage_test.go @@ -0,0 +1,47 @@ +package router + +import ( + "fmt" + "net/http" + "net/url" + "testing" + "time" + + "github.com/LIghtJUNction/api.lmm.best/model" + "github.com/LIghtJUNction/api.lmm.best/oauthserver" + "github.com/LIghtJUNction/api.lmm.best/service" + "github.com/stretchr/testify/require" +) + +func TestOAuthHTTPAuthorizationStoragePressureReturns503(t *testing.T) { + for _, stage := range []string{"preflight", "authenticated continuation"} { + t.Run(stage, func(t *testing.T) { + h := setupOAuthHTTP(t) + var cookie *http.Cookie + var csrf string + seedCount := oauthserver.MaxAuthorizationRows + if stage == "authenticated continuation" { + cookie, csrf = h.begin(t) + seedCount-- + } + rows := make([]model.OAuthServerAuthorization, seedCount) + for i := range rows { + rows[i] = model.OAuthServerAuthorization{Digest: fmt.Sprintf("capacity-row-%d", i), Issuer: h.integration.Issuer, ExpiresAtMs: time.Now().Add(time.Minute).UnixMilli()} + } + require.NoError(t, h.db.CreateInBatches(rows, 100).Error) + response := h.request("GET", "/api/oauth2/authorize?"+h.query, "", nil) + if stage == "authenticated continuation" { + response = h.request("POST", "/api/user/auth/oauth2/continue", url.Values{"csrf": {csrf}}.Encode(), map[string]string{ + "Origin": oauthTestIssuer, "Content-Type": "application/x-www-form-urlencoded", + }, cookie, &http.Cookie{Name: service.RefreshCookieName, Value: h.login.RefreshToken}) + } + require.Equal(t, http.StatusServiceUnavailable, response.Code) + require.Equal(t, "no-store", response.Header().Get("Cache-Control")) + var count int64 + require.NoError(t, h.db.Model(&model.OAuthServerAuthorization{}).Count(&count).Error) + require.EqualValues(t, oauthserver.MaxAuthorizationRows, count) + require.NoError(t, h.db.Model(&model.OAuthServerGrant{}).Count(&count).Error) + require.Zero(t, count) + }) + } +} diff --git a/apps/api-go/service/auth_cleanup.go b/apps/api-go/service/auth_cleanup.go index 5e234d11d..79c1d88e1 100644 --- a/apps/api-go/service/auth_cleanup.go +++ b/apps/api-go/service/auth_cleanup.go @@ -66,6 +66,20 @@ func cleanupAuthArtifacts() { if err := model.DeleteExpiredAuthFlows(now); err != nil { common.SysError("failed to delete expired authentication flows: " + err.Error()) } + if model.DB.Migrator().HasTable(&model.OAuthServerAuthorization{}) { + ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second) + defer cancel() + for batch := 0; batch < 20; batch++ { + count, err := model.CleanupExpiredOAuthAuthorizations(model.DB.WithContext(ctx), "", time.Now()) + if err != nil { + common.SysError("failed to delete expired OAuth browser transactions: " + err.Error()) + break + } + if count < model.OAuthAuthorizationCleanupBatchSize { + break + } + } + } // A minimal test database or a node still completing its first migration // may not have assistant storage yet. The next hourly pass will pick it up. if model.DB.Migrator().HasTable(&model.AssistantSecureCard{}) { diff --git a/apps/api-go/service/oauth_authorization_cleanup_test.go b/apps/api-go/service/oauth_authorization_cleanup_test.go new file mode 100644 index 000000000..af02a7e07 --- /dev/null +++ b/apps/api-go/service/oauth_authorization_cleanup_test.go @@ -0,0 +1,25 @@ +package service + +import ( + "testing" + "time" + + "github.com/LIghtJUNction/api.lmm.best/model" + "github.com/stretchr/testify/require" +) + +func TestCleanupAuthArtifactsIncludesExpiredOAuthBrowserState(t *testing.T) { + setupAuthSessionTestDB(t) + require.NoError(t, model.MigrateOAuthServer(model.DB)) + now := time.Now() + require.NoError(t, model.DB.Create(&[]model.OAuthServerAuthorization{ + {Digest: "expired-oauth-browser", Issuer: "https://local.example.test", ExpiresAtMs: now.Add(-time.Minute).UnixMilli()}, + {Digest: "live-oauth-browser", Issuer: "https://local.example.test", ExpiresAtMs: now.Add(time.Minute).UnixMilli(), BrowserCSRFHash: "live-one-time-csrf"}, + }).Error) + cleanupAuthArtifacts() + var rows []model.OAuthServerAuthorization + require.NoError(t, model.DB.Find(&rows).Error) + require.Len(t, rows, 1) + require.Equal(t, "live-oauth-browser", rows[0].Digest) + require.Equal(t, "live-one-time-csrf", rows[0].BrowserCSRFHash) +} diff --git a/apps/api-go/service/relay_error.go b/apps/api-go/service/relay_error.go index beb79c909..36da9ee66 100644 --- a/apps/api-go/service/relay_error.go +++ b/apps/api-go/service/relay_error.go @@ -16,6 +16,11 @@ import ( ) func ShouldRetryRelayError(c *gin.Context, apiErr *types.NewAPIError, retryTimes int) bool { + // Acceptance is request-scoped and overrides even channel errors or status + // mappings: another attempt would submit a second asynchronous provider job. + if c != nil && common.GetContextKeyBool(c, constant.ContextKeyUpstreamAsyncTaskAccepted) { + return false + } if c != nil && (common.GetContextKeyBool(c, constant.ContextKeyHTTPStreamCommitted) || common.GetContextKeyBool(c, constant.ContextKeyHTTPStreamDownstreamFailure)) { return false } diff --git a/apps/api-go/service/relay_error_test.go b/apps/api-go/service/relay_error_test.go index 608022e37..3485ad507 100644 --- a/apps/api-go/service/relay_error_test.go +++ b/apps/api-go/service/relay_error_test.go @@ -79,3 +79,27 @@ func TestShouldRetryRelayErrorSkipsClientDisconnect(t *testing.T) { ) assert.False(t, ShouldRetryRelayError(c, apiErr, 1)) } + +func TestAcceptedAsyncTaskOverridesRetryAndStaysRequestScoped(t *testing.T) { + for _, tc := range []struct { + name string + apiErr *types.NewAPIError + capability bool + }{ + {"channel_error", types.NewError(errors.New("fixture"), types.ErrorCodeChannelNoAvailableKey), false}, + {"mapped_capability_error", types.NewErrorWithStatusCode(errors.New("fixture"), types.ErrorCodeBadResponse, 400), true}, + {"upstream_timeout", types.NewErrorWithStatusCode(errors.New("fixture"), types.ErrorCodeUpstreamTimeout, 504), false}, + } { + t.Run(tc.name, func(t *testing.T) { + c, _ := gin.CreateTestContext(httptest.NewRecorder()) + c.Request = httptest.NewRequest("POST", "/v1/images/generations", nil) + common.SetContextKey(c, constant.ContextKeyUpstreamCapabilityMismatch, tc.capability) + assert.True(t, ShouldRetryRelayError(c, tc.apiErr, 2)) + common.SetContextKey(c, constant.ContextKeyUpstreamAsyncTaskAccepted, true) + assert.False(t, ShouldRetryRelayError(c, tc.apiErr, 2)) + fresh, _ := gin.CreateTestContext(httptest.NewRecorder()) + common.SetContextKey(fresh, constant.ContextKeyUpstreamCapabilityMismatch, tc.capability) + assert.True(t, ShouldRetryRelayError(fresh, tc.apiErr, 2)) + }) + } +} diff --git a/apps/api-go/service/signalgames/circuit.go b/apps/api-go/service/signalgames/circuit.go index 16789ef28..720499334 100644 --- a/apps/api-go/service/signalgames/circuit.go +++ b/apps/api-go/service/signalgames/circuit.go @@ -9,13 +9,14 @@ import ( ) const RulesVersion = 2 +const maxBoardSize = 64 var ports = []int{1, 2, 4, 8} var shapes = []int{3, 6, 12, 9, 5, 10} func ValidSize(size int) bool { switch size { - case 5, 8, 12, 24, 48, 64: + case 5, 8, 12, 24, 48, maxBoardSize: return true } return false @@ -60,10 +61,16 @@ func Won(tiles []int, size int) bool { if !ValidSize(size) || len(tiles) != size*size { return false } - seen := make([]bool, len(tiles)) + // A fixed bitset covers every supported board without a heap allocation + // for each move checked by Replay. The traversal and cycle rule are unchanged. + var seen [maxBoardSize * maxBoardSize / 64]uint64 index, incoming := size/2*size, 8 - for !seen[index] && tiles[index]&incoming != 0 { - seen[index] = true + for tiles[index]&incoming != 0 { + word, bit := index/64, uint64(1)< shortAllocs+1 { + t.Fatalf("per-move allocations remain: short=%g long=%g", shortAllocs, longAllocs) + } +} + +func TestSignalGameReplayPreservesPublicMoveBudget(t *testing.T) { + for _, size := range []int{5, 8, 12, 24, 48, 64} { + t.Run(fmt.Sprint(size), func(t *testing.T) { + actions := paddedSignalSolution(t, size) + if MaxMoves(size)-len(actions) > 3 { + t.Fatal("fixture did not exercise the public move budget") + } + if _, err := Replay(42, size, actions, false); err != nil { + t.Fatalf("legitimate long challenge rejected: %v", err) + } + if _, err := Replay(42, size, append(actions, 0), false); err == nil { + t.Fatal("accepted a move after completion") + } + if _, err := Replay(42, size, make([]int, MaxMoves(size)+1), true); err == nil { + t.Fatal("practice accepted an oversized replay") + } + }) + } +} + +func BenchmarkSignalGameReplayPublicBudget(b *testing.B) { + actions := paddedSignalSolution(b, 64) + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + if _, err := Replay(42, 64, actions, false); err != nil { + b.Fatal(err) + } + } +}